@idlebox/common 1.3.14 → 1.3.16

package/src/lifecycle/promise/deferredPromise.ts

@@ -0,0 +1,104 @@
+import { CanceledError } from './cancel';
+
+export type ValueCallback<T = any> = (value: T | Promise<T>) => void;
+export type ProgressCallback<T = any> = (value: T) => void;
+
+export interface IProgressHolder<T, PT> {
+	progress(fn: ProgressCallback<PT>): Promise<T> & IProgressHolder<T, PT>;
+}
+
+/**
+ * a promise can resolve or reject later
+ * @public
+ */
+export class DeferredPromise<T, PT = any> {
+	public readonly p: Promise<T> & IProgressHolder<T, PT>;
+	private declare _completeCallback: ValueCallback<T>;
+	private declare _errorCallback: (err: any) => void;
+	private _state: boolean | null = null;
+	private _progressList?: ProgressCallback<PT>[] = [];
+
+	constructor() {
+		this.p = Object.assign(
+			new Promise<any>((c, e) => {
+				this._completeCallback = c;
+				this._errorCallback = e;
+			}),
+			{
+				progress: (fn: ProgressCallback<PT>) => {
+					this.progress(fn);
+					return this.p;
+				},
+			}
+		);
+		this.p
+			.finally(() => {
+				delete this._progressList;
+			})
+			.catch(() => void 0);
+	}
+
+	notify(progress: PT): this {
+		for (const cb of this._progressList!) {
+			cb(progress);
+		}
+		return this;
+	}
+
+	progress(fn: ProgressCallback<PT>): void {
+		this._progressList!.push(fn);
+	}
+
+	get completed(): boolean {
+		return typeof this._state === 'boolean';
+	}
+
+	get resolved(): boolean {
+		return this._state === true;
+	}
+
+	get rejected(): boolean {
+		return this._state === false;
+	}
+
+	/**
+	 * resolve the promise
+	 */
+	public complete(value: T) {
+		this._state = true;
+		this._completeCallback(value);
+	}
+
+	/**
+	 * reject the promise
+	 */
+	public error(err: any) {
+		this._state = false;
+		this._errorCallback(err);
+	}
+
+	/**
+	 * reject the promise with CancelError
+	 */
+	public cancel() {
+		this._state = false;
+		this._errorCallback(new CanceledError());
+	}
+
+	/**
+	 * Convert promise into deferred
+	 * returns a DeferredPromise, resolve when prev resolve, reject when prev reject
+	 */
+	static wrap(prev: Promise<any>) {
+		const p = new DeferredPromise();
+		prev.then(
+			(d) => {
+				p.complete(d);
+			},
+			(e) => {
+				p.error(e);
+			}
+		);
+		return p;
+	}
+}

package/src/lifecycle/timeout/timeout.ts

@@ -0,0 +1,48 @@
+import { TimeoutError } from './timeoutError';
+import { DeferredPromise } from '../promise/deferredPromise';
+
+/**
+ * @returns promise reject with TimeoutError after specific time
+ */
+export function timeout(ms: number, error = 'no response'): Promise<never> {
+	return new Promise((_, reject) => {
+		setTimeout(() => {
+			reject(new TimeoutError(ms, error));
+		}, ms);
+	});
+}
+
+/**
+ * @returns promise resolve after specific time
+ */
+export function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => {
+		setTimeout(() => {
+			resolve();
+		}, ms);
+	});
+}
+
+export function timeoutPromise<T>(ms: number, p: Promise<T>): Promise<T>;
+export function timeoutPromise<T>(ms: number, message: string, p: Promise<T>): Promise<T>;
+export function timeoutPromise<T, PT = any>(ms: number, p: DeferredPromise<T, PT>): DeferredPromise<T, PT>;
+export function timeoutPromise<T, PT = any>(
+	ms: number,
+	message: string,
+	p: DeferredPromise<T, PT>
+): DeferredPromise<T, PT>;
+
+export function timeoutPromise<T>(ms: number, message: string | T, p?: T): T {
+	let msg: string | undefined;
+	if (typeof message !== 'string') {
+		p = message;
+		msg = undefined;
+	} else {
+		msg = message;
+	}
+	if (p instanceof DeferredPromise) {
+		return Promise.race([p.p, timeout(ms, msg)]).then(() => p) as any;
+	} else {
+		return Promise.race([p, timeout(ms, msg)]).then(() => p) as any;
+	}
+}

