@wener/utils 1.1.51 → 1.1.54

package/src/libs/ms.ts

@@ -7,47 +7,47 @@ const w = d * 7;
 const y = d * 365.25;
 
 type Unit =
-  | 'Years'
-  | 'Year'
-  | 'Yrs'
-  | 'Yr'
-  | 'Y'
-  | 'Weeks'
-  | 'Week'
-  | 'W'
-  | 'Days'
-  | 'Day'
-  | 'D'
-  | 'Hours'
-  | 'Hour'
-  | 'Hrs'
-  | 'Hr'
-  | 'H'
-  | 'Minutes'
-  | 'Minute'
-  | 'Mins'
-  | 'Min'
-  | 'M'
-  | 'Seconds'
-  | 'Second'
-  | 'Secs'
-  | 'Sec'
-  | 's'
-  | 'Milliseconds'
-  | 'Millisecond'
-  | 'Msecs'
-  | 'Msec'
-  | 'Ms';
+	| 'Years'
+	| 'Year'
+	| 'Yrs'
+	| 'Yr'
+	| 'Y'
+	| 'Weeks'
+	| 'Week'
+	| 'W'
+	| 'Days'
+	| 'Day'
+	| 'D'
+	| 'Hours'
+	| 'Hour'
+	| 'Hrs'
+	| 'Hr'
+	| 'H'
+	| 'Minutes'
+	| 'Minute'
+	| 'Mins'
+	| 'Min'
+	| 'M'
+	| 'Seconds'
+	| 'Second'
+	| 'Secs'
+	| 'Sec'
+	| 's'
+	| 'Milliseconds'
+	| 'Millisecond'
+	| 'Msecs'
+	| 'Msec'
+	| 'Ms';
 
 type UnitAnyCase = Unit | Uppercase<Unit> | Lowercase<Unit>;
 
 export type StringValue = `${number}` | `${number}${UnitAnyCase}` | `${number} ${UnitAnyCase}`;
 
 interface Options {
-  /**
-   * Set to `true` to use verbose formatting. Defaults to `false`.
-   */
-  long?: boolean;
+	/**
+	 * Set to `true` to use verbose formatting. Defaults to `false`.
+	 */
+	long?: boolean;
 }
 
 /**
@@ -60,19 +60,19 @@ interface Options {
 function msFn(value: StringValue, options?: Options): number;
 function msFn(value: number, options?: Options): string;
 function msFn(value: StringValue | number, options?: Options): number | string {
-  try {
-    if (typeof value === 'string' && value.length > 0) {
-      return parse(value);
-    } else if (typeof value === 'number' && isFinite(value)) {
-      return options?.long ? fmtLong(value) : fmtShort(value);
-    }
-    throw new Error('Value is not a string or number.');
-  } catch (error) {
-    const message = isError(error)
-      ? `${error.message}. value=${JSON.stringify(value)}`
-      : 'An unknown error has occurred.';
-    throw new Error(message);
-  }
+	try {
+		if (typeof value === 'string' && value.length > 0) {
+			return parse(value);
+		} else if (typeof value === 'number' && isFinite(value)) {
+			return options?.long ? fmtLong(value) : fmtShort(value);
+		}
+		throw new Error('Value is not a string or number.');
+	} catch (error) {
+		const message = isError(error)
+			? `${error.message}. value=${JSON.stringify(value)}`
+			: 'An unknown error has occurred.';
+		throw new Error(message);
+	}
 }
 
 /**
@@ -83,64 +83,64 @@ function msFn(value: StringValue | number, options?: Options): number | string {
  * parsed
  */
 function parse(str: string): number {
-  if (str.length > 100) {
-    throw new Error('Value exceeds the maximum length of 100 characters.');
-  }
-  const match =
-    /^(?<value>-?(?:\d+)?\.?\d+) *(?<type>milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-      str,
-    );
-  // Named capture groups need to be manually typed today.
-  // https://github.com/microsoft/TypeScript/issues/32098
-  const groups = match?.groups as { value: string; type?: string } | undefined;
-  if (!groups) {
-    return NaN;
-  }
-  const n = parseFloat(groups.value);
-  const type = (groups.type || 'ms').toLowerCase() as Lowercase<Unit>;
-  switch (type) {
-    case 'years':
-    case 'year':
-    case 'yrs':
-    case 'yr':
-    case 'y':
-      return n * y;
-    case 'weeks':
-    case 'week':
-    case 'w':
-      return n * w;
-    case 'days':
-    case 'day':
-    case 'd':
-      return n * d;
-    case 'hours':
-    case 'hour':
-    case 'hrs':
-    case 'hr':
-    case 'h':
-      return n * h;
-    case 'minutes':
-    case 'minute':
-    case 'mins':
-    case 'min':
-    case 'm':
-      return n * m;
-    case 'seconds':
-    case 'second':
-    case 'secs':
-    case 'sec':
-    case 's':
-      return n * s;
-    case 'milliseconds':
-    case 'millisecond':
-    case 'msecs':
-    case 'msec':
-    case 'ms':
-      return n;
-    default:
-      // This should never occur.
-      throw new Error(`The unit ${type as string} was matched, but no matching case exists.`);
-  }
+	if (str.length > 100) {
+		throw new Error('Value exceeds the maximum length of 100 characters.');
+	}
+	const match =
+		/^(?<value>-?(?:\d+)?\.?\d+) *(?<type>milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+			str,
+		);
+	// Named capture groups need to be manually typed today.
+	// https://github.com/microsoft/TypeScript/issues/32098
+	const groups = match?.groups as { value: string; type?: string } | undefined;
+	if (!groups) {
+		return NaN;
+	}
+	const n = parseFloat(groups.value);
+	const type = (groups.type || 'ms').toLowerCase() as Lowercase<Unit>;
+	switch (type) {
+		case 'years':
+		case 'year':
+		case 'yrs':
+		case 'yr':
+		case 'y':
+			return n * y;
+		case 'weeks':
+		case 'week':
+		case 'w':
+			return n * w;
+		case 'days':
+		case 'day':
+		case 'd':
+			return n * d;
+		case 'hours':
+		case 'hour':
+		case 'hrs':
+		case 'hr':
+		case 'h':
+			return n * h;
+		case 'minutes':
+		case 'minute':
+		case 'mins':
+		case 'min':
+		case 'm':
+			return n * m;
+		case 'seconds':
+		case 'second':
+		case 'secs':
+		case 'sec':
+		case 's':
+			return n * s;
+		case 'milliseconds':
+		case 'millisecond':
+		case 'msecs':
+		case 'msec':
+		case 'ms':
+			return n;
+		default:
+			// This should never occur.
+			throw new Error(`The unit ${type as string} was matched, but no matching case exists.`);
+	}
 }
 
 // eslint-disable-next-line import/no-default-export
