implab/implabjs-core Commit - r75:682bf9cf6f0c

added safe.firstWhere

cin -

r75:682bf9cf6f0c default

parent child

Context file:

r75:682bf9cf6f0c

Collapse all files

.vscode/settings.json 0 -1

             {
                 "java.configuration.updateBuildConfiguration": "disabled",
-                "tslint.enable": true,
                 "search.exclude": {
                     "**/node_modules": true,
                     "**/bower_components": true,
                     "/build": true
                 },
                 "files.watcherExclude": {
                     "**/.git/objects/**": true,
                     "**/.git/subtree-cache/**": true,
                     "**/node_modules/**": true,
                     "/build": true
                 },
                 "editor.minimap.enabled": false
             }

src/main/ts/interfaces.ts +9 -2

-            export type Constructor<T = {}> = new (...args: any[]) => T;
+            export interface Constructor<T = {}> {
+                new (...args: any[]): T;
+                prototype: T;
+            }
             export type Factory<T = {}> = (...args: any[]) => T;
             export type Predicate<T = any> = (x: T) => boolean;
             export interface MapOf<T> {
                 [key: string]: T;
             }
             export interface IDestroyable {
-                destroy();
+                destroy(): void;
+            }
+            export interface IRemovable {
+                remove(): void;
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation): Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * can be activated and manages the active state of the
                  * component
                  */
                 setActivationController(controller: IActivationController);
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                 next(ct?: ICancellation): Promise<T>;
             }

src/main/ts/safe.ts +97 -29

-            import { ICancellable } from "./interfaces";
+            import { ICancellable, Constructor } from "./interfaces";
             let _nextOid = 0;
             const _oid = typeof Symbol === "function" ?
                 Symbol("__implab__oid__") :
                 "__implab__oid__";
-            declare const window: any;
-            declare const global: any;
             export function oid(instance: object): string {
                 if (isNull(instance))
                     return null;
                 if (_oid in instance)
                     return instance[_oid];
                 else
                     return (instance[_oid] = "oid_" + (++_nextOid));
             }
