@idlebox/common 1.3.6 → 1.3.7

package/src/lifecycle/timeout/timeout.ts

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

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

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

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

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

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

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

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

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

@@ -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];
-		}
-	}
-}