@idlebox/common 1.4.0 → 1.4.2

package/src/lifecycle/event/event.ts

@@ -1,4 +1,4 @@
-import { IDisposable } from '../dispose/lifecycle';
+import { IDisposable } from '../dispose/lifecycle.js';
 
 export interface EventHandler<T> {
 	(data: T): void;
@@ -8,12 +8,15 @@ export interface EventRegister<T> {
 	(callback: EventHandler<T>): IDisposable;
 }
 
+type DeferFn = () => void;
+
 /**
  * 事件注册对象
  * @public
  */
 export class Emitter<T> implements IDisposable {
 	protected readonly _callbacks: EventHandler<T>[] = [];
+	private executing: boolean = false;
 
 	constructor() {
 		this.handle = this.handle.bind(this);
@@ -31,8 +34,15 @@ export class Emitter<T> implements IDisposable {
 	 * @param data 回调数据
 	 */
 	public fire(data: T) {
-		for (const callback of this._callbacks) {
-			callback(data);
+		this.requireNotExecuting();
+		this.executing = true;
+		try {
+			for (const callback of this._callbacks) {
+				callback(data);
+			}
+		} finally {
+			this.doDefer();
+			this.executing = false;
 		}
 	}
 
@@ -40,6 +50,8 @@ export class Emitter<T> implements IDisposable {
 	 * 与 `fire()`相同，但是忽略任何错误，并且即便出错也继续执行全部callback
 	 */
 	public fireNoError(data: T) {
+		this.requireNotExecuting();
+		this.executing = true;
 		for (const callback of this._callbacks) {
 			try {
 				callback(data);
@@ -47,6 +59,8 @@ export class Emitter<T> implements IDisposable {
 				console.error('Error ignored: ', e);
 			}
 		}
+		this.doDefer();
+		this.executing = false;
 	}
 
 	/**
@@ -61,18 +75,55 @@ export class Emitter<T> implements IDisposable {
 	 * @param callback 回调函数
 	 */
 	handle(callback: EventHandler<T>): IDisposable {
-		this._callbacks.unshift(callback);
+		this.requireNotExecuting();
+		let disposed = false;
+		this._callbacks.unshift((e) => {
+			if (!disposed) callback(e);
+		});
+		const realDispose = () => {
+			const index = this._callbacks.indexOf(callback);
+			if (index !== -1) {
+				this._callbacks.splice(index, 1);
+			}
+		};
 		return {
 			dispose: () => {
-				const index = this._callbacks.indexOf(callback);
-				if (index !== -1) {
-					this._callbacks.splice(index, 1);
+				disposed = true;
+				if (this.executing) {
+					this.defer(realDispose);
+				} else {
+					realDispose();
 				}
 			},
 		};
 	}
 
+	/**
+	 * 注册一次性回调
+	 * @param callback 回调函数
+	 */
+	once(callback: EventHandler<T>): IDisposable {
+		this.requireNotExecuting();
+		const disposable = this.handle((data) => {
+			callback(data);
+			disposable.dispose();
+		});
+		return disposable;
+	}
+
+	private defers: DeferFn[] = [];
+	public defer(fn: DeferFn) {
+		this.defers.push(fn);
+	}
+	private doDefer() {
+		for (const fn of this.defers) {
+			fn();
+		}
+		this.defers.length = 0;
+	}
+
 	dispose() {
+		this.requireNotExecuting();
 		this._callbacks.length = 0;
 		this.fireNoError =
 			this.fire =
@@ -81,4 +132,10 @@ export class Emitter<T> implements IDisposable {
 					throw new Error('Event is disposed');
 				};
 	}
+
+	private requireNotExecuting() {
+		if (this.executing) {
+			throw new Error('conflict state, emitter is firing');
+		}
+	}
 }

package/src/lifecycle/event/memorized.ts

@@ -1,5 +1,5 @@
-import { IDisposable } from '../dispose/lifecycle';
-import { Emitter, EventHandler } from './event';
+import { IDisposable } from '../dispose/lifecycle.js';
+import { Emitter, EventHandler } from './event.js';
 
 /**
  * 会记住上次fire的内容，并在每个新的handler注册时立即调用一次的Emitter

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

@@ -1,6 +1,6 @@
-import { EventHandler } from '../../event/event';
+import { EventHandler } from '../../event/event.js';
 
-import type { CancellationDriver, __CancellationToken } from './source';
+import type { CancellationDriver, __CancellationToken } from './source.js';
 
 declare const AbortController: any; // TODO
 declare type AbortController = any; // TODO

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

@@ -1,7 +1,7 @@
-import { IDisposable } from '../../dispose/lifecycle';
-import { Emitter, EventHandler } from '../../event/event';
+import { IDisposable } from '../../dispose/lifecycle.js';
+import { Emitter, EventHandler } from '../../event/event.js';
 
-import type { CancellationDriver, __CancellationToken } from './source';
+import type { CancellationDriver, __CancellationToken } from './source.js';
 
 /** @internal */
 export class CancellationDriverCommon implements CancellationDriver {

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

@@ -1,9 +1,9 @@
-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';
+import { globalObject } from '../../../platform/globalObject.js';
+import { IDisposable } from '../../dispose/lifecycle.js';
+import { DisposableOnce } from '../../dispose/lifecycle.sync.js';
+import { EventHandler } from '../../event/event.js';
+import { CancellationDriverBrowser } from './driver.browser.js';
+import { CancellationDriverCommon } from './driver.common.js';
 
 /** @public */
 export interface CancellationToken {

package/src/lifecycle/promise/deferredPromise.ts

@@ -1,4 +1,4 @@
-import { CanceledError } from './cancel';
+import { CanceledError } from './cancel.js';
 
 export type ValueCallback<T = any> = (value: T | Promise<T>) => void;
 export type ProgressCallback<T = any> = (value: T) => void;

package/src/lifecycle/timeout/timeout.ts

@@ -1,5 +1,5 @@
-import { TimeoutError } from './timeoutError';
-import { DeferredPromise } from '../promise/deferredPromise';
+import { TimeoutError } from './timeoutError.js';
+import { DeferredPromise } from '../promise/deferredPromise.js';
 
 /**
  * @returns promise reject with TimeoutError after specific time

package/src/lifecycle/timeout/timeoutError.ts

@@ -1,4 +1,4 @@
-import { humanDate } from '../../date/timeString';
+import { humanDate } from '../../date/timeString.js';
 
 /**
  * Error when timeout() done

package/src/log/logger.ts

@@ -1,5 +1,5 @@
-import { nameFunction } from '../function/functionName';
-import { isWeb } from '../platform/os';
+import { nameFunction } from '../function/functionName.js';
+import { isWeb } from '../platform/os.js';
 
 export enum ColorKind {
 	DISABLE,

package/src/misc/package.json.ts

@@ -12,6 +12,50 @@ interface IOverridesObject {
 
 type IOverrides = Record<string, string | IOverridesObject>;
 
+export interface IExportCondition {
+	node?: string | IExportCondition;
+	'node-addons'?: string | IExportCondition;
+	browser?: string | IExportCondition;
+	require?: string;
+	import?: string;
+	types?: string;
+	default?: string;
+	[platform: string]: undefined | string | IExportCondition;
+}
+
+export interface IExportMap {
+	[exportPath: string]: string | IExportCondition;
+}
+export interface IFullExportsField {
+	[exportPath: string]: IExportCondition;
+}
+
+export type IExportsField = string | IExportCondition | IExportMap;
+
+function isPathMap(exportsField: IExportCondition | IExportMap): exportsField is IExportMap {
+	return Object.keys(exportsField).some((e) => e.startsWith('.'));
+}
+export function parseExportsField(exports: IExportsField): IFullExportsField {
+	if (typeof exports === 'string') {
+		return { '.': { default: exports } };
+	}
+	if (!isPathMap(exports)) {
+		return { '.': exports };
+	}
+	let ret: IFullExportsField = {};
+	for (const [path, def] of Object.entries(exports)) {
+		if (typeof def === 'string') {
+			ret[path] = { default: def };
+		} else {
+			ret[path] = def;
+		}
+	}
+	return ret;
+}
+
+// export function resolveImport(exports:IFullExportsField, file:string,platform:string, condition: string){
+// }
+
 export interface IPackageJson {
 	name: string;
 	version: string;
@@ -48,7 +92,7 @@ export interface IPackageJson {
 	private: boolean;
 	publishConfig: Record<string, any>;
 	workspaces: string[];
-	exports: string | Record<string, string | Record<string, string>>;
+	exports: IExportsField;
 	dependencies: Record<string, string>;
 	devDependencies: Record<string, string>;
 	optionalDependencies: Record<string, string>;

package/src/object/definePublicConstant.ts

@@ -1,6 +1,4 @@
 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,
@@ -8,3 +6,12 @@ export function definePublicConstant(object: any, propertyKey: string | symbol,
 		value,
 	});
 }
+
+export function definePrivateConstant(object: any, propertyKey: string | symbol, value: any) {
+	Object.defineProperty(object, propertyKey, {
+		configurable: false,
+		enumerable: false,
+		writable: false,
+		value,
+	});
+}

package/src/object/objectSame.ts

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

package/src/path/pathArray.ts

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

package/src/platform/globalSingleton.ts

@@ -1,5 +1,5 @@
-import { functionName } from '../function/functionName';
-import { ensureGlobalObject } from './globalObject';
+import { functionName } from '../function/functionName.js';
+import { ensureGlobalObject } from './globalObject.js';
 
 const singletonRegistry = ensureGlobalObject(`@@idlebox/global-singleton`, () => {
 	return new Map<string | symbol, any>();

package/src/platform/globalSymbol.ts

@@ -1,4 +1,4 @@
-import { ensureGlobalObject } from './globalObject';
+import { ensureGlobalObject } from './globalObject.js';
 
 const symbolRegistry = ensureGlobalObject(`@@idlebox/global-symbol`, () => {
 	return {} as Record<string, Record<string, symbol>>;

package/src/promise/promiseCollection.ts

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

package/src/promise/timeoutPromiseCollection.ts

@@ -1,5 +1,5 @@
-import { TimeoutError } from '../lifecycle/timeout/timeoutError';
-import { PromiseCollection } from './promiseCollection';
+import { TimeoutError } from '../lifecycle/timeout/timeoutError.js';
+import { PromiseCollection } from './promiseCollection.js';
 
 export class TimeoutPromiseCollection extends PromiseCollection {
 	constructor(private readonly defaultTimeoutMs = 50000) {

package/src/reflection/classes/singleton.ts

@@ -1,4 +1,4 @@
-import { hookClass } from './hookClass';
+import { hookClass } from './hookClass.js';
 
 export const singletonSymbol = Symbol('@gongt/singleton');
 

package/src/reflection/methods/initOnRead.ts

@@ -1,4 +1,4 @@
-import { InitFunc, initOnRead } from '../../object/initOnRead';
+import { InitFunc, initOnRead } from '../../object/initOnRead.js';
 
 /**
  * Decorater version of `initOnRead`

package/src/state/StateMachine.ts

@@ -1,4 +1,4 @@
-import { Emitter } from '../lifecycle/event/event';
+import { Emitter } from '../lifecycle/event/event.js';
 
 // type StateType = string | number;
 // type EventType = string | number;

package/src/string/concatType.generated.ts

@@ -7,7 +7,6 @@
  * 
  */
 
-
 export function concatStringType
 	<T0 extends string>
 		(t0: T0):
@@ -88,8 +87,6 @@ export function concatStringType
 	<T0 extends string, T1 extends string, T2 extends string, T3 extends string, T4 extends string, T5 extends string, T6 extends string, T7 extends string, T8 extends string, T9 extends string, T10 extends string, T11 extends string, T12 extends string, T13 extends string, T14 extends string, T15 extends string, T16 extends string, T17 extends string, T18 extends string, T19 extends string>
 		(t0: T0, t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16, t17: T17, t18: T18, t19: T19):
 	`${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}${T15}${T16}${T17}${T18}${T19}`;
-
-/* copy */
 export function concatStringType(a: string[]): string {
 	return a.join('');
 }

package/src/string/concatType.generator.ts

@@ -1,13 +1,8 @@
-import { readFileSync } from 'fs';
-
-/* copy */
 export function concatStringType(a: string[]): string {
 	return a.join('');
 }
-/* copy end */
 
-export function generate() {
-	let content = '';
+export function generate(builder: any) {
 	const typeList = [];
 	const argList = [];
 	const returnList = [];
@@ -19,13 +14,8 @@ export function generate() {
 		const type = typeList.join(', ');
 		const arg = argList.join(', ');
 		const ret = returnList.join('');
-		content += `export function concatStringType\n\t<${type}>\n\t\t(${arg}):\n\t\`${ret}\`;\n`;
+		builder.append(`export function concatStringType\n\t<${type}>\n\t\t(${arg}):\n\t\`${ret}\`;`);
 	}
 
-	const full: string = readFileSync(__filename, 'utf-8');
-	const lines = full.split('\n');
-	content += '\n';
-	content += lines.slice(lines.indexOf('/* copy */'), lines.indexOf('/* copy end */')).join('\n');
-
-	return content;
+	builder.copyFunctionDeclare('concatStringType');
 }

package/src/typingHelper/deep.partial.ts

@@ -1,4 +1,4 @@
-import { Primitive } from './literal';
+import { Primitive } from './literal.js';
 
 export type DeepPartial<T> = T extends Primitive
 	? T

package/src/typingHelper/deep.readonly.ts

@@ -1,4 +1,4 @@
-import { Primitive } from './literal';
+import { Primitive } from './literal.js';
 
 export type DeepReadonly<T> = T extends Primitive
 	? T

package/src/typingHelper/deep.required.ts

@@ -1,4 +1,4 @@
-import { Primitive } from './literal';
+import { Primitive } from './literal.js';
 
 export type DeepNonNullable<T> = T extends Primitive
 	? T

package/src/typingHelper/deep.writable.ts

@@ -1,4 +1,4 @@
-import { Primitive } from './literal';
+import { Primitive } from './literal.js';
 
 export type DeepWriteable<T> = T extends Primitive
 	? T