@idlebox/common 1.3.4 → 1.3.7

package/src/lifecycle/promise/cancellationToken/driver.browser.ts

@@ -1,55 +0,0 @@
-import { EventHandler } from '../../event/event';
-
-import type { CancellationDriver, __CancellationToken } from './source';
-
-declare const AbortController: any; // TODO
-declare type AbortController = any; // TODO
-
-/** @internal */
-export class CancellationDriverBrowser implements CancellationDriver {
-	private readonly controller: AbortController;
-	public readonly token: __CancellationToken;
-	private readonly disposeList: (() => void)[] = [];
-
-	constructor() {
-		this.controller = new AbortController();
-
-		const signal = this.controller.signal;
-		signal.addEventListener('abort', () => {
-			token.isCancellationRequested = true;
-		});
-
-		const disposeList = this.disposeList;
-		const token = {
-			isCancellationRequested: false,
-			onCancellationRequested(listener: EventHandler<void>) {
-				const callback = () => listener();
-
-				signal.addEventListener('abort', callback);
-
-				const dispose = () => signal.removeEventListener('abort', callback);
-				disposeList.push(dispose);
-
-				return { dispose };
-			},
-		};
-
-		this.token = token;
-	}
-
-	cancel() {
-		if (this.token.isCancellationRequested) {
-			console.warn('[CancellationTokenSource] is already canceled.');
-		} else {
-			this.token.isCancellationRequested = true;
-			this.controller.abort();
-		}
-	}
-
-	dispose() {
-		for (const removeListener of this.disposeList) removeListener();
-		if (!this.token.isCancellationRequested) {
-			this.controller.abort();
-		}
-	}
-}

package/src/lifecycle/promise/cancellationToken/driver.common.ts

@@ -1,43 +0,0 @@
-import { IDisposable } from '../../dispose/lifecycle';
-import { Emitter, EventHandler } from '../../event/event';
-
-import type { CancellationDriver, __CancellationToken } from './source';
-
-/** @internal */
-export class CancellationDriverCommon implements CancellationDriver {
-	private readonly emitter: Emitter<void>;
-	public readonly token: __CancellationToken;
-	private readonly disposeList: IDisposable[] = [];
-
-	constructor() {
-		const emitter = new Emitter<void>();
-		this.emitter = emitter;
-
-		const disposeList = this.disposeList;
-		const token = {
-			isCancellationRequested: false,
-			onCancellationRequested(callback: EventHandler<void>) {
-				const ret = emitter.handle(callback);
-				disposeList.push(ret);
-				return ret;
-			},
-		};
-		this.token = token;
-	}
-
-	cancel() {
-		if (this.token.isCancellationRequested) {
-			console.warn('[CancellationTokenSource] is already canceled.');
-		} else {
-			this.token.isCancellationRequested = true;
-			this.emitter.fire();
-		}
-	}
-
-	dispose() {
-		for (const listen of this.disposeList) listen.dispose();
-		if (!this.token.isCancellationRequested) {
-			this.cancel();
-		}
-	}
-}

package/src/lifecycle/promise/cancellationToken/source.ts

@@ -1,48 +0,0 @@
-import { globalObject } from '../../../platform/globalObject';
-import { IDisposable } from '../../dispose/lifecycle';
-import { DisposableOnce } from '../../dispose/lifecycle.sync';
-import { EventHandler } from '../../event/event';
-import { CancellationDriverBrowser } from './driver.browser';
-import { CancellationDriverCommon } from './driver.common';
-
-/** @public */
-export interface CancellationToken {
-	readonly isCancellationRequested: boolean;
-	onCancellationRequested(callback: EventHandler<void>): IDisposable;
-}
-
-/** @internal */
-export interface __CancellationToken {
-	isCancellationRequested: boolean;
-	onCancellationRequested(callback: EventHandler<void>): IDisposable;
-}
-
-/** @internal */
-export interface CancellationDriver extends IDisposable {
-	readonly token: CancellationToken;
-	cancel(): void;
-}
-
-/** @public */
-export class CancellationTokenSource extends DisposableOnce implements IDisposable {
-	private readonly driver: CancellationDriver;
-	public readonly token: CancellationToken;
-
-	constructor() {
-		super();
-		if ('AbortController' in globalObject) {
-			this.driver = new CancellationDriverBrowser();
-		} else {
-			this.driver = new CancellationDriverCommon();
-		}
-		this.token = this.driver.token;
-	}
-
-	cancel(): void {
-		this.driver.cancel();
-	}
-
-	_dispose(): void {
-		this.driver.dispose();
-	}
-}

package/src/lifecycle/promise/deferredPromise.ts

@@ -1,102 +0,0 @@
-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;
-		});
-	}
-
-	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

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