package/src/lifecycle/timeout/timeoutError.ts

@@ -0,0 +1,16 @@
+import { humanDate } from '../../date/timeString';
+
+/**
+ * Error when timeout() done
+ * @public
+ */
+export class TimeoutError extends Error {
+	constructor(time: number, what: string = 'no response') {
+		super(`Timeout: ${what} in ${humanDate.deltaTiny(time)}`);
+	}
+}
+
+/** @public */
+export function isTimeoutError(error: Error): error is TimeoutError {
+	return error instanceof TimeoutError;
+}

package/src/log/logger.ts

@@ -0,0 +1,148 @@
+import { nameFunction } from '../function/functionName';
+import { isWeb } from '../platform/os';
+
+export enum ColorKind {
+	DISABLE,
+	TERMINAL,
+	WEB,
+	DETECT,
+}
+
+export interface WrappedConsoleOptions {
+	parent?: Console;
+	bind?: boolean;
+}
+
+export abstract class WrappedConsole {
+	public declare info: Console['info'];
+	public declare log: Console['log'];
+	public declare success: Console['log'];
+	public declare debug: Console['debug'];
+	public declare error: Console['error'];
+	public declare trace: Console['trace'];
+	public declare warn: Console['warn'];
+	public declare assert: Console['assert'];
+
+	public declare time: Console['time'];
+	public declare timeEnd: Console['timeEnd'];
+	public declare timeLog: Console['timeLog'];
+	public declare count: Console['count'];
+	public declare countReset: Console['countReset'];
+	public declare group: Console['group'];
+	public declare groupCollapsed: Console['groupCollapsed'];
+	public declare groupEnd: Console['groupEnd'];
+
+	public declare table: Console['table'];
+	public declare dir: Console['dir'];
+	public declare clear: Console['clear'];
+
+	protected readonly title: string;
+	protected readonly parent: Console;
+	protected readonly bind: boolean;
+
+	constructor(title: string, { parent, bind }: WrappedConsoleOptions = {}) {
+		this.title = title;
+		this.parent = parent || console;
+		this.bind = bind || false;
+
+		this.info = this.wrapMessageAt('info', 0);
+		this.log = this.wrapMessageAt('log', 0);
+		this.success = this.wrapMessageAt('log', 0);
+		this.debug = this.wrapMessageAt('debug', 0);
+		this.error = this.wrapMessageAt('error', 0);
+		this.trace = this.wrapMessageAt('trace', 0);
+		this.warn = this.wrapMessageAt('warn', 0);
+		this.assert = this.wrapMessageAt('assert', 1);
+
+		this.time = this.wrapMessageAt('time', 0);
+		this.timeEnd = this.wrapMessageAt('timeEnd', 0);
+		this.timeLog = this.wrapMessageAt('timeLog', 0);
+		this.count = this.wrapMessageAt('count', 0);
+		this.countReset = this.wrapMessageAt('countReset', 0);
+		this.group = this.wrapMessageAt('group', 0);
+		this.groupCollapsed = this.wrapMessageAt('groupCollapsed', 0);
+
+		this.groupEnd = this.wrapSimple('groupEnd');
+		this.table = this.wrapExtra('table', ' <<table>>');
+		this.dir = this.wrapExtra('dir', ' <<dir>>');
+		this.clear = this.wrapExtra('clear', ' <<clear>>');
+	}
+
+	protected wrap<T extends keyof Omit<Console & { Console: any }, 'Console'>>(original: T): Function {
+		if (this.bind) {
+			return this.parent[original].bind(this.parent) as any;
+		} else {
+			return this.parent[original];
+		}
+	}
+
+	private wrapSimple<T extends keyof Omit<Console & { Console: any }, 'Console'>>(original: T): Console[T] {
+		return nameFunction('console:' + original, this.wrap(original) as any);
+	}
+
+	private wrapExtra<T extends keyof Omit<Console & { Console: any }, 'Console'>>(
+		original: T,
+		exMessage: string
+	): Console[T] {
+		const bindedFn = this.wrap(original);
+		return nameFunction('console:' + original, (...args: any[]) => {
+			this.log(exMessage);
+			bindedFn(...args);
+		});
+	}
+
+	protected createPrefix(message: string) {
+		let prefix = `[${this.title}]`;
+		if (message) {
+			prefix += `[${message}] `;
+		} else {
+			prefix += ' ';
+		}
+		return prefix;
+	}
+
+	private wrapMessageAt<T extends keyof Omit<Console & { Console: any }, 'Console'>>(
+		original: T,
+		messageLoc: number,
+		additionalPrefix?: string
+	): Console[T] {
+		let prefix = `[${this.title}]`;
+		if (additionalPrefix) {
+			prefix += `[${additionalPrefix}] `;
+		} else {
+			prefix += ' ';
+		}
+
+		const fn = this.wrap(original);
+
+		return nameFunction('console:' + original, (...args: any[]) => {
+			this.convertObjectArg(args, messageLoc);
+			this.processColorLabel(args, messageLoc, original, prefix);
+			fn(...args);
+		});
+	}
+
+	private convertObjectArg(args: any[], pos: number) {
+		const msg = args[pos];
+		if (args.length > pos) {
+			if (typeof msg === 'string') {
+				return;
+			}
+
+			args.splice(pos, 0, (isWeb ? ' %o' : ' %j').repeat(args.length - pos).substr(1));
+		} else {
+			args[pos] = '';
+		}
+	}
+
+	protected abstract processColorLabel(
+		normalizedArguments: any[],
+		messageLoc: number,
+		level: string,
+		prefix: string
+	): void;
+
+	protected uncolor(args: any[], pos: number, prefix: string, postfix: string) {
+		args[pos] = prefix + args[pos] + postfix;
+	}
+}

