@idlebox/common 1.4.19 → 1.4.21

package/src/lifecycle/event/memorized.ts

@@ -1,5 +1,6 @@
-import type { IDisposable } from '../dispose/lifecycle.js';
-import { Emitter, type EventHandler } from './event.js';
+import type { IDisposable } from '../dispose/disposable.js';
+import { Emitter } from './event.js';
+import type { EventHandler } from './type.js';
 
 /**
  * 会记住上次fire的内容，并在每个新的handler注册时立即调用一次的Emitter
@@ -7,29 +8,29 @@ import { Emitter, type EventHandler } from './event.js';
  * @public
  */
 export class MemorizedEmitter<T> extends Emitter<T> {
-	private _memo?: T;
-	private _is_memo = false;
+	private _memo?: { data: T };
 
 	public override fire(data: T) {
-		this._memo = data;
-		this._is_memo = true;
-		return super.fire(data);
+		super.fire(data);
+		this._memo = { data };
 	}
 
 	public override fireNoError(data: T) {
-		this._memo = data;
-		this._is_memo = true;
-		return super.fireNoError(data);
+		super.fireNoError(data);
+		this._memo = { data };
 	}
 
 	public override handle(callback: EventHandler<T>): IDisposable {
-		if (this._is_memo) callback(this._memo!);
+		if (this._memo) callback(this._memo.data);
 		return super.handle(callback);
 	}
 
+	public override once(): never {
+		throw new Error('once() is not supported for MemorizedEmitter');
+	}
+
 	public forget() {
 		this._memo = undefined;
-		this._is_memo = false;
 	}
 
 	override dispose(): void {

package/src/lifecycle/event/type.ts

@@ -0,0 +1,55 @@
+import type { IDisposable } from '../dispose/disposable.js';
+import type { Emitter } from './event.js';
+
+/**
+ * 事件注册对象
+ */
+export interface IEventEmitter<T = unknown> extends IDisposable {
+	/**
+	 * @returns 当前注册回调数量
+	 */
+	listenerCount(): number;
+
+	/**
+	 * 触发本事件，任何一个回调错误，都会导致直接抛出异常，其他未知数量的回调将不会被执行
+	 * @param data 回调数据
+	 */
+	fire(data: T): void;
+
+	/**
+	 * 与 `fire()`相同，但是忽略任何错误
+	 * 即便出错也继续执行全部callback
+	 *
+	 * 抛出的异常会直接丢弃
+	 * 除了disposed错误外，其他错误都不会被重新抛出
+	 */
+	fireNoError(data: T): void;
+
+	/**
+	 * 注册本事件的新回调
+	 * @param callback 回调函数
+	 */
+	readonly register: EventRegister<T>;
+
+	/**
+	 * @alias register AI喜欢用event
+	 */
+	readonly event: EventRegister<T>;
+
+	/**
+	 * 注册一次性回调
+	 * @param callback 回调函数
+	 */
+	once(callback: EventHandler<T>): IDisposable;
+}
+
+export type EventHandler<T> = (data: T) => void;
+
+export interface EventRegister<T> {
+	(callback: EventHandler<T>): IDisposable;
+	once(callback: EventHandler<T>): IDisposable;
+}
+
+export type EventEmitterMap<T extends Record<string, unknown>> = {
+	[K in keyof T]: Emitter<T[K]>;
+};

package/src/lifecycle/global/global-lifecycle.ts

@@ -0,0 +1,49 @@
+import { globalSingletonStrong } from '../../platform/globalSingleton.js';
+import { createSymbol } from '../../platform/globalSymbol.js';
+import { UnorderedAsyncDisposable, type EnhancedAsyncDisposable } from '../dispose/async-disposable.js';
+import { _debug_dispose } from '../dispose/debug.js';
+import type { IAsyncDisposable, IDisposable } from '../dispose/disposable.js';
+
+const symbol = createSymbol('lifecycle', 'application');
+
+function create(): EnhancedAsyncDisposable {
+	return new UnorderedAsyncDisposable('global');
+}
+
+const logger = _debug_dispose.extend('global');
+
+/**
+ * Add object into global disposable store, it will be dispose when call to `disposeGlobal`
+ */
+export function registerGlobalLifecycle(object: IDisposable | IAsyncDisposable) {
+	globalSingletonStrong(symbol, create)._register(object);
+}
+
+/**
+ * Same as disposeGlobal, but do not throw by duplicate call
+ */
+export function ensureDisposeGlobal() {
+	const obj = globalSingletonStrong<EnhancedAsyncDisposable>(symbol);
+	if (obj && !obj.disposed) {
+		return Promise.try(() => obj.dispose());
+	}
+	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<EnhancedAsyncDisposable>(symbol);
+	if (obj?.disposed) {
+		throw new Error('global already disposed.');
+	}
+	if (obj) {
+		return Promise.try(() => obj.dispose());
+	}
+	if (logger.enabled) logger(`dispose global (not exists)`);
+	return Promise.resolve();
+}

package/src/log/logger.ts

@@ -1,4 +1,4 @@
-import { nameFunction } from '../function/functionName.js';
+import { nameFunction } from '../debugging/object-with-name.js';
 import { isWeb } from '../platform/os.js';
 
 export enum ColorKind {

package/src/{mapSet/customSet.ts → map-and-set/custom-set.ts}

@@ -1,34 +1,20 @@
 /** Find the index of given item */
 export type 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 ===
+ * Like a Set, but use custom compare function instead ===
  */
-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);
-	}
+export abstract class CustomSet<Type> {
+	protected registry: Type[] = [];
 
-	setFinder(finder: Finder<Type>) {
-		this.finder = finder.bind(this.registry);
-	}
+	protected abstract compare(item1: Type, item2: Type): number;
 
 	has(item: Type): boolean {
-		return this.finder(item) !== -1;
+		return this.registry.findIndex((e) => this.compare(e, item) === 0) !== -1;
 	}
 
 	add(item: Type): boolean {
-		const index = this.finder(item);
+		const index = this.registry.findIndex((e) => this.compare(e, item) === 0);
 		if (index === -1) {
 			this.registry.push(item);
 			return true;
@@ -44,7 +30,7 @@ export class CustomSet<Type = string> {
 	}
 
 	delete(item: Type): boolean {
-		const index = this.finder(item);
+		const index = this.registry.findIndex((e) => this.compare(e, item) === 0);
 		if (index === -1) {
 			return false;
 		}
@@ -67,10 +53,6 @@ export class CustomSet<Type = string> {
 		return this.registry.length;
 	}
 
-	get size() {
-		return this.registry.length;
-	}
-
 	[Symbol.iterator](): Iterator<Type> {
 		return this.registry[Symbol.iterator]();
 	}
@@ -80,7 +62,6 @@ export class CustomSet<Type = string> {
 	values(): Iterator<Type> {
 		return this.registry[Symbol.iterator]();
 	}
-
 	toArray() {
 		return this.registry.slice();
 	}

package/src/{mapSet/extendMap.ts → map-and-set/required-map.ts}

@@ -1,11 +1,7 @@
-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> {
+export class RequiredMap<K, V> extends Map<K, V> {
 	/**
 	 * Get value from map, if not exists, throw an error
 	 */
@@ -26,7 +22,7 @@ export class ExtendMap<K, V> extends Map<K, V> {
 	}
 
 	/**
-	 * Get a value, if not exists, call init() and set to map
+	 * Get a value, if not exists, call init() and save to map
 	 */
 	public entry(id: K, init: (id: K) => V): V {
 		if (super.has(id)) {
@@ -37,3 +33,22 @@ export class ExtendMap<K, V> extends Map<K, V> {
 		return nv;
 	}
 }
+
+/**
+ * A map that holds instances, automatically create new instance
+ */
+export abstract class InstanceMap<K, V> extends Map<K, V> {
+	protected abstract instance(key: K): V;
+
+	/**
+	 * Get a value, if not exists, call init() and save to map
+	 */
+	public override get(id: K): V {
+		if (super.has(id)) {
+			return super.get(id)!;
+		}
+		const nv = this.instance(id);
+		super.set(id, nv);
+		return nv;
+	}
+}

package/src/object/objectSame.ts

@@ -1,4 +1,4 @@
-import { isArraySame } from '../array/arraySame.js';
+import { isArraySame } from '../array/is-same.js';
 
 /**
  * Should ensure a and b is none-null before call this

package/src/path/pathArray.ts

@@ -1,5 +1,5 @@
 import { isWindows } from '../platform/os.js';
-import { ucfirst } from '../string/castCase.js';
+import { ucfirst } from '../string/case-cast.js';
 import { normalizePath } from './normalizePath.js';
 
 const isAbsolute = /^[a-z]:[/\\]/i;

package/src/path/pathCalc.ts

@@ -0,0 +1,18 @@
+import { normalizePath } from './normalizePath.js';
+
+/**
+ * 检查两个路径是否存在父子关系
+ *
+ * @param parent 父目录
+ * @param child 子目录
+ * @param equalsOk 默认为false，相等不属于父子。设为true则相等返回true
+ * @returns 如果parent是child的父目录，则返回true
+ */
+export function isPathContains(parent: string, child: string, equalsOk = false): boolean {
+	const nParent = normalizePath(parent);
+	const nChild = normalizePath(child);
+
+	if (nParent === nChild) return equalsOk;
+
+	return nChild.startsWith(`${nParent}/`);
+}

package/src/platform/compile.ts

@@ -0,0 +1,6 @@
+declare global {
+	interface ImportMeta {
+		env?: Record<string, string>;
+	}
+}
+export const isProductionMode = import.meta.env?.['MODE'] === 'production';

package/src/platform/globalSingleton.ts

@@ -1,6 +1,6 @@
 /** biome-ignore-all lint/suspicious/noShadowRestrictedNames:  */
 
-import { functionName } from '../function/functionName.js';
+import { functionName } from '../debugging/object-with-name.js';
 import { ensureGlobalObject } from './globalObject.js';
 
 const singletonRegistry = ensureGlobalObject('@@idlebox/global-singleton', () => {

package/src/platform/os.ts

@@ -6,7 +6,7 @@ declare const global: any;
 /**
  * buy detect process.pid, is there any bundler mock this?
  */
-export const hasProcess = typeof process?.pid === 'number';
+export const hasProcess = typeof process !== 'undefined' && typeof process?.pid === 'number';
 export const hasWindow = typeof window !== 'undefined' && globalThis === window;
 export const hasGlobal = typeof global !== 'undefined' && globalThis === global;
 

package/src/{lifecycle/promise/deferredPromise.ts → promise/deferred-promise.ts}

@@ -1,5 +1,7 @@
-import type { IDisposable } from '../dispose/lifecycle.js';
-import { CanceledError } from './cancel.js';
+import { CanceledError, TimeoutError } from '@idlebox/errors';
+import type { TimeoutType } from '../autoindex.js';
+import type { IDisposable } from '../lifecycle/dispose/disposable.js';
+import { scheduler } from '../schedule/scheduler.js';
 
 export type ValueCallback<T = any> = (value: T | Promise<T>) => void;
 export type ProgressCallback<T = any> = (value: T) => void;
@@ -13,25 +15,27 @@ export interface IProgressHolder<T, PT> {
  * @public
  */
 export class DeferredPromise<T, PT = any> {
-	readonly p: Promise<T> & IProgressHolder<T, PT>;
-	#completeCallback!: ValueCallback<T>;
-	#errorCallback!: (err: any) => void;
+	readonly promise: Promise<T> & IProgressHolder<T, PT>;
+	#completeCallback: ValueCallback<T>;
+	#errorCallback: (err: any) => void;
 	#success?: boolean;
 	#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;
-				},
+		const { promise, resolve, reject } = Promise.withResolvers<T>();
+		this.#completeCallback = resolve;
+		this.#errorCallback = reject;
+
+		this.promise = Object.assign(promise, {
+			progress: (fn: ProgressCallback<PT>) => {
+				this.progress(fn);
+				return this.p;
 			},
-		);
+		});
+	}
+
+	get p() {
+		return this.promise;
 	}
 
 	/**
@@ -42,7 +46,7 @@ export class DeferredPromise<T, PT = any> {
 	notify(progress: PT): this {
 		if (this.#success !== undefined) throw new Error('no more event after settled');
 		for (const cb of this.#progressList) {
-			cb(progress);
+			scheduler(cb.bind(undefined, progress));
 		}
 		return this;
 	}
@@ -50,9 +54,8 @@ export class DeferredPromise<T, PT = any> {
 	/**
 	 * register a progress callback
 	 * @param fn progress callback function, will be called when notify is called
-	 * @returns
 	 */
-	progress(fn: ProgressCallback<PT>): IDisposable {
+	protected progress(fn: ProgressCallback<PT>): IDisposable {
 		if (this.#success !== undefined) throw new Error('no more listener after settled');
 		this.#progressList.push(fn);
 
@@ -75,9 +78,16 @@ export class DeferredPromise<T, PT = any> {
 	}
 
 	/**
-	 * whether the promise is completed (resolved or rejected)
+	 * @deprecated use settled
 	 */
-	get completed(): boolean {
+	get completed() {
+		return this.settled;
+	}
+
+	/**
+	 * whether the promise is settled (resolved or rejected)
+	 */
+	get settled(): boolean {
 		return this.#success !== undefined;
 	}
 
@@ -93,31 +103,62 @@ export class DeferredPromise<T, PT = any> {
 	 * resolve the promise
 	 */
 	complete(value: T) {
+		if (this.settled) return;
 		this.#success = true;
+		this.#after_settled();
 		this.#completeCallback(value);
-		this.#no_more_progress();
 	}
 
 	/**
 	 * reject the promise
 	 */
 	error(err: any) {
+		if (this.settled) return;
 		this.#success = false;
+		this.#after_settled();
 		this.#errorCallback(err);
-		this.#no_more_progress();
 	}
 
 	/**
 	 * reject the deferred with {CancelError}
 	 */
 	cancel() {
-		this.#success = false;
-		this.#errorCallback(new CanceledError());
-		this.#no_more_progress();
+		this.error(new CanceledError());
 	}
 
-	#no_more_progress() {
+	#after_settled() {
 		this.#progressList.length = 0;
+		this.#cancel_timeout();
+	}
+
+	get callback() {
+		if (this.#success !== undefined) throw new Error('can not generate callback after settled');
+
+		return (error?: null | undefined | Error, data?: T) => {
+			if (error) {
+				this.error(error);
+			} else {
+				this.complete(data as any);
+			}
+		};
+	}
+
+	#timer?: TimeoutType;
+	#cancel_timeout() {
+		if (this.#timer) {
+			clearTimeout(this.#timer);
+			this.#timer = undefined;
+		}
+	}
+	timeout(ms: number) {
+		if (this.settled) throw new Error('no more timeout after settled');
+		this.#timer = setTimeout(() => {
+			this.error(new TimeoutError(ms, 'promise not settled'));
+		}, ms);
+
+		return {
+			dispose: () => this.#cancel_timeout(),
+		};
 	}
 
 	/**

package/src/promise/{promiseCollection.ts → promise-list.ts}

@@ -1,5 +1,5 @@
-import { CanceledError } from '../lifecycle/promise/cancel.js';
-import { DeferredPromise } from '../lifecycle/promise/deferredPromise.js';
+import { CanceledError } from '@idlebox/errors';
+import { DeferredPromise } from './deferred-promise.js';
 
 export class PromiseCollection {
 	protected readonly promiseList: Record<string, DeferredPromise<any>> = {};

package/src/re-export.ts

@@ -0,0 +1 @@
+export * from '@idlebox/errors';

package/src/reflection/classes/pointer.ts

@@ -0,0 +1,54 @@
+export type Ref<T = any> = { reference: T };
+
+export function Pointer<T>(_object: Ref<T>): T {
+	const object = _object as any;
+
+	return new Proxy(
+		{},
+		{
+			apply(_, thisArg, argArray) {
+				return Reflect.apply(object.reference, thisArg, argArray);
+			},
+			construct(_, argArray, new_) {
+				return Reflect.construct(object.reference, argArray, new_);
+			},
+			defineProperty(_, property, attributes) {
+				return Reflect.defineProperty(object.reference, property, attributes);
+			},
+			deleteProperty(_, p) {
+				return Reflect.deleteProperty(object.reference, p);
+			},
+			get(_, p, _receiver) {
+				const value = object.reference[p];
+				if (typeof value === 'function') {
+					return value.bind(object.reference);
+				}
+				return value;
+			},
+			getOwnPropertyDescriptor(_, p) {
+				return Reflect.getOwnPropertyDescriptor(object.reference, p);
+			},
+			getPrototypeOf(_) {
+				return Reflect.getPrototypeOf(object);
+			},
+			has(_, p) {
+				return Reflect.has(object.reference, p);
+			},
+			isExtensible(_) {
+				return Reflect.isExtensible(object);
+			},
+			ownKeys(_) {
+				return Reflect.ownKeys(object);
+			},
+			preventExtensions(_) {
+				return Reflect.preventExtensions(object);
+			},
+			set(_, p, newValue, receiver) {
+				return Reflect.set(object.reference, p, newValue, receiver);
+			},
+			setPrototypeOf(_, v) {
+				return Reflect.setPrototypeOf(object.reference, v);
+			},
+		},
+	) as any;
+}

package/src/reflection/classes/singleton.ts

@@ -1,32 +1,41 @@
-import { hookClass } from './hookClass.js';
+import { definePrivateConstant } from '../../autoindex.js';
 
-export const singletonSymbol = Symbol('@gongt/singleton');
+export const singletonSymbol = Symbol('@idlebox/singleton');
 
 export enum SingletonType {
 	Throw = 0,
-	Return = 1,
+	ReturnSame = 1,
 }
 
-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 = [];
-		}
+type AnyClass = new (...args: any) => any;
 
-		hook.beforeConstruct.push((cls) => {
-			if (cls[singletonSymbol]) {
-				if (type === SingletonType.Return) {
-					return cls[singletonSymbol];
+/**
+ * 单例类修饰器
+ * @param type
+ * @returns
+ */
+export function singleton(type: SingletonType = SingletonType.ReturnSame) {
+	return <T extends AnyClass>(Class: T, ctx: ClassDecoratorContext): T => {
+		if (ctx.kind !== 'class') throw new Error(`this decorator can only be applied to classes`);
+
+		const name = ctx.name;
+		return new Proxy(Class, {
+			construct(target, args) {
+				const exists = (Class as any)[singletonSymbol];
+				if (exists) {
+					if (type === SingletonType.Throw) throw new Error(`can not recreate singleton class #${name}`);
+					return exists;
 				}
-				throw new Error(`Duplicate new singleton class [${target.name}]`);
-			}
-		});
-		hook.afterConstruct.push((obj) => {
-			target[singletonSymbol] = obj;
+				const instance = Reflect.construct(target, args);
+				return instance;
+			},
 		});
 	};
 }
+
+export function createSingleton<T>(Class: new () => T): T {
+	if (!(Class as any)[singletonSymbol]) {
+		definePrivateConstant(Class, singletonSymbol, new Class());
+	}
+	return (Class as any)[singletonSymbol];
+}

package/src/reflection/methods/bind.ts

@@ -1,25 +1,17 @@
-/**
- * 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];
+import { nameObject } from '../../autoindex.js';
 
-				const fn = oldFunc.bind(this);
-				Object.defineProperty(this, propertyKey, {
-					value: fn,
-					writable: false,
-					enumerable: true,
-					configurable: false,
-				});
-				return fn;
-			},
-		};
+export function bindThis(method: Function, context: ClassMethodDecoratorContext) {
+	if (context.kind !== 'method') throw new Error(`this decorator can only be applied to classes`);
+
+	if (context.static) throw new TypeError('this decorator not supported on static methods.');
+	if (context.private) {
+		return nameObject(`${context.name.toString()}.bounded`, function (this: any, ...args: any[]) {
+			return method.apply(this, args);
+		});
+	} else {
+		context.addInitializer(function (this: any) {
+			this[context.name] = nameObject(`${context.name.toString()}.bounded`, method.bind(this));
+		});
+		return undefined;
 	}
-	throw new TypeError('@bindThis can only use with method, but not property.');
-};
+}