@@ -150,48 +150,48 @@ export default msFn;
  * Short format for `ms`.
  */
 function fmtShort(ms: number): StringValue {
-  const msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return `${Math.round(ms / d)}d`;
-  }
-  if (msAbs >= h) {
-    return `${Math.round(ms / h)}h`;
-  }
-  if (msAbs >= m) {
-    return `${Math.round(ms / m)}m`;
-  }
-  if (msAbs >= s) {
-    return `${Math.round(ms / s)}s`;
-  }
-  return `${ms}ms`;
+	const msAbs = Math.abs(ms);
+	if (msAbs >= d) {
+		return `${Math.round(ms / d)}d`;
+	}
+	if (msAbs >= h) {
+		return `${Math.round(ms / h)}h`;
+	}
+	if (msAbs >= m) {
+		return `${Math.round(ms / m)}m`;
+	}
+	if (msAbs >= s) {
+		return `${Math.round(ms / s)}s`;
+	}
+	return `${ms}ms`;
 }
 
 /**
  * Long format for `ms`.
  */
 function fmtLong(ms: number): StringValue {
-  const msAbs = Math.abs(ms);
-  if (msAbs >= d) {
-    return plural(ms, msAbs, d, 'day');
-  }
-  if (msAbs >= h) {
-    return plural(ms, msAbs, h, 'hour');
-  }
-  if (msAbs >= m) {
-    return plural(ms, msAbs, m, 'minute');
-  }
-  if (msAbs >= s) {
-    return plural(ms, msAbs, s, 'second');
-  }
-  return `${ms} ms`;
+	const msAbs = Math.abs(ms);
+	if (msAbs >= d) {
+		return plural(ms, msAbs, d, 'day');
+	}
+	if (msAbs >= h) {
+		return plural(ms, msAbs, h, 'hour');
+	}
+	if (msAbs >= m) {
+		return plural(ms, msAbs, m, 'minute');
+	}
+	if (msAbs >= s) {
+		return plural(ms, msAbs, s, 'second');
+	}
+	return `${ms} ms`;
 }
 
 /**
  * Pluralization helper.
  */
 function plural(ms: number, msAbs: number, n: number, name: string): StringValue {
-  const isPlural = msAbs >= n * 1.5;
-  return `${Math.round(ms / n)} ${name}${isPlural ? 's' : ''}` as StringValue;
+	const isPlural = msAbs >= n * 1.5;
+	return `${Math.round(ms / n)} ${name}${isPlural ? 's' : ''}` as StringValue;
 }
 
 /**
@@ -201,5 +201,5 @@ function plural(ms: number, msAbs: number, n: number, name: string): StringValue
  * @returns A boolean `true` if the provided value is an Error-like object
  */
 function isError(value: unknown): value is Error {
-  return typeof value === 'object' && value !== null && 'message' in value;
+	return typeof value === 'object' && value !== null && 'message' in value;
 }

