@idlebox/common 1.3.14 → 1.3.16

package/src/debugging/tryInspect.ts

@@ -0,0 +1,37 @@
+const inspect = Symbol.for('nodejs.util.inspect.custom'); // high version node
+const inspectOld = tryGetSymbol();
+
+declare const global: any;
+
+function tryGetSymbol() {
+	try {
+		const r = global.require;
+		return r('util').inspect.custom;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * try to call `inspect` method of an object, if not exists, call `toString`.
+ * @returns {string}
+ */
+export function tryInspect(object: any) {
+	if (!object || typeof object !== 'object') {
+		return JSON.stringify(object);
+	}
+
+	if (object[inspect]) {
+		return object[inspect]();
+	} else if (inspectOld && object[inspectOld]) {
+		return object[inspectOld]();
+	} else if (object['inspect']) {
+		return object['inspect']();
+	} else if (object[Symbol.toStringTag]) {
+		return object[Symbol.toStringTag]();
+	} else if (object.toJSON) {
+		return object.toJSON();
+	} else {
+		return '' + object;
+	}
+}

package/src/error/convertUnknown.ts

@@ -0,0 +1,10 @@
+import { getErrorFrame } from './getFrame';
+
+export function convertCatchedError(e: unknown): Error {
+	if (e instanceof Error) {
+		return e;
+	} else {
+		console.error('Catched invalid error at %s, type %s, value %s.', getErrorFrame(new Error(), 1), typeof e, e);
+		return new Error('Invalid: ' + e);
+	}
+}

package/src/error/getFrame.ts

@@ -0,0 +1,13 @@
+/**
+ * Get nth line of Error.stack
+ * @returns {string} if frame greater than max, return ''
+ */
+export function getErrorFrame(e: Error, frame: number): string {
+	if (e && e.stack) {
+		const stackArr = e.stack.split('\n');
+		if (stackArr.length > frame + 1) {
+			return stackArr[frame + 1].trim();
+		}
+	}
+	return '';
+}

package/src/function/asyncCallbackList.ts

@@ -0,0 +1,75 @@
+import { nameFunction } from './functionName';
+
+export interface MyAsyncCallback<Argument extends unknown[]> {
+	displayName?: string;
+
+	(...param: Argument): Promise<void | undefined | boolean> | void | undefined | boolean;
+}
+
+/**
+ * like CallbackList, but async
+ */
+export class AsyncCallbackList<Argument extends unknown[]> {
+	protected list: MyAsyncCallback<Argument>[] = [];
+	protected running: boolean = false;
+
+	constructor() {
+		this.run = (this.run as any).bind(this);
+	}
+
+	count() {
+		return this.list.length;
+	}
+
+	reset() {
+		if (this.running) {
+			throw new Error("Can not reset when it's running.");
+		}
+		this.list.length = 0;
+	}
+
+	/**
+	 * @param name optional name of `item` (will assign displayName to `item`)
+	 * @returns function list length
+	 */
+	add(item: MyAsyncCallback<Argument>, name?: string): number {
+		if (this.running) {
+			throw new Error("Can not add callback when it's running.");
+		}
+		if (name) {
+			nameFunction(name, item);
+		}
+		return this.list.push(item);
+	}
+
+	/**
+	 * @returns if removed: return `item`; if did not exists: return null
+	 */
+	remove(item: MyAsyncCallback<Argument>): null | MyAsyncCallback<Argument> {
+		if (this.running) {
+			throw new Error("Can not remove callback when it's running.");
+		}
+		const found = this.list.indexOf(item);
+		if (found !== -1) {
+			return this.list.splice(found, 1)[0];
+		}
+		return null;
+	}
+
+	/**
+	 * Stop run if one callback return `true`
+	 * @returns {boolean} true if one callback return true
+	 */
+	async run(...argument: Argument): Promise<boolean> {
+		this.running = true;
+		let ret: boolean | undefined | void;
+		for (const cb of this.list) {
+			ret = await cb(...argument);
+			if (ret === true) {
+				break;
+			}
+		}
+		this.running = false;
+		return ret || false;
+	}
+}

package/src/function/callbackList.ts

@@ -0,0 +1,88 @@
+import { nameFunction } from './functionName';
+
+export interface MyCallback<Argument extends unknown[]> {
+	displayName?: string;
+
+	(...param: Argument): any;
+}
+
+/**
+ * Manage a list of callback
+ */
+export class CallbackList<Argument extends unknown[]> {
+	protected list: MyCallback<Argument>[] = [];
+	protected running: boolean = false;
+	protected stop: boolean = false;
+
+	constructor() {
+		this.run = (this.run as any).bind(this);
+	}
+
+	count() {
+		return this.list.length;
+	}
+
+	/**
+	 * remove all callback
+	 */
+	reset() {
+		if (this.running) {
+			throw new Error("Can not reset when it's running.");
+		}
+		this.list.length = 0;
+	}
+
+	/**
+	 * @param name optional name of `item` (will assign displayName to `item`)
+	 * @returns function list length
+	 */
+	add(item: MyCallback<Argument>, name?: string): number {
+		if (this.running) {
+			throw new Error("Can not add callback when it's running.");
+		}
+		if (name) {
+			nameFunction(name, item);
+		}
+		return this.list.push(item);
+	}
+
+	/**
+	 * @returns if removed: return `item`; if did not exists: return null
+	 */
+	remove(item: MyCallback<Argument>): null | MyCallback<Argument> {
+		if (this.running) {
+			throw new Error("Can not remove callback when it's running.");
+		}
+		const found = this.list.indexOf(item);
+		if (found !== -1) {
+			return this.list.splice(found, 1)[0];
+		}
+		return null;
+	}
+
+	/**
+	 * in a callback, call this.stopRun() to stop remain callbacks (not by return false)
+	 * @returns {boolean} true if every callback called, false if stop in middle
+	 */
+	run(...argument: Argument): boolean {
+		if (this.running) {
+			throw new Error("can not run CallbackList in it's callback.");
+		}
+		this.stop = false;
+
+		this.running = true;
+		for (const cb of this.list) {
+			if (this.stop) break;
+			cb(...argument);
+		}
+		this.running = false;
+
+		const ret = !this.stop;
+		this.stop = false;
+		return ret;
+	}
+
+	stopRun() {
+		this.stop = true;
+	}
+}

package/src/function/delayCallbackList.ts

@@ -0,0 +1,45 @@
+import { nameFunction } from './functionName';
+
+export interface MyDelayCallback<Argument extends unknown[]> {
+	displayName?: string;
+
+	(...param: Argument): void;
+}
+
+/**
+ * remember arguments after run
+ * run all later added function with memorized argument
+ */
+export class DelayCallbackList<Argument extends unknown[]> {
+	private delayArgument?: Argument;
+	private delayComplete: boolean = false;
+
+	protected list?: MyDelayCallback<Argument>[] = [];
+
+	count() {
+		return this.list?.length ?? 0;
+	}
+
+	add(item: MyDelayCallback<Argument>, name?: string) {
+		if (name) {
+			nameFunction(name, item);
+		}
+		if (this.delayComplete) {
+			item(...this.delayArgument!);
+		} else {
+			this.list!.push(item);
+		}
+	}
+
+	run(argument: Argument) {
+		if (this.delayComplete) {
+			throw new Error('call to delay callback twice!');
+		}
+		this.delayComplete = true;
+		this.delayArgument = argument;
+		this.list!.forEach((cb) => {
+			cb(...argument);
+		});
+		delete this.list;
+	}
+}

package/src/function/functionName.ts

@@ -0,0 +1,39 @@
+/**
+ * Function with displayName
+ */
+export interface NamedFunction extends Function {
+	displayName: string;
+}
+
+/**
+ * Get displayName/name of a function
+ */
+export function functionName(func: Function) {
+	return (func as NamedFunction).displayName || func.name;
+}
+
+/**
+ * Set displayName of a function
+ */
+export function nameFunction<T extends Function>(name: string, func: T): T & NamedFunction {
+	return Object.assign(func, {
+		displayName: name,
+		inspect() {
+			return `[Function: ${name}]`;
+		},
+	});
+}
+
+export interface MaybeNamedFunction extends Function {
+	displayName?: string;
+}
+
+/**
+ * Assert function must have oneof displayName/name property
+ */
+export function assertFunctionHasName(func: MaybeNamedFunction) {
+	if (!func.displayName && !func.name) {
+		console.error(func);
+		throw new TypeError('function must have name!');
+	}
+}

package/src/index.generated.ts

@@ -0,0 +1,289 @@
+// DO NOT EDIT THIS FILE
+// @ts-ignore
+/* eslint-disable */
+
+/* array/arrayDiff.ts */
+	// Identifiers
+		export {IArrayUpdate} from "./array/arrayDiff";
+		export {arrayDiff} from "./array/arrayDiff";
+/* array/arraySame.ts */
+	// Identifiers
+		export {isArraySame} from "./array/arraySame";
+/* array/arrayUnique.ts */
+	// Identifiers
+		export {arrayUnique} from "./array/arrayUnique";
+		export {arrayUniqueReference} from "./array/arrayUnique";
+		export {IUniqueIdFactory} from "./array/arrayUnique";
+		export {uniqueFilter} from "./array/arrayUnique";
+/* array/normalizeArray.ts */
+	// Identifiers
+		export {normalizeArray} from "./array/normalizeArray";
+/* array/sortAlpha.ts */
+	// Identifiers
+		export {sortByString} from "./array/sortAlpha";
+/* date/consts.ts */
+	// Identifiers
+		export {oneSecond} from "./date/consts";
+		export {oneMinute} from "./date/consts";
+		export {oneHour} from "./date/consts";
+		export {oneDay} from "./date/consts";
+		export {oneWeek} from "./date/consts";
+/* date/isInvalid.ts */
+	// Identifiers
+		export {isDateInvalid} from "./date/isInvalid";
+/* date/sibling.ts */
+	// Identifiers
+		export {nextSecond} from "./date/sibling";
+		export {nextMinute} from "./date/sibling";
+		export {nextHour} from "./date/sibling";
+		export {nextDay} from "./date/sibling";
+		export {nextWeek} from "./date/sibling";
+		export {nextMonth} from "./date/sibling";
+		export {nextYear} from "./date/sibling";
+/* string/pad2.ts */
+	// Identifiers
+		export {pad2} from "./string/pad2";
+/* date/timeString.ts */
+	// Identifiers
+		export {humanDate} from "./date/timeString";
+/* date/unix.ts */
+	// Identifiers
+		export {getTimeStamp} from "./date/unix";
+		export {fromTimeStamp} from "./date/unix";
+/* debugging/serializable.ts */
+	// Identifiers
+		export {isScalar} from "./debugging/serializable";
+		export {SerializableKind} from "./debugging/serializable";
+		export {isSerializable} from "./debugging/serializable";
+		export {getTypeOf} from "./debugging/serializable";
+		export {assertSerializable} from "./debugging/serializable";
+/* debugging/tryInspect.ts */
+	// Identifiers
+		export {tryInspect} from "./debugging/tryInspect";
+/* error/getFrame.ts */
+	// Identifiers
+		export {getErrorFrame} from "./error/getFrame";
+/* error/convertUnknown.ts */
+	// Identifiers
+		export {convertCatchedError} from "./error/convertUnknown";
+/* function/functionName.ts */
+	// Identifiers
+		export {NamedFunction} from "./function/functionName";
+		export {functionName} from "./function/functionName";
+		export {nameFunction} from "./function/functionName";
+		export {MaybeNamedFunction} from "./function/functionName";
+		export {assertFunctionHasName} from "./function/functionName";
+/* function/asyncCallbackList.ts */
+	// Identifiers
+		export {MyAsyncCallback} from "./function/asyncCallbackList";
+		export {AsyncCallbackList} from "./function/asyncCallbackList";
+/* function/callbackList.ts */
+	// Identifiers
+		export {MyCallback} from "./function/callbackList";
+		export {CallbackList} from "./function/callbackList";
+/* function/delayCallbackList.ts */
+	// Identifiers
+		export {MyDelayCallback} from "./function/delayCallbackList";
+		export {DelayCallbackList} from "./function/delayCallbackList";
+/* lifecycle/event/event.ts */
+	// Identifiers
+		export {EventHandler} from "./lifecycle/event/event";
+		export {EventRegister} from "./lifecycle/event/event";
+		export {Emitter} from "./lifecycle/event/event";
+/* lifecycle/dispose/lifecycle.ts */
+	// Identifiers
+		export {IDisposableBaseInternal} from "./lifecycle/dispose/lifecycle";
+		export {IDisposable} from "./lifecycle/dispose/lifecycle";
+		export {IAsyncDisposable} from "./lifecycle/dispose/lifecycle";
+		export {toDisposable} from "./lifecycle/dispose/lifecycle";
+/* lifecycle/dispose/disposableEvent.ts */
+	// Identifiers
+		export {IEventListenerOptions} from "./lifecycle/dispose/disposableEvent";
+		export {IEventHostObject} from "./lifecycle/dispose/disposableEvent";
+		export {IEventEmitterObject} from "./lifecycle/dispose/disposableEvent";
+		export {addDisposableEventListener} from "./lifecycle/dispose/disposableEvent";
+/* lifecycle/dispose/disposedError.ts */
+	// Identifiers
+		export {DisposedError} from "./lifecycle/dispose/disposedError";
+		export {isDisposedError} from "./lifecycle/dispose/disposedError";
+/* lifecycle/dispose/lifecycle.async.ts */
+	// Identifiers
+		export {AsyncDisposable} from "./lifecycle/dispose/lifecycle.async";
+/* platform/globalObject.ts */
+	// Identifiers
+		export {globalObject} from "./platform/globalObject";
+		export {ensureGlobalObject} from "./platform/globalObject";
+		export {x} from "./platform/globalObject";
+/* platform/globalSingleton.ts */
+	// Identifiers
+		export {globalSingletonStrong} from "./platform/globalSingleton";
+		export {globalSingletonDelete} from "./platform/globalSingleton";
+		export {globalSingleton} from "./platform/globalSingleton";
+/* platform/globalSymbol.ts */
+	// Identifiers
+		export {createSymbol} from "./platform/globalSymbol";
+		export {deleteSymbol} from "./platform/globalSymbol";
+/* lifecycle/dispose/lifecycle.global.ts */
+	// Identifiers
+		export {registerGlobalLifecycle} from "./lifecycle/dispose/lifecycle.global";
+		export {ensureDisposeGlobal} from "./lifecycle/dispose/lifecycle.global";
+		export {disposeGlobal} from "./lifecycle/dispose/lifecycle.global";
+		export {LifecycleObject} from "./lifecycle/dispose/lifecycle.global";
+/* lifecycle/dispose/lifecycle.sync.ts */
+	// Identifiers
+		export {DisposableOnce} from "./lifecycle/dispose/lifecycle.sync";
+		export {Disposable} from "./lifecycle/dispose/lifecycle.sync";
+/* lifecycle/dispose/bridges/rxjs.ts */
+	// Identifiers
+		export {unsubscribableToDisposable} from "./lifecycle/dispose/bridges/rxjs";
+/* lifecycle/event/memorized.ts */
+	// Identifiers
+		export {MemorizedEmitter} from "./lifecycle/event/memorized";
+/* lifecycle/promise/cancel.ts */
+	// Identifiers
+		export {CanceledError} from "./lifecycle/promise/cancel";
+		export {isCanceledError} from "./lifecycle/promise/cancel";
+/* lifecycle/promise/deferredPromise.ts */
+	// Identifiers
+		export {ValueCallback} from "./lifecycle/promise/deferredPromise";
+		export {ProgressCallback} from "./lifecycle/promise/deferredPromise";
+		export {IProgressHolder} from "./lifecycle/promise/deferredPromise";
+		export {DeferredPromise} from "./lifecycle/promise/deferredPromise";
+/* lifecycle/promise/cancellationToken/driver.common.ts */
+	// Identifiers
+/* lifecycle/promise/cancellationToken/source.ts */
+	// Identifiers
+		export {CancellationToken} from "./lifecycle/promise/cancellationToken/source";
+		export {CancellationTokenSource} from "./lifecycle/promise/cancellationToken/source";
+/* lifecycle/promise/cancellationToken/driver.browser.ts */
+	// Identifiers
+/* lifecycle/timeout/timeoutError.ts */
+	// Identifiers
+		export {TimeoutError} from "./lifecycle/timeout/timeoutError";
+		export {isTimeoutError} from "./lifecycle/timeout/timeoutError";
+/* lifecycle/timeout/timeout.ts */
+	// Identifiers
+		export {timeout} from "./lifecycle/timeout/timeout";
+		export {sleep} from "./lifecycle/timeout/timeout";
+		export {timeoutPromise} from "./lifecycle/timeout/timeout";
+/* platform/os.ts */
+	// Identifiers
+		export {isElectron} from "./platform/os";
+		export {isElectronRenderer} from "./platform/os";
+		export {isElectronMain} from "./platform/os";
+		export {isWindows} from "./platform/os";
+		export {isMacintosh} from "./platform/os";
+		export {isLinux} from "./platform/os";
+		export {isNative} from "./platform/os";
+		export {isWeb} from "./platform/os";
+		export {userAgent} from "./platform/os";
+		export {sepList} from "./platform/os";
+/* log/logger.ts */
+	// Identifiers
+		export {ColorKind} from "./log/logger";
+		export {WrappedConsoleOptions} from "./log/logger";
+		export {WrappedConsole} from "./log/logger";
+/* mapSet/customSet.ts */
+	// Identifiers
+		export {Finder} from "./mapSet/customSet";
+		export {RegexpFinder} from "./mapSet/customSet";
+		export {CustomSet} from "./mapSet/customSet";
+/* mapSet/extendMap.ts */
+	// Identifiers
+		export {MapLike} from "./mapSet/extendMap";
+		export {ExtendMap} from "./mapSet/extendMap";
+/* misc/assertNotNull.ts */
+	// Identifiers
+		export {assertNotNull} from "./misc/assertNotNull";
+		export {throwNull} from "./misc/assertNotNull";
+/* object/definePublicConstant.ts */
+	// Identifiers
+		export {definePublicConstant} from "./object/definePublicConstant";
+/* object/initOnRead.ts */
+	// Identifiers
+		export {InitFunc} from "./object/initOnRead";
+		export {initOnRead} from "./object/initOnRead";
+/* object/objectPath.ts */
+	// Identifiers
+		export {objectPath} from "./object/objectPath";
+/* object/objectSame.ts */
+	// Identifiers
+		export {isObjectSame} from "./object/objectSame";
+		export {isObjectSameRecursive} from "./object/objectSame";
+/* path/isAbsolute.ts */
+	// Identifiers
+		export {isAbsolute} from "./path/isAbsolute";
+/* path/normalizePath.ts */
+	// Identifiers
+		export {normalizePath} from "./path/normalizePath";
+/* path/pathArray.ts */
+	// Identifiers
+		export {PathArray} from "./path/pathArray";
+/* promise/awaitIterator.ts */
+	// Identifiers
+		export {awaitIterator} from "./promise/awaitIterator";
+/* promise/finishAllPromise.ts */
+	// Identifiers
+		export {PromiseResultArray} from "./promise/finishAllPromise";
+		export {finishAllPromise} from "./promise/finishAllPromise";
+/* promise/promiseBool.ts */
+	// Identifiers
+		export {promiseBool} from "./promise/promiseBool";
+/* promise/promisePool.ts */
+	// Identifiers
+		export {PromisePool} from "./promise/promisePool";
+/* promise/timeoutPromisePool.ts */
+	// Identifiers
+		export {TimeoutPromisePool} from "./promise/timeoutPromisePool";
+/* reflection/classes/hookClass.ts */
+	// Identifiers
+		export {hookClassSymbol} from "./reflection/classes/hookClass";
+		export {hookClass} from "./reflection/classes/hookClass";
+/* reflection/classes/singleton.ts */
+	// Identifiers
+		export {singletonSymbol} from "./reflection/classes/singleton";
+		export {SingletonType} from "./reflection/classes/singleton";
+		export {singleton} from "./reflection/classes/singleton";
+/* reflection/methods/bind.ts */
+	// Identifiers
+		export {bindThis} from "./reflection/methods/bind";
+/* reflection/methods/initOnRead.ts */
+	// Identifiers
+		export {init} from "./reflection/methods/initOnRead";
+/* reflection/methods/memorize.ts */
+	// Identifiers
+		export {memorizeValueSymbol} from "./reflection/methods/memorize";
+		export {memo} from "./reflection/methods/memorize";
+/* string/castCase.ts */
+	// Identifiers
+		export {camelCase} from "./string/castCase";
+		export {ucfirst} from "./string/castCase";
+		export {lcfirst} from "./string/castCase";
+		export {linux_case} from "./string/castCase";
+		export {linux_case_hyphen} from "./string/castCase";
+/* string/concatType.generated.ts */
+	// Identifiers
+		export {concatStringType} from "./string/concatType.generated";
+/* string/escapeRegexp.ts */
+	// Identifiers
+		export {escapeRegExp} from "./string/escapeRegexp";
+/* string/sizeString.ts */
+	// Identifiers
+		export {humanSizeSI} from "./string/sizeString";
+		export {humanSize} from "./string/sizeString";
+		export {humanSpeed} from "./string/sizeString";
+/* typingHelper/literal.ts */
+	// Identifiers
+		export {Primitive} from "./typingHelper/literal";
+/* typingHelper/deep.partial.ts */
+	// Identifiers
+		export {DeepPartial} from "./typingHelper/deep.partial";
+/* typingHelper/deep.readonly.ts */
+	// Identifiers
+		export {DeepReadonly} from "./typingHelper/deep.readonly";
+/* typingHelper/deep.required.ts */
+	// Identifiers
+		export {DeepNonNullable} from "./typingHelper/deep.required";
+/* typingHelper/deep.writable.ts */
+	// Identifiers
+		export {DeepWriteable} from "./typingHelper/deep.writable";

package/src/lifecycle/dispose/bridges/rxjs.ts

@@ -0,0 +1,6 @@
+interface Unsubscribable {
+	unsubscribe(): void;
+}
+export function unsubscribableToDisposable(subscription: Unsubscribable) {
+	return { dispose: () => subscription.unsubscribe() };
+}