@idlebox/common 1.4.13 → 1.4.15

package/src/lifecycle/dispose/lifecycle.ts

@@ -1,3 +1,4 @@
+import type { MaybeNamed } from '../../function/functionName.js';
 import type { EventRegister } from '../event/event.js';
 
 /**
@@ -10,24 +11,18 @@ export interface IDisposableEvents {
 }
 
 /** @public */
-export interface IDisposable {
+export interface IDisposable extends MaybeNamed {
 	dispose(): void;
 
-	readonly name?: string;
-	readonly displayName?: string;
-
 	// [Symbol.dispose]?(): void;
 	/** @internal do not use/rely */
 	// [Symbol.asyncDispose]?(): Promise<void>;
 }
 
 /** @public */
-export interface IAsyncDisposable {
+export interface IAsyncDisposable extends MaybeNamed {
 	dispose(): void | Promise<void>;
 
-	name?: string;
-	displayName?: string;
-
 	// [Symbol.dispose]?(): void | Promise<void>;
 	// [Symbol.asyncDispose]?(): void | Promise<void>;
 }
@@ -70,3 +65,30 @@ export function toDisposable(fn_or_obj: Disposable | AsyncDisposable | (() => vo
 		});
 	}
 }
+
+type ClosableAsync = { close(): Promise<any> } & MaybeNamed;
+type ClosableSync = { close(cb: (e?: Error) => void): void } & MaybeNamed;
+export function closableToDisposable(closable: ClosableAsync | ClosableSync): IDisposable {
+	const promised = closable.close.length === 0;
+
+	return {
+		get displayName() {
+			return `closableToDisposable[AsyncDisposable](${closable.displayName || closable.name || closable.constructor.name || 'unknown'})`;
+		},
+		dispose() {
+			if (promised) {
+				return (closable as ClosableAsync).close();
+			} else {
+				return new Promise<void>((resolve, reject) => {
+					return (closable as ClosableSync).close((error) => {
+						if (error) {
+							reject(error);
+						} else {
+							resolve();
+						}
+					});
+				});
+			}
+		},
+	};
+}

package/src/lifecycle/event/event.ts

@@ -1,4 +1,4 @@
-import { AppExit } from '../../autoindex.js';
+import { AppExit } from '../../error-wellknown/exit.error.js';
 import type { IDisposable } from '../dispose/lifecycle.js';
 
 export type EventHandler<T> = (data: T) => void;

package/src/lifecycle/timeout/interval.ts

@@ -2,13 +2,15 @@ import type { IDisposable } from '../dispose/lifecycle.js';
 import { Disposable } from '../dispose/lifecycle.sync.js';
 import { Emitter } from '../event/event.js';
 