package/src/mapSet/customSet.ts

@@ -0,0 +1,91 @@
+/** Find the index of given item */
+export interface Finder<Type> {
+	(this: Type[], item: Type): number;
+}
+
+type MyFinder<Type> = (item: Type) => number;
+
+export function RegexpFinder(this: RegExp[], item: RegExp): number {
+	return this.findIndex((e) => e.toString() === item.toString());
+}
+
+/**
+ * Like a Set, but use custom compare function insteadof ===
+ */
+export class CustomSet<Type = string> {
+	protected registry: Type[];
+	private finder: MyFinder<Type>;
+
+	constructor(finder: Finder<Type> = Array.prototype.indexOf) {
+		this.registry = [];
+		this.finder = finder.bind(this.registry);
+	}
+
+	setFinder(finder: Finder<Type>) {
+		this.finder = finder.bind(this.registry);
+	}
+
+	has(item: Type): boolean {
+		return this.finder(item) !== -1;
+	}
+
+	add(item: Type): boolean {
+		const index = this.finder(item);
+		if (index === -1) {
+			this.registry.push(item);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * @returns all added values
+	 */
+	addAll(items: Type[]): Type[] {
+		return items.filter((e) => this.add(e));
+	}
+
+	delete(item: Type): boolean {
+		const index = this.finder(item);
+		if (index === -1) {
+			return false;
+		} else {
+			this.registry.splice(index, 1);
+			return true;
+		}
+	}
+
+	/**
+	 * @returns all deleted values
+	 */
+	deleteAll(items: Type[]): Type[] {
+		return items.filter((e) => this.delete(e));
+	}
+
+	clear() {
+		this.registry.length = 0;
+	}
+
+	get length() {
+		return this.registry.length;
+	}
+
+	get size() {
+		return this.registry.length;
+	}
+
+	[Symbol.iterator](): Iterator<Type> {
+		return this.registry[Symbol.iterator]();
+	}
+	keys(): Iterator<Type> {
+		return this.registry[Symbol.iterator]();
+	}
+	values(): Iterator<Type> {
+		return this.registry[Symbol.iterator]();
+	}
+
+	toArray() {
+		return this.registry.slice();
+	}
+}

package/src/mapSet/extendMap.ts

@@ -0,0 +1,40 @@
+export interface MapLike<V> {
+	[id: string]: V;
+}
+
+/**
+ * A map, will throw error when try to get not exists key
+ */
+export class ExtendMap<K, V> extends Map<K, V> {
+	/**
+	 * Get value from map, if not exists, throw an error
+	 */
+	public get(id: K): V;
+	/**
+	 * Get value from map, if not exists, return def instead (not insert it into map)
+	 */
+	public get(id: K, def: V): V;
+
+	public get(id: K, def?: V): V {
+		if (super.has(id)) {
+			return super.get(id)!;
+		} else if (arguments.length === 2) {
+			return def!;
+		} else {
+			throw new Error(`Unknown key {${id}} in map.`);
+		}
+	}
+
+	/**
+	 * Get a value, if not exists, call init() and set to map
+	 */
+	public entry(id: K, init: (id: K) => V): V {
+		if (super.has(id)) {
+			return super.get(id)!;
+		} else {
+			const nv = init(id);
+			super.set(id, nv);
+			return nv;
+		}
+	}
+}

package/src/misc/assertNotNull.ts

@@ -0,0 +1,21 @@
+/**
+ * assert value is not null or undefined or NaN
+ * @public
+ */
+export function assertNotNull<T>(val: T | null | undefined): T {
+	console.assert(val !== undefined && val !== null, 'AssertValue failed, got %s(%s).', typeof val, val);
+	return val!;
+}
+
+/**
+ * assert value is not null or undefined or NaN
+ * @throws Value is null or undefined
+ * @public
+ */
+export function throwNull<T>(val: T) {
+	if (val === undefined || val === null) {
+		return val!;
+	} else {
+		throw new Error('Value is ' + typeof val);
+	}
+}

package/src/object/definePublicConstant.ts

@@ -0,0 +1,10 @@
+export function definePublicConstant(object: any, propertyKey: string | symbol, value: any) {
+	if (object[propertyKey] === value) return;
+	delete object[propertyKey];
+	Object.defineProperty(object, propertyKey, {
+		configurable: false,
+		enumerable: true,
+		writable: false,
+		value,
+	});
+}

package/src/object/initOnRead.ts

@@ -0,0 +1,27 @@
+/** @public */
+export interface InitFunc<O, T> {
+	(this: O): T;
+}
+
+/**
+ * Define property on target, call init it when first use, them memorize
+ * @public
+ */
+export function initOnRead<O, T extends keyof O>(target: any, propertyKey: T, init: InitFunc<O, O[T]>) {
+	if (target.hasOwnProperty(propertyKey)) {
+		return;
+	}
+	Object.defineProperty(target, propertyKey, {
+		configurable: true,
+		get: function (): O[T] {
+			const data = init.call(this);
+			delete target[propertyKey];
+			target[propertyKey] = data;
+			return data;
+		},
+		set(v: T) {
+			delete target[propertyKey];
+			target[propertyKey] = v;
+		},
+	});
+}

package/src/object/objectPath.ts

@@ -0,0 +1,10 @@
+/**
+ * Get deep child property of an object
+ * @param path object path seprate by "."
+ */
+export function objectPath(obj: object, path: string): any {
+	path.split('.').every((name) => {
+		return (obj = (obj as any)[name]);
+	});
+	return obj;
+}

package/src/object/objectSame.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,11 @@
+/**
+ * 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

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

package/src/path/pathArray.ts

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,22 @@
+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];
+}
+
+export function x() {
+	return 1;
+}