@idlebox/common 1.3.4 → 1.3.7

package/src/object/objectSame.ts

@@ -1,52 +0,0 @@
-import { isArraySame } from '../array/arraySame';
-
-/**
- * Should ensure a and b is none-null before call this
- * @returns true when a and b has EXACTLY same keys and values
- */
-export function isObjectSame(a: any, b: any) {
-	if (a === b) {
-		return true;
-	}
-	const aks = Object.keys(a);
-	if (!isArraySame(aks, Object.keys(b))) {
-		return false;
-	}
-
-	for (const k of aks) {
-		if (a[k] !== b[k]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-/**
- * Should ensure a and b is none-null before call this
- * @returns true when a and b has EXACTLY same keys and values, recursive compare all object values
- */
-export function isObjectSameRecursive(a: any, b: any) {
-	const aks = Object.keys(a);
-	if (!isArraySame(aks, Object.keys(b))) {
-		return false;
-	}
-
-	for (const k of aks) {
-		if (a[k] !== b[k]) {
-			const av = a[k],
-				bv = b[k];
-			if (av && bv && typeof av === 'object' && typeof bv === 'object') {
-				if (Array.isArray(av)) {
-					if (Array.isArray(bv)) {
-						if (isArraySame(av, bv)) continue;
-					}
-				} else if (!Array.isArray(bv)) {
-					if (isObjectSameRecursive(a[k], b[k])) continue;
-				}
-			}
-
-			return false;
-		}
-	}
-	return true;
-}

package/src/path/isAbsolute.ts

@@ -1,11 +0,0 @@
-/**
- * return true if a path is absolute:
- *   - /xxxx
- *   - \xxxx
- *   - c:/
- *   - c:\
- *   - http://
- */
-export function isAbsolute(path: string) {
-	return /^\/|^\\|^[a-z]:[\\/]|^[^:]{1,10}:\/\//i.test(path);
-}

package/src/path/normalizePath.ts

@@ -1,8 +0,0 @@
-/**
- * replace // to /
- * replace \ to /
- * remove ending /
- */
-export function normalizePath(p: string) {
-	return p.replace(/\\+/, '/').replace(/\/\/+/, '/').replace(/\/+$/, '');
-}

package/src/path/pathArray.ts

@@ -1,42 +0,0 @@
-import { normalizePath } from './normalizePath';
-
-/**
- * Work on "PATH"-like values
- */
-export class PathArray extends Set<string> {
-	constructor(init: string, private readonly sep: ':' | ';') {
-		super();
-		if (init) this.add(init);
-	}
-
-	add(paths: string) {
-		for (const p of paths.split(this.sep)) {
-			if (!p) continue;
-			super.add(normalizePath(p));
-		}
-		return this;
-	}
-
-	delete(paths: string) {
-		let anyRet = false;
-		for (const p of paths.split(this.sep)) {
-			anyRet = anyRet || super.delete(normalizePath(p));
-		}
-		return anyRet;
-	}
-
-	has(path: string): boolean {
-		return super.has(normalizePath(path));
-	}
-
-	toString() {
-		return [...this.values()].join(this.sep);
-	}
-
-	/**
-	 * @returns an array with `part` append to every element
-	 */
-	join(part: string) {
-		return [...this.values()].map((p) => normalizePath(p + '/' + part));
-	}
-}

package/src/platform/globalObject.ts

@@ -1,18 +0,0 @@
-declare const global: any;
-declare const window: any;
-
-/**
- * globalThis when supported.
- * if not, window in browser, global in nodejs
- * @public
- */
-export const globalObject: any =
-	typeof globalThis === 'undefined' ? (typeof window === 'undefined' ? global : window) : globalThis;
-
-export function ensureGlobalObject<T>(symbol: string, constructor: () => T): T {
-	const sm = Symbol.for(symbol);
-	if (!globalObject[sm]) {
-		globalObject[sm] = constructor();
-	}
-	return globalObject[sm];
-}

package/src/platform/globalSingleton.ts

@@ -1,82 +0,0 @@
-import { functionName } from '../function/functionName';
-import { ensureGlobalObject } from './globalObject';
-
-const singletonRegistry = ensureGlobalObject(`@@idlebox/global-singleton`, () => {
-	return new Map<string | symbol, any>();
-});
-
-/**
- * Get an singleton instance from window/global space
- * if symbol did not exists, create it and assign to window/global
- * @public
- */
-export function globalSingletonStrong<T>(symbol: symbol | string, constructor: () => T): T;
-/**
- * Get an singleton instance from window/global space
- * @public
- */
-export function globalSingletonStrong<T>(symbol: symbol | string): T | undefined;
-
-export function globalSingletonStrong<T>(symbol: symbol | string, constructor?: () => T): T | undefined {
-	let object = singletonRegistry.get(symbol);
-	if (object instanceof WeakRef) {
-		const target = object.deref();
-		if (target !== undefined) {
-			object = target;
-		} else if (constructor) {
-			object = constructor();
-			if (object === undefined)
-				throw new TypeError(`singleton constructor (${functionName(constructor)}) returned undefined.`);
-		} else {
-			singletonRegistry.delete(symbol);
-			return undefined;
-		}
-		singletonRegistry.set(symbol, object);
-	} else if (object === undefined && constructor) {
-		object = constructor();
-		if (object === undefined)
-			throw new TypeError(`singleton constructor (${functionName(constructor)}) returned undefined.`);
-		singletonRegistry.set(symbol, object);
-	}
-	return object;
-}
-
-/**
- * Delete a key from window/global space
- * use with care
- * @public
- */
-export function globalSingletonDelete(symbol: symbol | string) {
-	singletonRegistry.delete(symbol);
-}
-
-/**
- * Same with globalSingletonStrong, but save instance in a WeakMap, so it maybe delete by gc if no reference
- * @public
- */
-export function globalSingleton<T>(symbol: symbol | string, constructor: () => T): T;
-/**
- * Same with globalSingletonStrong, but save instance in a WeakMap, so it maybe delete by gc if no reference
- * @public
- */
-export function globalSingleton<T>(symbol: symbol | string): T | undefined;
-export function globalSingleton<T>(symbol: symbol | string, constructor?: () => T): T | undefined {
-	if (singletonRegistry.has(symbol)) {
-		let object = singletonRegistry.get(symbol);
-		if (object instanceof WeakRef) {
-			object = object.deref();
-			if (object) return object;
-			singletonRegistry.delete(symbol);
-		} else {
-			return object; // strong
-		}
-	}
-
-	if (constructor) {
-		const object = new WeakRef(constructor() as any);
-		singletonRegistry.set(symbol, object);
-		return object.deref();
-	}
-
-	return undefined;
-}

package/src/platform/globalSymbol.ts

@@ -1,36 +0,0 @@
-import { ensureGlobalObject } from './globalObject';
-
-const symbolRegistry = ensureGlobalObject(`@@idlebox/global-symbol`, () => {
-	return {} as Record<string, Record<string, symbol>>;
-});
-
-/**
- * Get a symbol singleton, if not exists, create it
- *
- * this is very like Symbol.for, but not real global symbol
- * @public
- */
-export function createSymbol(category: string, name: string): symbol {
-	if (symbolRegistry[category] && symbolRegistry[category][name]) {
-		return symbolRegistry[category][name];
-	} else {
-		if (!symbolRegistry[category]) {
-			symbolRegistry[category] = {};
-		}
-		symbolRegistry[category][name] = Symbol(name);
-		return symbolRegistry[category][name];
-	}
-}
-
-/**
- * Delete a symbol from window/global object
- * @public
- */
-export function deleteSymbol(category: string, name: string) {
-	if (symbolRegistry[category] && symbolRegistry[category][name]) {
-		delete symbolRegistry[category][name];
-		if (Object.keys(symbolRegistry[category]).length === 0) {
-			delete symbolRegistry[category];
-		}
-	}
-}

package/src/platform/os.ts

@@ -1,45 +0,0 @@
-declare const process: any;
-declare const navigator: any;
-
-let _isWindows = false;
-let _isMacintosh = false;
-let _isLinux = false;
-let _isNative = false;
-let _isWeb = false;
-let _userAgent: string;
-
-export const isElectron =
-	typeof process !== 'undefined' &&
-	typeof process.versions !== 'undefined' &&
-	typeof process.versions.electron !== 'undefined';
-export const isElectronRenderer = isElectron && process.type === 'renderer';
-export const isElectronMain = !isElectronRenderer;
-
-if (typeof navigator === 'object' && !isElectronRenderer) {
-	_userAgent = navigator.userAgent;
-	_isWindows = _userAgent.indexOf('Windows') >= 0;
-	_isMacintosh = _userAgent.indexOf('Macintosh') >= 0;
-	_isLinux = _userAgent.indexOf('Linux') >= 0;
-	_isWeb = true;
-} else if (typeof process === 'object') {
-	_userAgent = `nodejs(${process.versions.node})`;
-	if (process.versions.electron) {
-		_userAgent += ` electron(${process.versions.electron})`;
-		if (isElectronRenderer) {
-			_userAgent += ' ' + navigator.userAgent;
-		}
-	}
-	_isWindows = process.platform === 'win32';
-	_isMacintosh = process.platform === 'darwin';
-	_isLinux = process.platform === 'linux';
-	_isNative = true;
-} else {
-	_userAgent = 'unsupported';
-}
-
-export const isWindows = _isWindows;
-export const isMacintosh = _isMacintosh;
-export const isLinux = _isLinux;
-export const isNative = _isNative;
-export const isWeb = _isWeb;
-export const userAgent = _userAgent;

package/src/promise/awaitIterator.ts

@@ -1,19 +0,0 @@
-/**
- * Convert Iterator into Promise, resolve with the last value from Iterator
- */
-export async function awaitIterator<T>(generator: Iterator<T>): Promise<T> {
-	let lastValue: any = {};
-	do {
-		const itr: IteratorResult<any> = generator.next(lastValue);
-		if (itr.done) {
-			return itr.value || lastValue;
-		}
-		if (itr.value[Symbol.iterator]) {
-			lastValue = await awaitIterator(<any>itr.value);
-		} else if (itr.value.then) {
-			lastValue = await itr.value;
-		} else {
-			lastValue = itr.value;
-		}
-	} while (true);
-}

package/src/promise/finishAllPromise.ts

@@ -1,50 +0,0 @@
-/** @deprecated */
-export interface PromiseResultArray<T> {
-	count: number;
-	fulfilledResult: T[];
-	fulfilled: number[];
-	rejectedResult: Error[];
-	rejected: number[];
-}
-
-/**
- * @deprecated Use Promise.allSettled instead
- */
-export function finishAllPromise<T>(ps: Promise<T>[]) {
-	return new Promise<PromiseResultArray<T>>((resolve) => {
-		const fulfilledResult: T[] = [];
-		const rejectedResult: Error[] = [];
-		const fulfilled: number[] = [];
-		const rejected: number[] = [];
-		let last = ps.length;
-
-		const toDone = () => {
-			if (last === 0) {
-				resolve({
-					count: ps.length,
-					fulfilledResult,
-					fulfilled,
-					rejectedResult,
-					rejected,
-				});
-			}
-		};
-
-		ps.forEach((p, index) => {
-			p.then(
-				(t) => {
-					fulfilledResult[index] = t;
-					fulfilled.push(index);
-					last--;
-					toDone();
-				},
-				(e) => {
-					rejectedResult[index] = e;
-					rejected.push(index);
-					last--;
-					toDone();
-				}
-			);
-		});
-	});
-}

package/src/promise/promiseBool.ts

@@ -1,10 +0,0 @@
-/**
- * resolve with true when `p` resolve
- * resolve with false when `p` reject (and drop error)
- */
-export function promiseBool(p: Promise<any>): Promise<boolean> {
-	return p.then(
-		() => true,
-		() => false
-	);
-}

package/src/promise/promisePool.ts

@@ -1,40 +0,0 @@
-import { CanceledError } from '../lifecycle/promise/cancel';
-import { DeferredPromise } from '../lifecycle/promise/deferredPromise';
-
-export class PromisePool {
-	protected readonly promiseList: Record<string, DeferredPromise<any>> = {};
-
-	size() {
-		return Object.keys(this.promiseList).length;
-	}
-
-	create(id: string) {
-		if (this.promiseList[id]) {
-			throw new Error('duplicate promise with id ' + id);
-		}
-		const dfd = new DeferredPromise<any>();
-		this.promiseList[id] = dfd;
-		return dfd.p;
-	}
-
-	has(id: string) {
-		return this.promiseList.hasOwnProperty(id);
-	}
-
-	done(id: string, data: any) {
-		this.promiseList[id].complete(data);
-		delete this.promiseList[id];
-	}
-
-	error(id: string, e: Error) {
-		this.promiseList[id].error(e);
-		delete this.promiseList[id];
-	}
-
-	dispose() {
-		const e = new CanceledError();
-		for (const id of Object.keys(this.promiseList)) {
-			this.error(id, e);
-		}
-	}
-}

package/src/promise/timeoutPromisePool.ts

@@ -1,22 +0,0 @@
-import { TimeoutError } from '../lifecycle/timeout/timeoutError';
-import { PromisePool } from './promisePool';
-
-export class TimeoutPromisePool extends PromisePool {
-	constructor(private readonly defaultTimeoutMs = 50000) {
-		super();
-	}
-
-	create(id: string, timeoutMs: number = this.defaultTimeoutMs, timeoutMsg?: string) {
-		const p = super.create(id);
-
-		const to = setTimeout(() => {
-			this.error(id, new TimeoutError(timeoutMs, timeoutMsg));
-		}, timeoutMs);
-
-		p.finally(() => {
-			clearTimeout(to);
-		});
-
-		return p;
-	}
-}

package/src/reflection/classes/hookClass.ts

@@ -1,47 +0,0 @@
-export const hookClassSymbol = Symbol('@gongt/hookClass');
-
-interface IConstructorOf<T> extends Object {
-	new (...args: any[]): T;
-}
-
-interface IHooks<T, TC> {
-	afterConstruct?: ((obj: T) => void)[];
-	beforeConstruct?: ((obj: TC) => T | void)[];
-}
-
-export function hookClass<TC extends IConstructorOf<T>, T>(target: TC): IHooks<T, TC> {
-	if ((target as any)[hookClassSymbol]) {
-		return (target as any)[hookClassSymbol];
-	}
-
-	const hooks = {} as IHooks<T, TC>;
-
-	const proxyTarget = new Proxy(target, {
-		construct(target: any, argArray: any): object {
-			if (hooks.beforeConstruct) {
-				for (const beforeCb of hooks.beforeConstruct) {
-					const ret = beforeCb(target);
-					if (ret) {
-						return ret as any;
-					}
-				}
-			}
-			const d = new target(...argArray);
-			if (hooks.afterConstruct) {
-				for (const afterCb of hooks.afterConstruct) {
-					afterCb(d);
-				}
-			}
-			return d;
-		},
-	});
-
-	Object.defineProperty(proxyTarget, hookClassSymbol, {
-		value: hooks,
-		enumerable: false,
-		configurable: false,
-		writable: false,
-	});
-
-	return hooks;
-}

package/src/reflection/classes/singleton.ts

@@ -1,33 +0,0 @@
-import { hookClass } from './hookClass';
-
-export const singletonSymbol = Symbol('@gongt/singleton');
-
-export enum SingletonType {
-	Throw,
-	Return,
-}
-
-export function singleton(type: SingletonType = SingletonType.Return): ClassDecorator {
-	return (target: any): any => {
-		const hook = hookClass(target);
-		if (!hook.beforeConstruct) {
-			hook.beforeConstruct = [];
-		}
-		if (!hook.afterConstruct) {
-			hook.afterConstruct = [];
-		}
-
-		hook.beforeConstruct.push((cls) => {
-			if (cls[singletonSymbol]) {
-				if (type === SingletonType.Return) {
-					return cls[singletonSymbol];
-				} else {
-					throw new Error(`Duplicate new singleton class [${target.name}]`);
-				}
-			}
-		});
-		hook.afterConstruct.push((obj) => {
-			target[singletonSymbol] = obj;
-		});
-	};
-}

package/src/reflection/methods/bind.ts

@@ -1,30 +0,0 @@
-/**
- * Auto bind `this` to class method
- */
-export const bindThis: MethodDecorator = <T>(
-	_target: Object,
-	propertyKey: string | symbol,
-	descriptor: TypedPropertyDescriptor<T>
-) => {
-	const oldFunc = descriptor.value;
-	if (typeof oldFunc === 'function') {
-		return {
-			enumerable: true,
-			configurable: true,
-			get: function (this: any) {
-				delete this[propertyKey];
-
-				const fn = oldFunc.bind(this);
-				Object.defineProperty(this, propertyKey, {
-					value: fn,
-					writable: false,
-					enumerable: true,
-					configurable: false,
-				});
-				return fn;
-			},
-		};
-	} else {
-		throw new TypeError('@bindThis can only use with method, but not property.');
-	}
-};

package/src/reflection/methods/initOnRead.ts

@@ -1,11 +0,0 @@
-import { InitFunc, initOnRead } from '../../object/initOnRead';
-
-/**
- * Decorater version of `initOnRead`
- * @see initOnRead
- */
-export function init<O, T extends keyof O>(init: InitFunc<O, O[T]>): PropertyDecorator {
-	return function (target: O, propertyKey: T) {
-		initOnRead<O, T>(target, propertyKey, init);
-	} as any;
-}

package/src/reflection/methods/memorize.ts

@@ -1,33 +0,0 @@
-export const memorizeValueSymbol = Symbol('@gongt/memorizeValue');
-
-/**
- * Decorate class method/getter
- *
- * remember first return value of method/getter, directlly return memorized value when call it again
- */
-export const memo: MethodDecorator = <T>(
-	_target: Object,
-	propertyKey: string | symbol,
-	descriptor: TypedPropertyDescriptor<T>
-) => {
-	const original: Function = (descriptor.value ? descriptor.value : descriptor.get) as any;
-	if (descriptor.set || typeof original !== 'function') {
-		throw new TypeError('@memo should only use on method, or getter. Not property and setter.');
-	}
-
-	if (descriptor.get) {
-		descriptor.get = function memo_getter(this: any) {
-			const value = original.call(this, arguments);
-			Object.defineProperty(this, propertyKey, { value });
-			return value;
-		};
-	} else {
-		descriptor.value = function memo_method(this: any) {
-			const value = original.call(this, arguments);
-			Object.defineProperty(this, propertyKey, { value: () => value });
-			return value;
-		} as any;
-	}
-
-	return descriptor;
-};

package/src/string/castCase.ts

@@ -1,44 +0,0 @@
-/** @public */
-export function camelCase(str: string) {
-	return str.replace(/[-.\/_][a-z]/g, (s) => {
-		return s[1].toUpperCase();
-	});
-}
-
-/**
- * Uppercase first char
- * @public
- */
-export function ucfirst<T extends string>(str: T): Capitalize<T> {
-	return <any>(str[0].toUpperCase() + str.slice(1));
-}
-
-/**
- * lowercase first char
- * @public
- */
-export function lcfirst<T extends string>(str: T): Uncapitalize<T> {
-	return <any>(str[0].toLowerCase() + str.slice(1));
-}
-
-/** @public */
-export function linux_case(str: string) {
-	return str
-		.replace(/^[A-Z]/, (s) => {
-			return s.toLowerCase();
-		})
-		.replace(/[A-Z]/g, (s) => {
-			return '_' + s.toLowerCase();
-		});
-}
-
-/** @public */
-export function linux_case_hyphen(str: string) {
-	return str
-		.replace(/^[A-Z]/, (s) => {
-			return s.toLowerCase();
-		})
-		.replace(/[A-Z]/g, (s) => {
-			return '-' + s.toLowerCase();
-		});
-}

package/src/string/escapeRegexp.ts

@@ -1,4 +0,0 @@
-/** @public */
-export function escapeRegExp(str: string) {
-	return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
-}

package/src/string/pad2.ts

@@ -1,11 +0,0 @@
-/**
- * Pad number to two digits string, used in time format
- * @public
- */
-export function pad2(s: number) {
-	if (s < 10) {
-		return '0' + s;
-	} else {
-		return '' + s;
-	}
-}