package/src/logger/const.ts

@@ -0,0 +1,18 @@
+import type { Logger } from './types';
+
+export let logger: Logger = console;
+export function setLogger(l: Logger) {
+	logger = l;
+}
+
+export function createNoopLogger(): Logger {
+	const noop = () => {};
+	return {
+		log: noop,
+		info: noop,
+		warn: noop,
+		error: noop,
+		debug: noop,
+		trace: noop,
+	} as any;
+}

package/src/logger/index.ts

@@ -0,0 +1,2 @@
+export { type Logger } from './types';
+export { logger, setLogger, createNoopLogger } from './const';

package/src/logger/types.ts

@@ -0,0 +1,10 @@
+type Writer = (message?: any, ...args: any[]) => void;
+
+export type Logger = {
+	log: Writer;
+	info: Writer;
+	warn: Writer;
+	error: Writer;
+	debug: Writer;
+	trace: Writer;
+};

package/src/maths/clamp.test.ts

@@ -2,22 +2,22 @@ import { expect, test } from 'vitest';
 import { clamp } from './clamp';
 
 test('clamp', () => {
-  for (const [a, b] of [
-    [[null, 0, 0], 0],
-    [[null, 1, 10], 1],
-    [[undefined, 1, 10], 1],
-    [[undefined, 1, 10, 5], 5],
-    [[2, 1, 10, 5], 2],
-    [[11, 1, 10, 5], 10],
-    [[11, { min: 1, max: 10 }], 10],
-    [[null, { min: 1, max: 10 }], 1],
-    [[null, { min: 1, max: 10, default: 5 }], 5],
-    [[2n, 1, 10, 5], 2n],
-    [[1, 2], 2], //  min
-    [[1, undefined, 0], 0], // max
-    [[], undefined],
-    [[null], undefined],
-  ]) {
-    expect(clamp.apply(null, a as any), `${a} -> ${b}`).toBe(b);
-  }
+	for (const [a, b] of [
+		[[null, 0, 0], 0],
+		[[null, 1, 10], 1],
+		[[undefined, 1, 10], 1],
+		[[undefined, 1, 10, 5], 5],
+		[[2, 1, 10, 5], 2],
+		[[11, 1, 10, 5], 10],
+		[[11, { min: 1, max: 10 }], 10],
+		[[null, { min: 1, max: 10 }], 1],
+		[[null, { min: 1, max: 10, default: 5 }], 5],
+		[[2n, 1, 10, 5], 2n],
+		[[1, 2], 2], //  min
+		[[1, undefined, 0], 0], // max
+		[[], undefined],
+		[[null], undefined],
+	]) {
+		expect(clamp.apply(null, a as any), `${a} -> ${b}`).toBe(b);
+	}
 });

package/src/maths/clamp.ts

@@ -1,23 +1,23 @@
 import { isDefined } from '../langs/isDefined';
