@idlebox/common 1.4.2 → 1.4.3

package/src/path/normalizePath.ts

@@ -10,12 +10,12 @@ const winLetter = /^[a-z]:[\/\\]/i;
 const doubleSlash = /^[\/\\]{2}[^\/\\]/i;
 
 export enum PathKind {
-	url,
-	unc,
-	win,
-	cifs,
-	unix,
-	relative,
+	url = 0,
+	unc = 1,
+	win = 2,
+	cifs = 3,
+	unix = 4,
+	relative = 5,
 }
 export interface IPathInfo {
 	kind: PathKind;
@@ -31,18 +31,18 @@ export function analyzePath(p: string) {
 		const u = new URL(p);
 		r = {
 			kind: PathKind.url,
-			prefix: u.protocol + '//' + u.host,
+			prefix: `${u.protocol}//${u.host}`,
 			path: u.pathname.slice(1),
 			url: u,
 		};
 	} else if (unc.test(p)) {
 		p = p.replace(unc, '').replace(/^[\/\\]+/, '');
 		const i = /[\///]/.exec(p)?.index ?? -1;
-		if (i <= 0) throw new Error('invalid unc path: ' + inp);
+		if (i <= 0) throw new Error(`invalid unc path: ${inp}`);
 
 		r = {
 			kind: PathKind.unc,
-			prefix: '//?/UNC/' + p.slice(0, i),
+			prefix: `//?/UNC/${p.slice(0, i)}`,
 			path: p.slice(i + 1),
 		};
 	} else if (winSp.test(p) || winLetter.test(p)) {
@@ -56,11 +56,11 @@ export function analyzePath(p: string) {
 	} else if (doubleSlash.test(p)) {
 		p = p.replace(/^[\/\\]+/, '');
 		const i = /[\///]/.exec(p)?.index ?? -1;
-		if (i <= 0) throw new Error('invalid cifs url: ' + inp);
+		if (i <= 0) throw new Error(`invalid cifs url: ${inp}`);
 
 		r = {
 			kind: PathKind.cifs,
-			prefix: '//' + p.slice(0, i),
+			prefix: `//${p.slice(0, i)}`,
 			path: p.slice(i + 1),
 		};
 	} else if (p.startsWith('/')) {
@@ -103,9 +103,8 @@ export function normalizePath(p: string) {
 
 	if (r.prefix === undefined) {
 		return r.path;
-	} else {
-		return `${r.prefix}/${r.path}`;
 	}
+	return `${r.prefix}/${r.path}`;
 }
 
 export function relativePath(from: string, to: string) {
@@ -113,9 +112,7 @@ export function relativePath(from: string, to: string) {
 	const r2 = analyzePath(to);
 	if (r1.kind !== r2.kind)
 		throw new Error(
-			`cannot relative path between different kind: "${PathKind[r1.kind]}::${from}" * "${
-				PathKind[r2.kind]
-			}::${to}"`,
+			`cannot relative path between different kind: "${PathKind[r1.kind]}::${from}" * "${PathKind[r2.kind]}::${to}"`
 		);
 
 	if (r1.prefix !== r2.prefix) return to;
@@ -132,7 +129,7 @@ export function relativePath(from: string, to: string) {
 	p2arr.splice(0, i);
 
 	// add ..
-	const p1 = p1arr.length > 0 ? p1arr.map(() => '..').join('/') + '/' : '';
+	const p1 = p1arr.length > 0 ? `${p1arr.map(() => '..').join('/')}/` : '';
 	const p2 = p2arr.join('/');
 
 	return p1 + p2;

package/src/path/pathArray.ts

@@ -10,7 +10,7 @@ const isAbsolute = /^[a-z]:[/\\]/i;
 abstract class PathArrayAbstract extends Set<string> {
 	constructor(
 		init: string,
-		private readonly sep: ':' | ';' = isWindows ? ';' : ':',
+		private readonly sep: ':' | ';' = isWindows ? ';' : ':'
 	) {
 		super();
 		if (init) this.add(init);
@@ -44,7 +44,7 @@ abstract class PathArrayAbstract extends Set<string> {
 	 * @returns an array with `part` append to every element
 	 */
 	join(part: string) {
-		return [...this.values()].map((p) => normalizePath(p + '/' + part));
+		return [...this.values()].map((p) => normalizePath(`${p}/${part}`));
 	}
 }
 

package/src/platform/globalSingleton.ts

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

package/src/platform/globalSymbol.ts

@@ -1,6 +1,6 @@
 import { ensureGlobalObject } from './globalObject.js';
 
-const symbolRegistry = ensureGlobalObject(`@@idlebox/global-symbol`, () => {
+const symbolRegistry = ensureGlobalObject('@@idlebox/global-symbol', () => {
 	return {} as Record<string, Record<string, symbol>>;
 });
 
@@ -12,15 +12,14 @@ const symbolRegistry = ensureGlobalObject(`@@idlebox/global-symbol`, () => {
  */
 export function createSymbol(category: string, name: string): symbol {
 	if (symbolRegistry[category]?.[name]) {
-		return symbolRegistry[category]![name]!;
-	} else {
-		if (!symbolRegistry[category]) {
-			symbolRegistry[category] = {};
-		}
-		const c = symbolRegistry[category]!;
-
-		return (c[name] = Symbol(name));
+		return symbolRegistry[category]?.[name]!;
 	}
+	if (!symbolRegistry[category]) {
+		symbolRegistry[category] = {};
+	}
+	const c = symbolRegistry[category]!;
+
+	return (c[name] = Symbol(name));
 }
 
 /**

package/src/promise/promiseCollection.ts

@@ -10,7 +10,7 @@ export class PromiseCollection {
 
 	create(id: string) {
 		if (this.promiseList[id]) {
-			throw new Error('duplicate promise with id ' + id);
+			throw new Error(`duplicate promise with id ${id}`);
 		}
 		const dfd = new DeferredPromise<any>();
 		this.promiseList[id] = dfd;
@@ -22,12 +22,12 @@ export class PromiseCollection {
 	}
 
 	done(id: string, data: any) {
-		this.promiseList[id]!.complete(data);
+		this.promiseList[id]?.complete(data);
 		delete this.promiseList[id];
 	}
 
 	error(id: string, e: Error) {
-		this.promiseList[id]!.error(e);
+		this.promiseList[id]?.error(e);
 		delete this.promiseList[id];
 	}
 

package/src/reflection/classes/hookClass.ts

@@ -6,7 +6,7 @@ interface IConstructorOf<T> extends Object {
 
 interface IHooks<T, TC> {
 	afterConstruct?: ((obj: T) => void)[];
-	beforeConstruct?: ((obj: TC) => T | void)[];
+	beforeConstruct?: ((obj: TC) => T | undefined)[];
 }
 
 export function hookClass<TC extends IConstructorOf<T>, T>(target: TC): IHooks<T, TC> {

package/src/reflection/classes/singleton.ts

@@ -3,8 +3,8 @@ import { hookClass } from './hookClass.js';
 export const singletonSymbol = Symbol('@gongt/singleton');
 
 export enum SingletonType {
-	Throw,
-	Return,
+	Throw = 0,
+	Return = 1,
 }
 
 export function singleton(type: SingletonType = SingletonType.Return): ClassDecorator {
@@ -21,9 +21,8 @@ export function singleton(type: SingletonType = SingletonType.Return): ClassDeco
 			if (cls[singletonSymbol]) {
 				if (type === SingletonType.Return) {
 					return cls[singletonSymbol];
-				} else {
-					throw new Error(`Duplicate new singleton class [${target.name}]`);
 				}
+				throw new Error(`Duplicate new singleton class [${target.name}]`);
 			}
 		});
 		hook.afterConstruct.push((obj) => {

package/src/reflection/methods/bind.ts

@@ -24,7 +24,6 @@ export const bindThis: MethodDecorator = <T>(
 				return fn;
 			},
 		};
-	} else {
-		throw new TypeError('@bindThis can only use with method, but not property.');
 	}
+	throw new TypeError('@bindThis can only use with method, but not property.');
 };

package/src/reflection/methods/initOnRead.ts

@@ -1,11 +1,11 @@
-import { InitFunc, initOnRead } from '../../object/initOnRead.js';
+import { type InitFunc, initOnRead } from '../../object/initOnRead.js';
 
 /**
  * Decorater version of `initOnRead`
  * @see initOnRead
  */
 export function init<O, T extends keyof O>(init: InitFunc<O, O[T]>): PropertyDecorator {
-	return function (target: O, propertyKey: T) {
+	return ((target: O, propertyKey: T) => {
 		initOnRead<O, T>(target, propertyKey, init);
-	} as any;
+	}) as any;
 }

package/src/string/castCase.ts

@@ -2,7 +2,7 @@
 export function camelCase(str: string) {
 	return str
 		.replace(/[-.\/_]+[a-z]/g, (s) => {
-			return s[1]!.toUpperCase();
+			return s[1]?.toUpperCase();
 		})
 		.replace(/[-.\/_]+/g, '');
 }
@@ -12,7 +12,7 @@ export function camelCase(str: string) {
  * @public
  */
 export function ucfirst<T extends string>(str: T): Capitalize<T> {
-	return <any>(str[0]!.toUpperCase() + str.slice(1));
+	return <any>(str[0]?.toUpperCase() + str.slice(1));
 }
 
 /**
@@ -20,7 +20,7 @@ export function ucfirst<T extends string>(str: T): Capitalize<T> {
  * @public
  */
 export function lcfirst<T extends string>(str: T): Uncapitalize<T> {
-	return <any>(str[0]!.toLowerCase() + str.slice(1));
+	return <any>(str[0]?.toLowerCase() + str.slice(1));
 }
 
 /** @public */
@@ -30,7 +30,7 @@ export function linux_case(str: string) {
 			return s.toLowerCase();
 		})
 		.replace(/[A-Z]+/g, (s) => {
-			return '_' + s.toLowerCase();
+			return `_${s.toLowerCase()}`;
 		})
 		.replace(/[-.\/_]+/g, '_');
 }
@@ -42,7 +42,7 @@ export function linux_case_hyphen(str: string) {
 			return s.toLowerCase();
 		})
 		.replace(/[A-Z]+/g, (s) => {
-			return '-' + s.toLowerCase();
+			return `-${s.toLowerCase()}`;
 		})
 		.replace(/[-.\/_]+/g, '-');
 }

package/src/string/pad2.ts

@@ -4,8 +4,7 @@
  */
 export function pad2(s: number) {
 	if (s < 10) {
-		return '0' + s;
-	} else {
-		return '' + s;
+		return `0${s}`;
 	}
+	return `${s}`;
 }

package/src/string/sizeString.ts

@@ -5,19 +5,23 @@
 export function humanSizeSI(bytes: number, fixed = 2) {
 	if (bytes < 0) {
 		return '<0B';
-	} else if (bytes < 1000) {
-		return bytes + 'B';
-	} else if (bytes < 1000000) {
-		return (bytes / 1000).toFixed(fixed) + 'KiB';
-	} else if (bytes < 1000000000) {
-		return (bytes / 1000000).toFixed(fixed) + 'MiB';
-	} else if (bytes < 1000000000000) {
-		return (bytes / 1000000000).toFixed(fixed) + 'GiB';
-	} else if (bytes < 1000000000000000) {
-		return (bytes / 1000000000000).toFixed(fixed) + 'TiB';
-	} else {
-		return (bytes / 1000000000000000).toFixed(fixed) + 'PiB';
 	}
+	if (bytes < 1000) {
+		return `${bytes}B`;
+	}
+	if (bytes < 1000000) {
+		return `${(bytes / 1000).toFixed(fixed)}KiB`;
+	}
+	if (bytes < 1000000000) {
+		return `${(bytes / 1000000).toFixed(fixed)}MiB`;
+	}
+	if (bytes < 1000000000000) {
+		return `${(bytes / 1000000000).toFixed(fixed)}GiB`;
+	}
+	if (bytes < 1000000000000000) {
+		return `${(bytes / 1000000000000).toFixed(fixed)}TiB`;
+	}
+	return `${(bytes / 1000000000000000).toFixed(fixed)}PiB`;
 }
 
 /**
@@ -27,26 +31,30 @@ export function humanSizeSI(bytes: number, fixed = 2) {
 export function humanSize(bytes: number, fixed = 2) {
 	if (bytes < 0) {
 		return '<0B';
-	} else if (bytes < 1024) {
-		return bytes + 'B';
-	} else if (bytes < 1048576) {
+	}
+	if (bytes < 1024) {
+		return `${bytes}B`;
+	}
+	if (bytes < 1048576) {
 		// 1024 * 1024
-		return (bytes / 1024).toFixed(fixed) + 'KiB';
-	} else if (bytes < 1073741824) {
+		return `${(bytes / 1024).toFixed(fixed)}KiB`;
+	}
+	if (bytes < 1073741824) {
 		// 1024 * 1024 * 1024
-		return (bytes / 1048576).toFixed(fixed) + 'MiB';
-	} else if (bytes < 1099511627776) {
+		return `${(bytes / 1048576).toFixed(fixed)}MiB`;
+	}
+	if (bytes < 1099511627776) {
 		// 1024 * 1024 * 1024 * 1024
-		return (bytes / 1073741824).toFixed(fixed) + 'GiB';
-	} else if (bytes < 1125899906842624) {
+		return `${(bytes / 1073741824).toFixed(fixed)}GiB`;
+	}
+	if (bytes < 1125899906842624) {
 		// 1024 * 1024 * 1024 * 1024 * 1024
-		return (bytes / 1099511627776).toFixed(fixed) + 'TiB';
-	} else {
-		return (bytes / 1125899906842624).toFixed(fixed) + 'PiB';
+		return `${(bytes / 1099511627776).toFixed(fixed)}TiB`;
 	}
+	return `${(bytes / 1125899906842624).toFixed(fixed)}PiB`;
 }
 
 /** @deprecated */
 export function humanSpeed(bps: number) {
-	return humanSize(bps) + '/s';
+	return `${humanSize(bps)}/s`;
 }

package/src/tsconfig.json

@@ -5,5 +5,5 @@
 		"outDir": "../lib/esm",
 		"rootDir": "./",
 	},
-	"exclude": ["**/*.generator.ts"]
+	"exclude": ["**/*.generator.ts"],
 }

package/src/typingHelper/deep.partial.ts

@@ -1,14 +1,14 @@
-import { Primitive } from './literal.js';
+import type { Primitive } from './literal.js';
 
 export type DeepPartial<T> = T extends Primitive
 	? T
 	: T extends ReadonlyArray<infer U>
-	? DeepPartialArray<U>
-	: T extends ReadonlyMap<infer K, infer V>
-	? DeepPartialMap<K, V>
-	: T extends ReadonlySet<infer M>
-	? DeepPartialSet<M>
-	: DeepPartialObject<T>;
+		? DeepPartialArray<U>
+		: T extends ReadonlyMap<infer K, infer V>
+			? DeepPartialMap<K, V>
+			: T extends ReadonlySet<infer M>
+				? DeepPartialSet<M>
+				: DeepPartialObject<T>;
 
 type DeepPartialArray<T> = Array<DeepPartial<T>>;
 type DeepPartialMap<K, V> = Map<DeepPartial<K>, DeepPartial<V>>;

package/src/typingHelper/deep.readonly.ts

@@ -1,14 +1,14 @@
-import { Primitive } from './literal.js';
+import type { Primitive } from './literal.js';
 
 export type DeepReadonly<T> = T extends Primitive
 	? T
 	: T extends Array<infer U>
-	? DeepReadonlyArray<U>
-	: T extends Map<infer K, infer V>
-	? DeepReadonlyMap<K, V>
-	: T extends Set<infer M>
-	? DeepReadonlySet<M>
-	: DeepReadonlyObject<T>;
+		? DeepReadonlyArray<U>
+		: T extends Map<infer K, infer V>
+			? DeepReadonlyMap<K, V>
+			: T extends Set<infer M>
+				? DeepReadonlySet<M>
+				: DeepReadonlyObject<T>;
 
 type DeepReadonlyArray<T> = ReadonlyArray<DeepReadonly<T>>;
 type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;

package/src/typingHelper/deep.required.ts

@@ -1,14 +1,14 @@
-import { Primitive } from './literal.js';
+import type { Primitive } from './literal.js';
 
 export type DeepNonNullable<T> = T extends Primitive
 	? T
 	: T extends ReadonlyArray<infer U> | Array<infer U>
-	? DeepNonNullableArray<U>
-	: T extends ReadonlyMap<infer K, infer V> | Map<infer K, infer V>
-	? DeepNonNullableMap<K, V>
-	: T extends ReadonlySet<infer M>
-	? DeepNonNullableSet<M>
-	: DeepNonNullableObject<T>;
+		? DeepNonNullableArray<U>
+		: T extends ReadonlyMap<infer K, infer V> | Map<infer K, infer V>
+			? DeepNonNullableMap<K, V>
+			: T extends ReadonlySet<infer M>
+				? DeepNonNullableSet<M>
+				: DeepNonNullableObject<T>;
 
 type DeepNonNullableArray<T> = Array<DeepNonNullable<T>>;
 type DeepNonNullableMap<K, V> = Map<DeepNonNullable<K>, DeepNonNullable<V>>;

package/src/typingHelper/deep.writable.ts

@@ -1,14 +1,14 @@
-import { Primitive } from './literal.js';
+import type { Primitive } from './literal.js';
 
 export type DeepWriteable<T> = T extends Primitive
 	? T
 	: T extends ReadonlyArray<infer U>
-	? DeepWriteableArray<U>
-	: T extends ReadonlyMap<infer K, infer V>
-	? DeepWriteableMap<K, V>
-	: T extends ReadonlySet<infer M>
-	? DeepWriteableSet<M>
-	: DeepWriteableObject<T>;
+		? DeepWriteableArray<U>
+		: T extends ReadonlyMap<infer K, infer V>
+			? DeepWriteableMap<K, V>
+			: T extends ReadonlySet<infer M>
+				? DeepWriteableSet<M>
+				: DeepWriteableObject<T>;
 
 type DeepWriteableArray<T> = Array<DeepWriteable<T>>;
 type DeepWriteableMap<K, V> = Map<DeepWriteable<K>, DeepWriteable<V>>;