@idlebox/common 1.4.11 → 1.4.13

package/src/path/pathArray.ts

@@ -5,49 +5,118 @@ import { normalizePath } from './normalizePath.js';
 const isAbsolute = /^[a-z]:[/\\]/i;
 
 /**
- * Work on "PATH"-like values, but always use / insteadof \
+ * Work on "PATH"-like values, but always use / instead-of \
  */
-abstract class PathArrayAbstract extends Set<string> {
+abstract class PathArrayAbstract {
+	private readonly array: string[] = [];
+
 	constructor(
-		init: string,
-		private readonly sep: ':' | ';' = isWindows ? ';' : ':'
+		init: string | string[] = [],
+		private readonly sep: ':' | ';' = isWindows ? ';' : ':',
 	) {
-		super();
-		if (init) this.add(init);
+		if (Array.isArray(init)) {
+			for (const item of init) {
+				this.add(item);
+			}
+		} else {
+			this.add(init);
+		}
 	}
 
-	abstract normalize(path: string): string;
+	clone(): PathArrayAbstract {
+		const Cls = this.constructor as any;
+		return new Cls(this.array);
+	}
+
+	get size() {
+		return this.array.length;
+	}
+
+	/**
+	 * 添加value到数组
+	 * @param value 路径，允许传入是字符串表达的数组（/a:/b:/c）
+	 * @param first 是否将路径添加到数组的开头
+	 * @param force 是否强制添加路径，即使它已经存在
+	 */
+	add(value: string, first: boolean = false, force: boolean = false) {
+		for (const part of this.split(value)) {
+			if (force) {
+				this._delete(part);
+			}
+			this._add(part, first);
+		}
+	}
+
+	protected _add(normalizedPath: string, prepend: boolean = false) {
+		if (this.has(normalizedPath)) return false;
+		if (prepend) {
+			this.array.unshift(normalizedPath);
+		} else {
+			this.array.push(normalizedPath);
+		}
+		return true;
+	}
 
-	split(pathArrStr: string) {
-		return pathArrStr.split(this.sep);
+	delete(value: string) {
+		let anyRet = false;
+		for (const part of this.split(value)) {
+			anyRet = anyRet || this._delete(part);
+		}
+		return anyRet;
+	}
+
+	protected _delete(normalizedPath: string) {
+		const index = this.array.indexOf(normalizedPath);
+		if (index !== -1) {
+			this.array.splice(index, 1);
+			return true;
+		}
+		return false;
 	}
 
-	override toString(): string {
-		return [...this.values()].join(this.sep);
+	split(value: string): string[] {
+		return value.split(this.sep).map((p) => this.normalize(p));
 	}
 
-	// /** @deprecated @use values() */
-	// override keys() {
-	// 	return super.keys();
-	// }
+	has(value: string) {
+		return this.array.includes(this.normalize(value));
+	}
+
+	/**
+	 * Normalize the given path. it maybe relative or absolute.
+	 */
+	abstract normalize(path: string): string;
+
+	toString(): string {
+		return this.array.join(this.sep);
+	}
+	toArray(): string[] {
+		return this.array.slice();
+	}
 
-	// /** @deprecated @use values() */
-	// override entries() {
-	// 	return super.entries();
-	// }
+	[Symbol.iterator]() {
+		return this.array.values();
+	}
 
-	// override [Symbol.iterator]() {
-	// 	return this.values();
-	// }
+	values() {
+		return this.array.values();
+	}
 
 	/**
 	 * @returns an array with `part` append to every element
 	 */
-	join(part: string) {
-		return [...this.values()].map((p) => normalizePath(`${p}/${part}`));
+	joinpath(part: string) {
+		return this.array.map((p) => `${p}/${part}`);
+	}
+
+	clear() {
+		this.array.length = 0;
 	}
 }
 
+/**
+ * handle PATH like values, but always use / instead of \
+ */
 export class PathArrayWindows extends PathArrayAbstract {
 	private readonly caseMap = new Map<string, string>();
 
@@ -64,58 +133,27 @@ export class PathArrayWindows extends PathArrayAbstract {
 		this.caseMap.clear();
 	}
 
-	override add(paths: string) {
-		for (const p of this.split(paths)) {
-			const rpath = this.normalize(p);
-			const lcase = rpath.toLowerCase();
-			this.caseMap.set(lcase, rpath);
-			super.add(lcase);
-		}
-		return this;
+	override _add(normalizedPath: string) {
+		const lcase = normalizedPath.toLowerCase();
+		this.caseMap.set(lcase, normalizedPath);
+		return super._add(lcase);
 	}
 
-	override delete(paths: string) {
-		let anyRet = false;
-		for (const p of this.split(paths)) {
-			const rpath = this.normalize(p);
-			const lcase = rpath.toLowerCase();
-			this.caseMap.delete(lcase);
-			anyRet = anyRet || super.delete(lcase);
-		}
-		return anyRet;
+	override _delete(normalizedPath: string) {
+		const lcase = normalizedPath.toLowerCase();
+		this.caseMap.delete(lcase);
+		return super._delete(lcase);
 	}
 
 	override has(path: string): boolean {
-		return super.has(this.normalize(path).toLowerCase());
-	}
-
-	override values() {
-		return this.caseMap.values();
+		return this.caseMap.has(this.normalize(path).toLowerCase());
 	}
 }
+
 export class PathArrayPosix extends PathArrayAbstract {
 	override normalize(path: string) {
 		return normalizePath(path);
 	}
-
-	override add(paths: string) {
-		for (const p of this.split(paths)) {
-			super.add(this.normalize(p));
-		}
-		return this;
-	}
-
-	override delete(paths: string) {
-		let anyRet = false;
-		for (const p of this.split(paths)) {
-			anyRet = anyRet || super.delete(this.normalize(p));
-		}
-		return anyRet;
-	}
-
-	override has(path: string): boolean {
-		return super.has(this.normalize(path));
-	}
 }
 
 const TypePathArrayAbstract = isWindows ? PathArrayWindows : PathArrayPosix;

package/src/platform/globalSingleton.ts

@@ -1,3 +1,5 @@
+/** biome-ignore-all lint/suspicious/noShadowRestrictedNames:  */
+
 import { functionName } from '../function/functionName.js';
 import { ensureGlobalObject } from './globalObject.js';
 
@@ -28,8 +30,7 @@ export function globalSingletonStrong<T>(symbol: symbol | string, constructor?:
 			if (object === undefined)
 				throw new TypeError(`singleton constructor (${functionName(constructor)}) returned undefined.`);
 		} else {
-			singletonRegistry.delete(symbol);
-			return undefined;
+			throw new TypeError(`singleton (${String(symbol)}) is not defined and no constructor provided.`);
 		}
 		singletonRegistry.set(symbol, object);
 	} else if (object === undefined && constructor) {

package/src/platform/os.ts

@@ -3,7 +3,10 @@ declare const navigator: any;
 declare const window: any;
 declare const global: any;
 
-export const hasProcess = typeof process !== 'undefined' && typeof process.pid === 'number';
+/**
+ * buy detect process.pid, is there any bundler mock this?
+ */
+export const hasProcess = typeof process?.pid === 'number';
 export const hasWindow = typeof window !== 'undefined' && globalThis === window;
 export const hasGlobal = typeof global !== 'undefined' && globalThis === global;
 
@@ -32,6 +35,7 @@ export let isWindows = false;
 export let isMacintosh = false;
 export let isLinux = false;
 export let isNative = false;
+export let isNodeJs = false;
 export let isWeb = false;
 export let is64Bit = false;
 
@@ -44,6 +48,7 @@ if (hasWindow && !hasProcess) {
 	is64Bit = userAgent.includes('x64');
 } else if (hasProcess) {
 	isNative = true;
+	isNodeJs = typeof process.versions?.node === 'string';
 	is64Bit = process.arch === 'x64';
 	if (process.platform === 'linux') {
 		isLinux = true;

package/src/string/concatType.generated.ts

@@ -1,11 +1,16 @@
 /* eslint-disable */
 // @ts-ignore
-/*
- * 
+// biome-ignore-all lint
+// biome-ignore-all assist
+// biome-ignore-all syntax
+/******************************************************************************
  *  GENERATED FILE, DO NOT MODIFY
  *  这是生成的文件，千万不要修改
  * 
- */
+ * @build-script/codegen 0.0.1 - The Simple Code Generater
+ * https://github.com/GongT/baobao
+ * 
+ ******************************************************************************/
 
 export function concatStringType
 	<T0 extends string>
@@ -89,4 +94,4 @@ export function concatStringType
 	`${T0}${T1}${T2}${T3}${T4}${T5}${T6}${T7}${T8}${T9}${T10}${T11}${T12}${T13}${T14}${T15}${T16}${T17}${T18}${T19}`;
 export function concatStringType(a: string[]): string {
 	return a.join('');
-}
+}

package/src/string/concatType.generator.ts

@@ -1,8 +1,18 @@
+import type { FileBuilder, GenerateContext } from '@build-script/codegen';
+
 export function concatStringType(a: string[]): string {
 	return a.join('');
 }
 
-export function generate(builder: any) {
+export function generate(context: GenerateContext) {
+	let builder: FileBuilder;
+	if (context.file) {
+		builder = context.file('./concatType');
+	} else {
+		// TODO
+		builder = context as any;
+	}
+
 	const typeList = [];
 	const argList = [];
 	const returnList = [];

package/src/tsconfig.json

@@ -1,8 +1,8 @@
 {
-	"extends": "@internal/local-rig/profiles/dualstack/tsconfig.json",
+	"extends": "@internal/local-rig/profiles/default/tsconfig.json",
 	"compilerOptions": {
 		"typeRoots": ["../node_modules/@types", "../node_modules"],
-		"outDir": "../lib/esm",
+		"outDir": "../lib",
 		"rootDir": "./",
 	},
 	"exclude": ["**/*.generator.ts"],