-import { isNullish } from '../langs/isNullish';
+import { isNil } from '../langs/isNil';
 
 // export function clamp<T>(value: T | null | undefined, opts: { min?: T; max?: T; default?: T }): T;
 export function clamp<T>(value: T | null | undefined, min: T, max: T, def?: T): T;
 export function clamp<T>(value: T | null | undefined, ...o: any[]): T {
-  let min: T, max: T, def: T;
-  if (o.length === 1 && o[0] && typeof o[0] === 'object') {
-    ({ min, max, default: def = min! } = o[0]);
-  } else {
-    [min, max, def = min!] = o;
-  }
-  if (isNullish(value)) {
-    return def;
-  }
-  if (isDefined(min) && value < min) {
-    return min;
-  }
-  if (isDefined(max) && value > max) {
-    return max;
-  }
-  return value;
+	let min: T, max: T, def: T;
+	if (o.length === 1 && o[0] && typeof o[0] === 'object') {
+		({ min, max, default: def = min! } = o[0]);
+	} else {
+		[min, max, def = min!] = o;
+	}
+	if (isNil(value)) {
+		return def;
+	}
+	if (isDefined(min) && value < min) {
+		return min;
+	}
+	if (isDefined(max) && value > max) {
+		return max;
+	}
+	return value;
 }

package/src/maths/createRandom.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from 'vitest';
+import { createRandom } from './random';
+
+test('createRandom', () => {
+	let random = createRandom(0);
+	expect(random.random(100)).toBe(47);
+	for (const a of random) {
+		expect(a).toBe(0.557133817113936);
+		break;
+	}
+	expect(random.randomBytes(4)).toEqual(Uint8Array.from([163, 85, 196, 62]));
+});

package/src/maths/random.ts

@@ -1,16 +1,52 @@
-/// javascript pseudo random
-export function createRandom(o: { seed?: string | number } = {}) {
-  let seed = typeof o.seed === 'string' ? 0 : (o.seed ?? 0);
-  if (typeof o.seed === 'string') {
-    let sum = 0;
-    for (let i = 0; i < o.seed.length; i++) {
-      sum += o.seed.charCodeAt(i);
-    }
-    seed = sum;
-  }
+// LCG pseudo random
+export function createRandom(_seed: number | string = Date.now()): {
+	random(n?: number): number;
+	randomBytes(length: number): Uint8Array;
+	[Symbol.iterator](): Generator<number, void, unknown>;
+} {
+	let seed = 0;
 
-  return () => {
-    const x = Math.sin(seed++) * 10000;
-    return x - Math.floor(x);
-  };
+	if (typeof _seed === 'string') {
+		for (let i = 0; i < _seed.length; i++) {
+			seed = (Math.imul(31, seed) + _seed.charCodeAt(i)) | 0;
+		}
+	} else if (typeof _seed === 'number') {
+		seed = _seed;
+	}
+
+	// int32
+	seed = seed >>> 0;
+
+	// alternative 梅森旋转算法 (Mersenne Twister), Xorshift
+	// LCG
+	const m = 0x80000000; // 2^31
+	const a = 1664525;
+	const c = 1013904223;
+
+	const random = (n?: number): number => {
+		seed = (a * seed + c) % m;
+		let r = seed / m;
+		if (n) {
+			r = Math.floor(r * n);
+		}
+		return r;
+	};
+
+	const randomBytes = (length: number): Uint8Array => {
+		const bytes = new Uint8Array(length);
+		for (let i = 0; i < length; i++) {
+			bytes[i] = Math.floor(random() * 256);
+		}
+		return bytes;
+	};
+
+	return {
+		random,
+		randomBytes,
+		[Symbol.iterator]: function* () {
+			while (true) {
+				yield random();
+			}
+		},
+	};
 }

package/src/modules/isModule.ts

@@ -2,12 +2,12 @@
  * Check is ESM Module
  */
 export function isModule(o: any): o is Module {
-  return o && o[Symbol.toStringTag] === 'Module';
+	return o && o[Symbol.toStringTag] === 'Module';
 }
 
 export interface Module {
-  [Symbol.toStringTag]: 'Module';
-  default?: any;
+	[Symbol.toStringTag]: 'Module';
+	default?: any;
 
-  [k: string | symbol]: any;
+	[k: string | symbol]: any;
 }