@idlebox/common 1.3.15 → 1.3.17

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() };
+}

package/src/lifecycle/dispose/disposableEvent.ts

@@ -0,0 +1,117 @@
+import { IDisposable } from './lifecycle';
+
+declare const AbortController: new () => any;
+
+export interface IEventListenerOptions {
+	capture?: boolean;
+	once?: boolean;
+	passive?: boolean;
+}
+
+export interface IEventHostObject<T extends Function> {
+	addEventListener(type: string, handler: T, options?: IEventListenerOptions): any;
+	removeEventListener(type: string, handler: T, options?: IEventListenerOptions): any;
+}
+
+export interface IEventEmitterObject<T extends Function> {
+	addListener(type: string, handler: T): any;
+	removeListener(type: string, handler: T): any;
+}
+
+export function addDisposableEventListener<T extends Function>(
+	target: IEventHostObject<T> | IEventEmitterObject<T>,
+	type: string,
+	options: IEventListenerOptions,
+	handler: T
+): IDisposable;
+
+export function addDisposableEventListener<T extends Function>(
+	target: IEventHostObject<T> | IEventEmitterObject<T>,
+	type: string,
+	handler: T
+): IDisposable;
+
+export function addDisposableEventListener<T extends Function>(
+	target: IEventHostObject<T> | IEventEmitterObject<T>,
+	type: string,
+	_options: IEventListenerOptions | T | undefined,
+	_handler?: T
+): IDisposable {
+	if (!_handler) {
+		if (typeof _options === 'function') {
+			_handler = _options;
+			_options = undefined;
+		} else {
+			throw new Error('missing handler');
+		}
+	}
+
+	const handler = _handler as T;
+	const options = _options as IEventListenerOptions;
+
+	let remove: IDisposable['dispose'];
+
+	if ('addEventListener' in target) {
+		if (passiveSupported === undefined || abortSupported === undefined) {
+			checkAllSupport(target);
+		}
+		const [abort, xOptions] = check(options);
+		target.addEventListener(type, handler, xOptions);
+		if (abort) {
+			remove = () => {
+				abort;
+			};
+		} else {
+			remove = () => {
+				target.removeEventListener(type, handler, xOptions);
+			};
+		}
+	} else {
+		target.addListener(type, handler);
+		remove = () => {
+			target.removeListener(type, handler);
+		};
+	}
+	return { dispose: remove };
+}
+
+let passiveSupported: boolean;
+let abortSupported: boolean;
+function check(options: IEventListenerOptions = {}): [{ abort(): void } | undefined, IEventListenerOptions] {
+	if (!passiveSupported) {
+		return [undefined, (options.capture || false) as any];
+	}
+
+	if (abortSupported) {
+		const controller = new AbortController();
+		(options as any).signal = controller.signal;
+		return [controller, options];
+	} else {
+		return [undefined, options];
+	}
+}
+
+function checkAllSupport(ele: IEventHostObject<any>) {
+	passiveSupported = checkSupport('passive', ele);
+	abortSupported = typeof AbortController !== 'undefined' && checkSupport('signal', ele);
+}
+
+function checkSupport(field: string, ele: IEventHostObject<any>) {
+	let supported = false;
+	try {
+		const options = {
+			get [field]() {
+				// This function will be called when the browser
+				//   attempts to access the passive property.
+				supported = true;
+				return undefined;
+			},
+		};
+
+		ele.addEventListener('_test_', null, options);
+		ele.removeEventListener('_test_', null, options);
+	} catch (err) {
+		supported = false;
+	}
+	return supported;
+}

package/src/lifecycle/dispose/disposedError.ts

@@ -0,0 +1,16 @@
+import { getErrorFrame } from '../../error/getFrame';
+import { tryInspect } from '../../debugging/tryInspect';
+
+/**
+ * Error when call dispose() twice
+ */
+export class DisposedError extends Error {
+	constructor(object: any, previous: Error) {
+		super(`Object [${tryInspect(object)}] has already disposed at ${getErrorFrame(previous, 2)}.`);
+		this.name = 'Warning';
+	}
+}
+
+export function isDisposedError(error: any): boolean {
+	return error instanceof DisposedError;
+}

package/src/lifecycle/dispose/lifecycle.async.ts

@@ -0,0 +1,61 @@
+import { convertCatchedError } from '../../error/convertUnknown';
+import { Emitter, EventRegister } from '../event/event';
+import { DisposedError } from './disposedError';
+import { IAsyncDisposable, IDisposableBaseInternal } from './lifecycle';
+
+/**
+ * Async version of Disposable
+ * @public
+ */
+export class AsyncDisposable implements IAsyncDisposable, IDisposableBaseInternal {
+	private readonly _disposables: IAsyncDisposable[] = [];
+
+	protected readonly _onDisposeError = new Emitter<Error>();
+	public readonly onDisposeError: EventRegister<Error> = this._onDisposeError.register;
+
+	protected readonly _onBeforeDispose = new Emitter<void>();
+	public readonly onBeforeDispose: EventRegister<void> = this._onBeforeDispose.register;
+
+	private _disposed?: Error;
+
+	public get hasDisposed() {
+		return !!this._disposed;
+	}
+
+	/**
+	 * @throws if already disposed
+	 */
+	public assertNotDisposed() {
+		if (this._disposed) {
+			throw new DisposedError(this, this._disposed);
+		}
+	}
+
+	/**
+	 * register a disposable object
+	 */
+	public _register<T extends IAsyncDisposable>(d: T): T {
+		this.assertNotDisposed();
+		this._disposables.unshift(d);
+		return d;
+	}
+
+	public async dispose(): Promise<void> {
+		if (this._disposed) {
+			console.warn(new DisposedError(this, this._disposed).message);
+			return;
+		}
+		this._onBeforeDispose.fireNoError();
+		this._disposed = new Error('disposed');
+
+		this._disposables.push(this._onBeforeDispose);
+		this._disposables.push(this._onDisposeError);
+		for (const cb of this._disposables) {
+			try {
+				await cb.dispose();
+			} catch (e) {
+				this._onDisposeError.fire(convertCatchedError(e));
+			}
+		}
+	}
+}