+type TimerT = ReturnType<typeof setInterval>;
+
 /**
  * @param unref defaults to `false`, when true, call `unref()` on the timer.
  *            can not set to `true` on other platform.
  * @returns dispose will stop the interval
  */
 export function interval(ms: number, action: () => void, unref = false) {
-	let timer: number | undefined = setInterval(action, ms);
+	let timer: TimerT | undefined = setInterval(action, ms);
 	// unref is not supported in browser
 	if (unref) (timer as any).unref();
 
@@ -23,7 +25,7 @@ export function interval(ms: number, action: () => void, unref = false) {
 
 /**
  * A simple interval class.
- * 
+ *
  * mainly use for pause/resume several times.
  */
 export class Interval extends Disposable {

package/src/misc/package.json.ts

@@ -31,6 +31,7 @@ export interface IFullExportsField {
 }
 
 export type IExportsField = string | IExportCondition | IExportMap;
+export type IImportsField = IExportCondition | IExportMap;
 
 function isPathMap(exportsField: IExportCondition | IExportMap): exportsField is IExportMap {
 	return Object.keys(exportsField).some((e) => e.startsWith('.'));
@@ -110,6 +111,7 @@ export interface IPackageJson {
 	publishConfig: Record<string, any>;
 	workspaces: string[];
 	exports: IExportsField;
+	imports: IImportsField;
 	dependencies: Record<string, string>;
 	devDependencies: Record<string, string>;
 	optionalDependencies: Record<string, string>;
@@ -125,6 +127,17 @@ export interface IPackageJson {
 
 	dist: IPackageJsonNpmDist;
 
+	/* My Addons */
+	/**
+	 * Array of dependencies that will remove from dependencies and devDependencies when resolving build order.
+	 */
+	decoupledDependencies: string | string[];
+	/**
+	 * Array of package names that add this package to it's `decoupledDependencies`.
+	 */
+	decoupledDependents: string | string[];
+	/* My Addons End */
+
 	[field: string]: any;
 }
 

package/src/object/objectPath.test.ts

@@ -0,0 +1,46 @@
+import { createRootLogger, EnableLogLevel, logger } from '@idlebox/logger';
+import { ObjectPath } from './objectPath.js';
+
+createRootLogger('object-checker');
+logger.enable(EnableLogLevel.debug);
+
+const objects = [
+	{
+		value: {
+			a: 1,
+			b: {
+				x: 1,
+			},
+			c: {
+				x: 1,
+				y: 2,
+			},
+		},
+	},
+	{
+		a: {
+			b: {
+				c: {
+					d: 1,
+				},
+			},
+		},
+	},
+];
+
+const check1 = new ObjectPath(objects[1]);
+if (check1.get(['a', 'b', 'c', 'd']) !== 1) {
+	logger.fatal`get fail`;
+} else {
+	logger.success`get ok`;
+}
+
+logger.log`${check1.get(['a', 'b', 'c'])}`;
+
+const check2 = new ObjectPath(objects[0]);
+
+check2.set(['value', 'a'], 2);
+check2.set(['value', 'b', 'x'], undefined);
+check2.set(['value', 'c', 'x'], undefined);
+
+logger.log`${objects[0]}`;

package/src/object/objectPath.ts

@@ -8,3 +8,112 @@ export function objectPath(obj: object, path: string): any {
 	});
 	return obj;
 }
+
+type KeyType = string | number | symbol;
+/**
+ * Mutate an object by path
+ *
+ * @param object the object to mutate, by reference
+ */
+export class ObjectPath {
+	constructor(public readonly object: any) {}
+
+	/**
+	 * Get a value from the object by path
+	 * @param path the path to get, must not be empty
+	 * @returns undefined if any part not found
+	 */
+	public get(path: readonly KeyType[]) {
+		if (path.length === 0) throw new Error('path must not be empty');
+		const rest = path.slice();
+		const last = rest.pop()!;
+
+		let cursor = this.object;
+		for (const p of rest) {
+			if (typeof cursor[p] !== 'object') {
+				return undefined;
+			}
+			cursor = cursor[p];
+		}
+
+		return cursor[last];
+	}
+
+	public exists(path: readonly KeyType[]) {
+		if (path.length === 0) throw new Error('path must not be empty');
+		const rest = path.slice();
+		const last = rest.pop()!;
+
+		let cursor = this.object;
+		for (const p of rest) {
+			if (typeof cursor[p] !== 'object') {
+				return false;
+			}
+			cursor = cursor[p];
+		}
+
+		return Object.hasOwn(cursor, last);
+	}
+
+	/**
+	 * Set value on a path
+	 * @param path the path to set, must not be empty
+	 * @param value
+	 */
+	public set(path: readonly KeyType[], value: any) {
+		if (path.length === 0) throw new Error('path must not be empty');
+		function walkSet(cursor: any) {
+			const rest = path.slice();
+			const last = rest.pop()!;
+
+			for (const [index, name] of rest.entries()) {
+				if (!cursor[name]) {
+					const next = path[index + 1];
+					if (typeof next === 'number') {
+						cursor[name] = [];
+					} else {
+						cursor[name] = {};
+					}
+				}
+				cursor = cursor[name];
+			}
+			cursor[last] = value;
+		}
+		function walkDelete(cursor: any) {
+			const rest = path.slice();
+			const last = rest.pop()!;
+			const objects = [];
+			for (const name of rest) {
+				objects.unshift({ object: cursor, child: name });
+				cursor = cursor[name];
+				if (typeof cursor !== 'object') break;
+			}
+
+			if (cursor) {
+				if (Array.isArray(cursor) && typeof last === 'number') {
+					if (last < cursor.length) {
+						cursor.splice(last, 1);
+					}
+				} else {
+					delete cursor[last];
+				}
+			}
+
+			for (const { object, child } of objects) {
+				if (typeof object[child] !== 'object' || isEmptyObject(object[child])) {
+					delete object[child];
+				}
+			}
+		}
+
+		if (value === undefined) {
+			walkDelete(this.object);
+		} else {
+			walkSet(this.object);
+		}
+	}
+}
+
+function isEmptyObject(obj: any): boolean {
+	return Object.keys(obj).length === 0;
+}

package/src/path/pathArray.ts

@@ -14,12 +14,14 @@ abstract class PathArrayAbstract {
 		init: string | string[] = [],
 		private readonly sep: ':' | ';' = isWindows ? ';' : ':',
 	) {
-		if (Array.isArray(init)) {
-			for (const item of init) {
-				this.add(item);
+		if (init.length) {
+			if (Array.isArray(init)) {
+				for (const item of init) {
+					this.add(item);
+				}
+			} else {
+				this.add(init);
 			}
-		} else {
-			this.add(init);
 		}
 	}
 

package/src/platform/globalObject.ts

@@ -16,7 +16,3 @@ export function ensureGlobalObject<T>(symbol: string, constructor: () => T): T {
 	}
 	return globalObject[sm];
 }
-
-export function x() {
-	return 1;
-}

package/src/string/concatType.generated.ts

@@ -7,7 +7,7 @@
  *  GENERATED FILE, DO NOT MODIFY
  *  这是生成的文件，千万不要修改
  * 
- * @build-script/codegen 0.0.1 - The Simple Code Generater
+ * @build-script/codegen 1.0.2 - The Simple Code Generater
  * https://github.com/GongT/baobao
  * 
  ******************************************************************************/

package/src/tsconfig.json

@@ -3,7 +3,7 @@
 	"compilerOptions": {
 		"typeRoots": ["../node_modules/@types", "../node_modules"],
 		"outDir": "../lib",
-		"rootDir": "./",
+		"rootDir": "./"
 	},
-	"exclude": ["**/*.generator.ts"],
+	"exclude": ["**/*.generator.ts", "**/*.test.ts"]
 }

package/src/global.d.ts

@@ -1 +0,0 @@
-/// <reference types="@idlebox/itypes" />