safe.ts
306 lines
| 9.5 KiB
| video/mp2t
|
TypeScriptLexer
cin
|
r34 | let _nextOid = 0; | ||
|
cin
|
r41 | const _oid = typeof Symbol === "function" ? Symbol("__oid") : "__oid"; | ||
|
cin
|
r34 | |||
|
cin
|
r39 | export function oid(instance: object): string { | ||
|
cin
|
r34 | if (isNull(instance)) | ||
| return null; | ||||
| if (_oid in instance) | ||||
| return instance[_oid]; | ||||
| else | ||||
| return (instance[_oid] = "oid_" + (++_nextOid)); | ||||
| } | ||||
|
cin
|
r16 | export function argumentNotNull(arg, name) { | ||
| if (arg === null || arg === undefined) | ||||
| throw new Error("The argument " + name + " can't be null or undefined"); | ||||
| } | ||||
| export function argumentNotEmptyString(arg, name) { | ||||
| if (typeof (arg) !== "string" || !arg.length) | ||||
| throw new Error("The argument '" + name + "' must be a not empty string"); | ||||
| } | ||||
| export function argumentNotEmptyArray(arg, name) { | ||||
| if (!(arg instanceof Array) || !arg.length) | ||||
| throw new Error("The argument '" + name + "' must be a not empty array"); | ||||
| } | ||||
| export function argumentOfType(arg, type, name) { | ||||
| if (!(arg instanceof type)) | ||||
| throw new Error("The argument '" + name + "' type doesn't match"); | ||||
| } | ||||
| export function isNull(arg) { | ||||
| return (arg === null || arg === undefined); | ||||
| } | ||||
| export function isPrimitive(arg) { | ||||
| return (arg === null || arg === undefined || typeof (arg) === "string" || | ||||
| typeof (arg) === "number" || typeof (arg) === "boolean"); | ||||
| } | ||||
| export function isInteger(arg) { | ||||
|
cin
|
r34 | return parseInt(arg, 10) === arg; | ||
|
cin
|
r16 | } | ||
| export function isNumber(arg) { | ||||
|
cin
|
r34 | return parseFloat(arg) === arg; | ||
|
cin
|
r16 | } | ||
| export function isString(val) { | ||||
|
cin
|
r34 | return typeof (val) === "string" || val instanceof String; | ||
|
cin
|
r16 | } | ||
|
cin
|
r39 | export function isPromise(val): val is PromiseLike<any> { | ||
| return "then" in val && val.then instanceof Function; | ||||
| } | ||||
|
cin
|
r16 | export function isNullOrEmptyString(str) { | ||
| if (str === null || str === undefined || | ||||
|
cin
|
r34 | ((typeof (str) === "string" || str instanceof String) && str.length === 0)) | ||
|
cin
|
r16 | return true; | ||
| } | ||||
|
cin
|
r33 | export function isNotEmptyArray(arg): arg is Array<any> { | ||
|
cin
|
r16 | return (arg instanceof Array && arg.length > 0); | ||
| } | ||||
|
cin
|
r34 | export function getGlobal() { | ||
| return 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; | ||||
| } | ||||
|
cin
|
r16 | /** | ||
| * Выполняет метод для каждого элемента массива, останавливается, когда | ||||
| * либо достигнут конец массива, либо функция <c>cb</c> вернула | ||||
| * значение. | ||||
|
cin
|
r34 | * | ||
|
cin
|
r16 | * @param {Array | Object} obj массив элементов для просмотра | ||
| * @param {Function} cb функция, вызываемая для каждого элемента | ||||
| * @param {Object} thisArg значение, которое будет передано в качестве | ||||
| * <c>this</c> в <c>cb</c>. | ||||
| * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c> | ||||
| * если достигнут конец массива. | ||||
| */ | ||||
|
cin
|
r33 | export function each(obj, cb, thisArg?) { | ||
|
cin
|
r16 | argumentNotNull(cb, "cb"); | ||
| if (obj instanceof Array) { | ||||
|
cin
|
r34 | for (let i = 0; i < obj.length; i++) { | ||
| const x = cb.call(thisArg, obj[i], i); | ||||
|
cin
|
r16 | if (x !== undefined) | ||
| return x; | ||||
| } | ||||
| } else { | ||||
|
cin
|
r34 | const keys = Object.keys(obj); | ||
| for (const k of keys) { | ||||
| const x = cb.call(thisArg, obj[k], k); | ||||
|
cin
|
r16 | if (x !== undefined) | ||
| return x; | ||||
| } | ||||
| } | ||||
| } | ||||
|
cin
|
r33 | /** Copies property values from a source object to the destination and returns | ||
| * the destination onject. | ||||
|
cin
|
r34 | * | ||
|
cin
|
r33 | * @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. | ||||
|
cin
|
r34 | * | ||
|
cin
|
r33 | */ | ||
|
cin
|
r34 | export function mixin<T, S>(dest: T, source: S, template?: string[] | object): T & S { | ||
|
cin
|
r33 | argumentNotNull(dest, "to"); | ||
|
cin
|
r34 | const _res = dest as T & S; | ||
|
cin
|
r33 | |||
| if (template instanceof Array) { | ||||
|
cin
|
r39 | for (const p of template) { | ||
|
cin
|
r33 | if (p in source) | ||
| _res[p] = source[p]; | ||||
| } | ||||
| } else if (template) { | ||||
|
cin
|
r34 | const keys = Object.keys(source); | ||
| for (const p of keys) { | ||||
|
cin
|
r33 | if (p in template) | ||
| _res[template[p]] = source[p]; | ||||
| } | ||||
| } else { | ||||
|
cin
|
r34 | const keys = Object.keys(source); | ||
| for (const p of keys) | ||||
|
cin
|
r33 | _res[p] = source[p]; | ||
| } | ||||
| return _res; | ||||
| } | ||||
|
cin
|
r16 | /** 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. | ||||
| */ | ||||
|
cin
|
r33 | export function async(_fn: (...args: any[]) => any, thisArg): (...args: any[]) => PromiseLike<any> { | ||
|
cin
|
r16 | let fn = _fn; | ||
|
cin
|
r34 | if (arguments.length === 2 && !(fn instanceof Function)) | ||
|
cin
|
r16 | fn = thisArg[fn]; | ||
| if (fn == null) | ||||
| throw new Error("The function must be specified"); | ||||
|
cin
|
r33 | function wrapresult(x, e?): PromiseLike<any> { | ||
|
cin
|
r16 | if (e) { | ||
| return { | ||||
|
cin
|
r34 | then(cb, eb) { | ||
|
cin
|
r16 | try { | ||
| return eb ? wrapresult(eb(e)) : this; | ||||
| } catch (e2) { | ||||
| return wrapresult(null, e2); | ||||
| } | ||||
| } | ||||
| }; | ||||
| } else { | ||||
| if (x && x.then) | ||||
| return x; | ||||
| return { | ||||
|
cin
|
r34 | then(cb) { | ||
|
cin
|
r16 | try { | ||
| return cb ? wrapresult(cb(x)) : this; | ||||
| } catch (e2) { | ||||
| return wrapresult(e2); | ||||
| } | ||||
| } | ||||
| }; | ||||
| } | ||||
| } | ||||
|
cin
|
r34 | return (...args) => { | ||
|
cin
|
r16 | try { | ||
|
cin
|
r34 | return wrapresult(fn.apply(thisArg, args)); | ||
|
cin
|
r16 | } catch (e) { | ||
| return wrapresult(null, e); | ||||
| } | ||||
| }; | ||||
| } | ||||
|
cin
|
r34 | type _AnyFn = (...args) => any; | ||
| export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) { | ||||
|
cin
|
r33 | let method; | ||
|
cin
|
r16 | |||
| if (!(_method instanceof Function)) { | ||||
| argumentNotNull(target, "target"); | ||||
| method = target[_method]; | ||||
|
cin
|
r33 | if (!(method instanceof Function)) | ||
| throw new Error("'method' argument must be a Function or a method name"); | ||||
|
cin
|
r16 | } else { | ||
| method = _method; | ||||
| } | ||||
|
cin
|
r34 | return (...args) => { | ||
| return method.apply(target, args); | ||||
|
cin
|
r16 | }; | ||
| } | ||||
| /** | ||||
| * Для каждого элемента массива вызывает указанную функцию и сохраняет | ||||
| * возвращенное значение в массиве результатов. | ||||
|
cin
|
r34 | * | ||
|
cin
|
r16 | * @remarks cb может выполняться асинхронно, при этом одновременно будет | ||
| * только одна операция. | ||||
|
cin
|
r34 | * | ||
|
cin
|
r16 | * @async | ||
| */ | ||||
| export function pmap(items, cb) { | ||||
| argumentNotNull(cb, "cb"); | ||||
|
cin
|
r41 | if (isPromise(items)) | ||
|
cin
|
r39 | return items.then(data => pmap(data, cb)); | ||
|
cin
|
r16 | |||
| if (isNull(items) || !items.length) | ||||
| return items; | ||||
|
cin
|
r39 | let i = 0; | ||
| const result = []; | ||||
|
cin
|
r16 | |||
| function next() { | ||||
|
cin
|
r39 | let r; | ||
| let ri; | ||||
|
cin
|
r16 | |||
| function chain(x) { | ||||
| result[ri] = x; | ||||
| return next(); | ||||
| } | ||||
| while (i < items.length) { | ||||
| r = cb(items[i], i); | ||||
| ri = i; | ||||
| i++; | ||||
|
cin
|
r39 | if (isPromise(r)) { | ||
|
cin
|
r16 | return r.then(chain); | ||
| } else { | ||||
| result[ri] = r; | ||||
| } | ||||
| } | ||||
| return result; | ||||
| } | ||||
| return next(); | ||||
| } | ||||
| /** | ||||
| * Выбирает первый элемент из последовательности, или обещания, если в | ||||
| * качестве параметра используется обещание, оно должно вернуть массив. | ||||
|
cin
|
r39 | * | ||
|
cin
|
r16 | * @param {Function} cb обработчик результата, ему будет передан первый | ||
| * элемент последовательности в случае успеха | ||||
| * @param {Function} err обработчик исключения, если массив пустой, либо | ||||
| * не массив | ||||
|
cin
|
r39 | * | ||
|
cin
|
r16 | * @remarks Если не указаны ни cb ни err, тогда функция вернет либо | ||
| * обещание, либо первый элемент. | ||||
| * @async | ||||
| */ | ||||
|
cin
|
r39 | export function first(sequence, cb: (x) => any, err: (x) => any) { | ||
|
cin
|
r16 | if (sequence) { | ||
|
cin
|
r39 | if (isPromise(sequence)) { | ||
| return sequence.then(res => first(res, cb, err)); | ||||
|
cin
|
r16 | } 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"); | ||||
| } | ||||
| return cb ? cb(sequence[0]) : sequence[0]; | ||||
| } | ||||
| } | ||||
| if (err) | ||||
| return err(new Error("The sequence is required")); | ||||
| else | ||||
| throw new Error("The sequence is required"); | ||||
|
cin
|
r22 | } | ||
|
cin
|
r39 | export function destroy(d) { | ||
| if (d && "destroy" in d) | ||||
|
cin
|
r22 | d.destroy(); | ||
|
cin
|
r39 | } | ||