package/src/lifecycle/dispose/lifecycle.global.ts

@@ -0,0 +1,61 @@
+import { globalSingletonStrong } from '../../platform/globalSingleton';
+import { createSymbol } from '../../platform/globalSymbol';
+import { IDisposable } from './lifecycle';
+import { AsyncDisposable } from './lifecycle.async';
+
+const symbol = createSymbol('lifecycle', 'application');
+
+function create() {
+	return new AsyncDisposable();
+}
+
+/**
+ * Add object into global disposable store, it will be dispose when call to `disposeGlobal`
+ */
+export function registerGlobalLifecycle(object: IDisposable) {
+	globalSingletonStrong(symbol, create)._register(object);
+}
+
+/**
+ * Same as disposeGlobal, but do not throw by duplicate call
+ */
+export function ensureDisposeGlobal() {
+	const obj = globalSingletonStrong<AsyncDisposable>(symbol);
+	if (obj && !obj.hasDisposed) {
+		return Promise.resolve(obj.dispose());
+	} else {
+		return Promise.resolve();
+	}
+}
+
+/**
+ * Dispose the global disposable store
+ * this function must be manually called by user, when registerGlobalLifecycle is used
+ *
+ * @throws when call twice
+ */
+export function disposeGlobal() {
+	const obj = globalSingletonStrong<AsyncDisposable>(symbol);
+	if (obj && obj.hasDisposed) {
+		throw new Error('global already disposed.');
+	} else if (obj) {
+		return Promise.resolve(obj.dispose());
+	} else {
+		return Promise.resolve();
+	}
+}
+
+/**
+ * Note: sub-class should singleton
+ * @alpha
+ */
+export abstract class LifecycleObject extends AsyncDisposable {
+	/** sub-class should shutdown program in this method */
+	protected abstract done(): void;
+
+	public async dispose(): Promise<void> {
+		return super.dispose().finally(() => {
+			this.done();
+		});
+	}
+}

package/src/lifecycle/dispose/lifecycle.sync.ts

@@ -0,0 +1,79 @@
+import { DisposedError } from './disposedError';
+import { Emitter, EventRegister } from '../event/event';
+import { IDisposable, IDisposableBaseInternal } from './lifecycle';
+
+export abstract class DisposableOnce implements IDisposable {
+	private _disposed?: Error;
+
+	public get hasDisposed() {
+		return !!this._disposed;
+	}
+	public dispose(): void {
+		if (this._disposed) {
+			console.warn(new DisposedError(this, this._disposed).message);
+			return;
+		}
+		this._disposed = new Error('disposed');
+		this._dispose();
+	}
+
+	protected abstract _dispose(): void;
+}
+
+/**
+ * Standalone disposable class, can use as instance or base class.
+ */
+export class Disposable implements IDisposable, IDisposableBaseInternal {
+	private readonly _disposables: IDisposable[] = [];
+
+	protected readonly _onDisposeError = new Emitter<Error>();
+	public readonly onDisposeError: EventRegister<Error> = this._onDisposeError.register;
+
+	protected readonly _onBeforeDispose = new Emitter<void>();
+	public readonly onBeforeDispose: EventRegister<void> = this._onBeforeDispose.register;
+
+	private _disposed?: Error;
+
+	public get hasDisposed() {
+		return !!this._disposed;
+	}
+
+	/**
+	 * @throws if already disposed
+	 */
+	public assertNotDisposed() {
+		if (this._disposed) {
+			throw new DisposedError(this, this._disposed);
+		}
+	}
+
+	public _register<T extends IDisposable>(d: T): T {
+		this.assertNotDisposed();
+		this._disposables.unshift(d);
+		return d;
+	}
+
+	public dispose(): void {
+		if (this._disposed) {
+			console.warn(new DisposedError(this, this._disposed).message);
+			return;
+		}
+		this._onBeforeDispose.fireNoError();
+		this._disposed = new Error('disposed');
+
+		this._disposables.push(this._onBeforeDispose);
+		this._disposables.push(this._onDisposeError);
+		for (const item of this._disposables.values()) {
+			try {
+				item.dispose();
+			} catch (e) {
+				if (e instanceof Error) {
+					this._onDisposeError.fire(e);
+				} else {
+					console.error('error during dispose, throw:', e);
+					this._onDisposeError.fire(new Error('' + e));
+				}
+			}
+		}
+	}
+}

package/src/lifecycle/dispose/lifecycle.ts

@@ -0,0 +1,28 @@
+import { EventRegister } from '../event/event';
+
+/**
+ * @private
+ */
+export interface IDisposableBaseInternal {
+	onDisposeError: EventRegister<Error>;
+	onBeforeDispose: EventRegister<void>;
+	readonly hasDisposed: boolean;
+}
+
+/** @public */
+export interface IDisposable {
+	dispose(): void;
+}
+
+/** @public */
+export interface IAsyncDisposable {
+	dispose(): void | Promise<void>;
+}
+
+/**
+ * Convert "dispose function" to disposable object
+ * @public
+ */
+export function toDisposable(fn: () => void): IDisposable {
+	return { dispose: fn };
+}