-            export function argumentNotNull(arg, name) {
+            export function argumentNotNull(arg: any, name: string) {
                 if (arg === null || arg === undefined)
                     throw new Error("The argument " + name + " can't be null or undefined");
             }
-            export function argumentNotEmptyString(arg, name) {
+            export function argumentNotEmptyString(arg: any, name: string) {
                 if (typeof (arg) !== "string" || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty string");
             }
-            export function argumentNotEmptyArray(arg, name) {
+            export function argumentNotEmptyArray(arg: any, name: string) {
                 if (!(arg instanceof Array) || !arg.length)
                     throw new Error("The argument '" + name + "' must be a not empty array");
             }
-            export function argumentOfType(arg, type, name) {
+            export function argumentOfType(arg: any, type: Constructor<{}>, name: string) {
                 if (!(arg instanceof type))
                     throw new Error("The argument '" + name + "' type doesn't match");
             }
-            export function isNull(arg) {
+            export function isNull(val: any) {
-                return (arg === null || arg === undefined);
+                return (val === null || val === undefined);
             }
-            export function isPrimitive(arg): arg is string | number | boolean | undefined | null {
+            export function isPrimitive(val: any): val is string | number | boolean | undefined | null {
-                return (arg === null || arg === undefined || typeof (arg) === "string" ||
+                return (val === null || val === undefined || typeof (val) === "string" ||
-                    typeof (arg) === "number" || typeof (arg) === "boolean");
+                    typeof (val) === "number" || typeof (val) === "boolean");
             }
-            export function isInteger(arg): arg is number {
+            export function isInteger(val: any): val is number {
-                return parseInt(arg, 10) === arg;
+                return parseInt(val, 10) === val;
             }
-            export function isNumber(arg): arg is number {
+            export function isNumber(val: any): val is number {
-                return parseFloat(arg) === arg;
+                return parseFloat(val) === val;
             }
-            export function isString(val): val is string {
+            export function isString(val: any): val is string {
                 return typeof (val) === "string" || val instanceof String;
             }
-            export function isPromise(val): val is PromiseLike<any> {
+            export function isPromise(val: any): val is PromiseLike<any> {
                 return val && typeof val.then === "function";
             }
-            export function isCancellable(val): val is ICancellable {
+            export function isCancellable(val: any): val is ICancellable {
                 return val && typeof val.cancel === "function";
             }
-            export function isNullOrEmptyString(str) {
+            export function isNullOrEmptyString(val: any): val is string | null | undefined {
-                if (str === null || str === undefined ||
+                if (val === null || val === undefined ||
-                    ((typeof (str) === "string" || str instanceof String) && str.length === 0))
+                    ((typeof (val) === "string" || val instanceof String) && val.length === 0))
                     return true;
             }
-            export function isNotEmptyArray(arg): arg is Array<any> {
+            export function isNotEmptyArray(arg: any): arg is Array<any> {
                 return (arg instanceof Array && arg.length > 0);
             }
             function _isStrictMode() {
                 return !this;
             }
             function _getNonStrictGlobal() {
                 return this;
             }
             export function getGlobal() {
                 // in es3 we can't use indirect call to eval, since it will
                 // be executed in the current call context.
                 if (!_isStrictMode()) {
                     return _getNonStrictGlobal();
                 } else {
                     // tslint:disable-next-line:no-eval
                     return eval.call(null, "this");
                 }
             }
             export function get(member: string, context?: object) {
                 argumentNotEmptyString(member, "member");
                 let that = context || getGlobal();
                 const parts = member.split(".");
                 for (const m of parts) {
                     if (!m)
                         continue;
                     if (isNull(that = that[m]))
                         break;
                 }
                 return that;
             }
             /**
              * Выполняет метод для каждого элемента массива, останавливается, когда
              * либо достигнут конец массива, либо функция <c>cb</c> вернула
              * значение.
              *
              * @param {Array | Object} obj массив элементов для просмотра
              * @param {Function} cb функция, вызываемая для каждого элемента
              * @param {Object} thisArg значение, которое будет передано в качестве
              *                <c>this</c> в <c>cb</c>.
              * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
              *          если достигнут конец массива.
              */
             export function each(obj, cb, thisArg?) {
                 argumentNotNull(cb, "cb");
                 if (obj instanceof Array) {
                     for (let i = 0; i < obj.length; i++) {
                         const x = cb.call(thisArg, obj[i], i);
                         if (x !== undefined)
                             return x;
                     }
                 } else {
                     const keys = Object.keys(obj);
                     for (const k of keys) {
                         const x = cb.call(thisArg, obj[k], k);
                         if (x !== undefined)
                             return x;
                     }
                 }
             }
             /** Copies property values from a source object to the destination and returns
              * the destination onject.
              *
              * @param dest The destination object into which properties from the source
              *  object will be copied.
              * @param source The source of values which will be copied to the destination
              *  object.
              * @param template An optional parameter specifies which properties should be
              *  copied from the source and how to map them to the destination. If the
              *  template is an array it contains the list of property names to copy from the
              *  source to the destination. In case of object the templates contains the map
              *  where keys are property names in the source and the values are property
              *  names in the destination object. If the template isn't specified then the
              *  own properties of the source are entirely copied to the destination.
              *
              */
             export function mixin<T, S>(dest: T, source: S, template?: string[] | object): T & S {
                 argumentNotNull(dest, "to");
                 const _res = dest as T & S;
                 if (isPrimitive(source))
                     return _res;
                 if (template instanceof Array) {
                     for (const p of template) {
                         if (p in source)
                             _res[p] = source[p];
                     }
                 } else if (template) {
                     const keys = Object.keys(source);
                     for (const p of keys) {
                         if (p in template)
                             _res[template[p]] = source[p];
                     }
                 } else {
                     const keys = Object.keys(source);
                     for (const p of keys)
                         _res[p] = source[p];
                 }
                 return _res;
             }
             /** Wraps the specified function to emulate an asynchronous execution.
              * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
              * @param{Function|String} fn [Required] Function wich will be wrapped.
              */
             export function async(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> {
                 let fn = _fn;
                 if (arguments.length === 2 && !(fn instanceof Function))
                     fn = thisArg[fn];
                 if (fn == null)
                     throw new Error("The function must be specified");
                 function wrapresult(x, e?): PromiseLike<any> {
                     if (e) {
                         return {
                             then(cb, eb) {
                                 try {
                                     return eb ? wrapresult(eb(e)) : this;
                                 } catch (e2) {
                                     return wrapresult(null, e2);
                                 }
                             }
                         };
                     } else {
                         if (x && x.then)
                             return x;
                         return {
                             then(cb) {
                                 try {
                                     return cb ? wrapresult(cb(x)) : this;
                                 } catch (e2) {
                                     return wrapresult(e2);
                                 }
                             }
                         };
                     }
                 }
                 return (...args) => {
                     try {
                         return wrapresult(fn.apply(thisArg, args));
                     } catch (e) {
                         return wrapresult(null, e);
                     }
                 };
             }
             type _AnyFn = (...args) => any;
             export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
                 let method;
                 if (!(_method instanceof Function)) {
                     argumentNotNull(target, "target");
                     method = target[_method];
                     if (!(method instanceof Function))
                         throw new Error("'method' argument must be a Function or a method name");
                 } else {
                     method = _method;
                 }
                 return (...args) => {
                     return method.apply(target, args);
                 };
             }
             /**
              * Для каждого элемента массива вызывает указанную функцию и сохраняет
              * возвращенное значение в массиве результатов.
              *
              * @remarks cb может выполняться асинхронно, при этом одновременно будет
              *          только одна операция.
              *
              * @async
              */
             export function pmap(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items))
                     return items.then(data => pmap(data, cb));
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 const result = [];
                 function next() {
                     let r;
                     let ri;
                     function chain(x) {
                         result[ri] = x;
                         return next();
                     }
                     while (i < items.length) {
                         r = cb(items[i], i);
                         ri = i;
                         i++;
                         if (isPromise(r)) {
                             return r.then(chain);
                         } else {
                             result[ri] = r;
                         }
                     }
                     return result;
                 }
                 return next();
             }
             export function pfor(items, cb) {
                 argumentNotNull(cb, "cb");
                 if (isPromise(items))
                     return items.then(data => {
                         return pmap(data, cb);
                     });
                 if (isNull(items) || !items.length)
                     return items;
                 let i = 0;
                 function next() {
                     while (i < items.length) {
                         const r = cb(items[i], i);
                         i++;
                         if (isPromise(r))
                             return r.then(next);
                     }
                 }
                 return next();
             }
+            export function first<T>(sequence: ArrayLike<T>): T;
+            export function first<T>(sequence: PromiseLike<ArrayLike<T>>): PromiseLike<T>;
+            export function first<T>(
+                sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
+                cb: (x: T) => void,
+                err?: (x: Error) => void
+            ): void;
             /**
              * Выбирает первый элемент из последовательности, или обещания, если в
              * качестве параметра используется обещание, оно должно вернуть массив.
              *
              * @param {Function} cb обработчик результата, ему будет передан первый
              *                  элемент последовательности в случае успеха
              * @param {Function} err обработчик исключения, если массив пустой, либо
              *                  не массив
              *
              * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
              *          обещание, либо первый элемент.
              * @async
              */
-            export function first(sequence, cb: (x) => any, err: (x) => any) {
+            export function first<T>(
-                if (sequence) {
+                sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
+                cb?: (x: T) => void,
+                err?: (x: Error) => void
+            ) {
                 if (isPromise(sequence)) {
                     return sequence.then(res => first(res, cb, err));
                 } else if (sequence && "length" in sequence) {
                     if (sequence.length === 0) {
                         if (err)
                             return err(new Error("The sequence is empty"));
                         else
                             throw new Error("The sequence is empty");
+                    } else if (cb) {
+                        cb(sequence[0]);
+                    } else {
+                        return sequence[0];
                     }
-                        return cb ? cb(sequence[0]) : sequence[0];
+                } else {
+                    if (err)
+                        err(new Error("The sequence is required"));
+                    else
+                        throw new Error("The sequence is required");
                 }
             }
+            export function firstWhere<T>(
+                sequence: ArrayLike<T>,
+                predicate: (x: T) => boolean
+            ): T;
+            export function firstWhere<T>(
+                sequence: PromiseLike<ArrayLike<T>>,
+                predicate: (x: T) => boolean
+            ): PromiseLike<T>;
+            export function firstWhere<T>(
+                sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
+                predicate: (x: T) => boolean,
+                cb: (x: T) => void,
+                err?: (x: Error) => void
+            ): void;
+            export function firstWhere<T>(
+                sequence: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
+                predicate?: (x: T) => boolean,
+                cb?: (x: T) => void,
+                err?: (x: Error) => void
+            ) {
+                if (isPromise(sequence)) {
+                    return sequence.then(res => firstWhere(res, predicate, cb, err));
+                } else if (sequence && "length" in sequence) {
+                    if (sequence.length === 0) {
                         if (err)
-                    return err(new Error("The sequence is required"));
+                            err(new Error("The sequence is empty"));
+                        else
+                            throw new Error("The sequence is empty");
+                    } else {
+                        if (!predicate) {
+                            return cb ? cb(sequence[0]) : sequence[0];
+                        } else {
+                            for (let i = 0; i < sequence.length; i++) {
+                                const v = sequence[i];
+                                if (predicate(v))
+                                    return cb ? cb(v) : v;
+                            }
+                            if (err)
+                                err(new Error("The sequence doesn't contain matching items"));
+                            else
+                                throw new Error("The sequence doesn't contain matching items");
+                        }
+                    }
+                } else {
+                    if (err)
+                        err(new Error("The sequence is required"));
                     else
                         throw new Error("The sequence is required");
                 }
+            }
-            export function destroy(d) {
+            export function destroy(d: any) {
                 if (d && "destroy" in d)
                     d.destroy();
             }
+            /**
+             * Used to mark that the async operation isn't awaited intentionally.
+             * @param p The promise which represents the async operation.
+             */
+            export function nowait(p: Promise<any>) {
+            }

tslint.json +3 -1

             {
                 "extends": "tslint:recommended",
                 "rules": {
                     "align": [
                         true,
                         "parameters",
                         "statements"
                     ],
                     "interface-name": [false],
                     "max-line-length": [ true, 185 ],
                     "member-access": false,
                     "member-ordering": [
                         false,
                         "variables-before-functions"
                     ],
                     "no-bitwise": false,
                     "no-empty": false,
                     "no-namespace": false,
-                    "no-string-literal": false,
                     "ordered-imports": false,
+                    "no-return-await": true,
+                    "no-floating-promises": true,
+                    "prefer-for-of": false,
                     "one-line": [
                         true,
                         "check-open-brace",
                         "check-catch",
                         "check-whitespace"
                     ],
                     "object-literal-sort-keys": false,
                     "trailing-comma": [
                         true,
                         {
                             "singleline": "never",
                             "multiline": "never"
                         }
                     ],
                     "variable-name": false,
                     "curly": false,
                     "array-type": false,
                     "arrow-parens": [true, "ban-single-arg-parens"]
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages