@wener/utils 1.1.7 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {
@@ -14,7 +14,7 @@
     "node": "16",
     "npm": "8"
   },
-  "main": "dist/cjs/index.js",
+  "main": "dist/cjs/index.cjs",
   "module": "lib/index.js",
   "exports": {
     ".": {
@@ -24,7 +24,7 @@
       "system": {
         "default": "./dist/system/index.js"
       },
-      "require": "./dist/cjs/index.js"
+      "require": "./dist/cjs/index.cjs"
     },
     "./types": {
       "types": "./types.d.ts"
@@ -36,7 +36,7 @@
       "system": {
         "default": "./dist/system/server.js"
       },
-      "require": "./dist/cjs/server.js"
+      "require": "./dist/cjs/server.cjs"
     },
     "./src/*": "./src/*",
     "./package.json": "./package.json"
@@ -62,7 +62,7 @@
   ],
   "devDependencies": {
     "@types/lodash": "^4.14.186",
-    "ava": "^4.3.3",
+    "ava": "^5.0.1",
     "lodash": "^4",
     "tsd": "^0.24.1"
   },

package/src/asyncs/createLazyPromise.test.ts

@@ -17,7 +17,7 @@ test('basic', async (t) => {
 });
 
 test('manual resolve skip exec', async (t) => {
-  const promise = createLazyPromise(() => {
+  const promise = createLazyPromise<number>(() => {
     t.fail();
   });
   promise.resolve(-1);
@@ -37,3 +37,18 @@ test('exec', async (t) => {
   promise.resolve(20);
   t.is(await promise, 10);
 });
+
+test('exec auto', async (t) => {
+  let r = 0;
+  const promise = createLazyPromise(() => {
+    r++;
+    return 10;
+  });
+  await sleep(10);
+  t.is(r, 0);
+  void promise.then(() => undefined);
+  t.is(await promise, 10);
+  t.is(r, 1);
+  t.is(await promise, 10);
+  t.is(r, 1);
+});

package/src/asyncs/createLazyPromise.ts

@@ -1,3 +1,5 @@
+import type { MaybePromise } from './MaybePromise';
+
 export type LazyPromise<T> = Promise<T> & {
   reject(reason?: any): void;
   resolve(v?: T | PromiseLike<T>): void;
@@ -8,7 +10,9 @@ export type LazyPromise<T> = Promise<T> & {
  * if you pass a function to it, it will be executed when the promise try to resolve.
  */
 export function createLazyPromise<T = any>(
-  executor?: (resolve: LazyPromise<T>['resolve'], reject: LazyPromise<T>['reject']) => void,
+  executor?:
+    | ((resolve: LazyPromise<T>['resolve'], reject: LazyPromise<T>['reject']) => void)
+    | ((resolve: LazyPromise<T>['resolve'], reject: LazyPromise<T>['reject']) => MaybePromise<T>),
 ): LazyPromise<T> {
   const holder = {
     resolve(_: any): void {
@@ -43,7 +47,18 @@ export function createLazyPromise<T = any>(
     future.then = (...args) => {
       if (shouldExec) {
         shouldExec = false;
-        executor(holder.resolve, holder.reject);
+        try {
+          // kind of bad
+          const result = executor(holder.resolve, holder.reject);
+          // ensure resolve/reject is called
+          if (result && 'then' in result) {
+            result.then(holder.resolve, holder.reject);
+          } else if (result !== undefined) {
+            holder.resolve(result);
+          }
+        } catch (e) {
+          holder.reject(e);
+        }
       }
       return then(...args);
     };

package/src/browsers/copy.ts

@@ -1,4 +1,4 @@
-import { MaybePromise } from '../asyncs/MaybePromise';
+import type { MaybePromise } from '../asyncs/MaybePromise';
 
 let _copy: (s: any) => void;
 

package/src/crypto/getRandomValues.ts

@@ -0,0 +1,40 @@
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+let nodeCrypto: Awaited<typeof import('node:crypto')>;
+// globalThis.process?.release?.name
+
+// typedoc error
+if (!(process as any).browser) {
+  try {
+    if (typeof require === 'undefined') {
+      void import('node:crypto').then((v) => (nodeCrypto = v.default));
+    } else {
+      nodeCrypto = require('node:crypto');
+    }
+  } catch (e) {}
+}
+
+export let getRandomValues: <T extends Exclude<NodeJS.TypedArray, Float32Array | Float64Array>>(typedArray: T) => T =
+  globalThis.crypto?.getRandomValues || (globalThis as any).msCrypto?.getRandomValues || _getRandomValues;
+
+function _getRandomValues<T extends Exclude<NodeJS.TypedArray, Float32Array | Float64Array>>(buf: T) {
+  if (nodeCrypto?.webcrypto?.getRandomValues) {
+    getRandomValues = nodeCrypto?.webcrypto?.getRandomValues;
+    return nodeCrypto.webcrypto.getRandomValues(buf);
+  }
+  if (nodeCrypto?.randomBytes) {
+    if (!(buf instanceof Uint8Array)) {
+      throw new TypeError('expected Uint8Array');
+    }
+    if (buf.length > 65536) {
+      const e: any = new Error();
+      e.code = 22;
+      e.message = `Failed to execute 'getRandomValues' on 'Crypto': The ArrayBufferView's byte length (${buf.length}) exceeds the number of bytes of entropy available via this API (65536).`;
+      e.name = 'QuotaExceededError';
+      throw e;
+    }
+    const bytes = nodeCrypto.randomBytes(buf.length);
+    buf.set(bytes);
+    return buf;
+  }
+  throw new Error('No secure random number generator available.');
+}

package/src/crypto/ulid.test.ts

@@ -0,0 +1,22 @@
+import test from 'ava';
+import { createULID, parseULID } from './ulid';
+
+test('ulid', (t) => {
+  // monotonic
+  {
+    let lastTime = 0;
+    const ulid = createULID({
+      now: () => {
+        lastTime ||= Date.now();
+        return lastTime;
+      },
+    });
+
+    const ulid1 = ulid();
+    t.is(parseULID(ulid1).time, lastTime);
+
+    const ulid2 = ulid();
+    t.true(ulid1 < ulid2);
+    t.is(parseULID(ulid2).time, lastTime);
+  }
+});

package/src/crypto/ulid.ts

@@ -0,0 +1,182 @@
+import { getRandomValues } from './getRandomValues';
+
+type PRNG = () => number;
+
+/**
+ * Universally Unique Lexicographically Sortable Identifier
+ *
+ * @see https://github.com/ulid/spec ulid/spec
+ */
+export type ULID = (seedTime?: number) => string;
+
+export interface ULIDError extends Error {
+  source: string;
+}
+
+function createError(message: string): ULIDError {
+  const err = new Error(message) as ULIDError;
+  err.source = 'ulid';
+  return err;
+}
+
+// These values should NEVER change. If
+// they do, we're no longer making ulids!
+const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'; // Crockford's Base32
+const ENCODING_LEN = ENCODING.length;
+const TIME_MAX = Math.pow(2, 48) - 1;
+const TIME_LEN = 10;
+const RANDOM_LEN = 16;
+
+/**
+ * check give {@link str} is a valid ulid
+ */
+export function isULID(str: string): boolean {
+  return str?.length === 26 && /^[0-9A-HJKMNP-TV-Z]{26}$/.test(str);
+}
+
+function replaceCharAt(str: string, index: number, char: string) {
+  if (index > str.length - 1) {
+    return str;
+  }
+  return str.substr(0, index) + char + str.substr(index + 1);
+}
+
+function incrementBase32(str: string): string {
+  let done;
+  let index = str.length;
+  let char;
+  let charIndex;
+  const maxCharIndex = ENCODING_LEN - 1;
+  while (!done && index-- >= 0) {
+    char = str[index];
+    charIndex = ENCODING.indexOf(char);
+    if (charIndex === -1) {
+      throw createError('incorrectly encoded string');
+    }
+    if (charIndex === maxCharIndex) {
+      str = replaceCharAt(str, index, ENCODING[0]);
+      continue;
+    }
+    done = replaceCharAt(str, index, ENCODING[charIndex + 1]);
+  }
+  if (typeof done === 'string') {
+    return done;
+  }
+  throw createError('cannot increment this string');
+}
+
+function randomChar(prng: PRNG): string {
+  let rand = Math.floor(prng() * ENCODING_LEN);
+  if (rand === ENCODING_LEN) {
+    rand = ENCODING_LEN - 1;
+  }
+  return ENCODING.charAt(rand);
+}
+
+function encodeTime(now: number, len: number): string {
+  if (isNaN(now)) {
+    throw new Error(`${now} must be a number`);
+  }
+  if (now > TIME_MAX) {
+    throw createError(`cannot encode time greater than ${TIME_MAX}`);
+  }
+  if (now < 0) {
+    throw createError('time must be positive');
+  }
+  if (!Number.isInteger(now)) {
+    throw createError('time must be an integer');
+  }
+  let mod;
+  let str = '';
+  for (; len > 0; len--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING.charAt(mod) + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+
+function encodeRandom(len: number, prng: PRNG): string {
+  let str = '';
+  for (; len > 0; len--) {
+    str = randomChar(prng) + str;
+  }
+  return str;
+}
+
+/**
+ * extract time & random from ulid
+ *
+ * @throws ULIDError
+ */
+export function parseULID(id: string): { time: number; random: string } {
+  if (id.length !== TIME_LEN + RANDOM_LEN) {
+    throw createError('malformed ulid');
+  }
+  const time = id
+    .substr(0, TIME_LEN)
+    .split('')
+    .reverse()
+    .reduce((carry, char, index) => {
+      const encodingIndex = ENCODING.indexOf(char);
+      if (encodingIndex === -1) {
+        throw createError('invalid character found: ' + char);
+      }
+      return (carry += encodingIndex * Math.pow(ENCODING_LEN, index));
+    }, 0);
+  if (time > TIME_MAX) {
+    throw createError('malformed ulid, timestamp too large');
+  }
+  return { time, random: id.substring(TIME_LEN) };
+}
+
+function createPrng(): PRNG {
+  return () => {
+    const buffer = new Uint8Array(1);
+    getRandomValues(buffer);
+    return buffer[0] / 0xff;
+  };
+}
+
+/**
+ * create a ulid generator
+ */
+export function createULID({
+  monotonic = true,
+  random = createPrng(),
+  now = Date.now,
+}: { monotonic?: boolean; now?: () => number; random?: () => number } = {}) {
+  if (!monotonic) {
+    return function ulid(seedTime?: number): string {
+      seedTime ||= now();
+      return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, random);
+    };
+  }
+
+  let lastTime: number = 0;
+  let lastRandom: string;
+  return function ulid(seedTime?: number): string {
+    seedTime ||= now();
+    if (seedTime <= lastTime) {
+      const incrementedRandom = (lastRandom = incrementBase32(lastRandom));
+      return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
+    }
+    lastTime = seedTime;
+    const newRandom = (lastRandom = encodeRandom(RANDOM_LEN, random));
+    return encodeTime(seedTime, TIME_LEN) + newRandom;
+  };
+}
+
+/**
+ * default monotonic ulid generator
+ */
+export let ulid: ULID = (...args) => {
+  if (_real) {
+    return _real(...args);
+  }
+  // delay initialize crypto
+  _real = createULID();
+  ulid = _real;
+  return _real(...args);
+};
+let _real: ULID;

package/src/i18n/createTranslate.test.ts

@@ -153,3 +153,18 @@ test('invalid value', (t) => {
 
   t.deepEqual(ctx.t('foo', null as any, 'en'), ['bar']);
 });
+
+test('fallback', (t) => {
+  const ctx = createTranslate({
+    en: {
+      a: 'a',
+    },
+    'en-US': {
+      a: 'a-US',
+    },
+  });
+
+  // t.deepEqual(ctx.t('a', undefined, 'en'), 'a');
+  // t.deepEqual(ctx.t('a', undefined, 'en-US'), 'a-US');
+  t.deepEqual(ctx.t('a', undefined, 'en-UK'), 'a');
+});

package/src/i18n/createTranslate.ts

@@ -1,5 +1,5 @@
 import { get } from '../objects/get';
-import { ObjectPathLike } from '../objects/parseObjectPath';
+import type { ObjectPathLike } from '../objects/parseObjectPath';
 import { renderTemplate } from '../strings/renderTemplate';
 
 export interface Translate<T extends object> {
@@ -19,7 +19,17 @@ export interface Translate<T extends object> {
 export function createTranslate<T extends object>(obj?: Record<string, T>): Translate<T> {
   let locale = '';
   const tree = obj || {};
-
+  // en-US -> en-US,en
+  const keyOfDict = (s: string | string[]) => {
+    if (Array.isArray(s)) {
+      return s;
+    }
+    const sp = s.split(/[_-]/);
+    if (sp.length > 1) {
+      return [s, sp[0]];
+    }
+    return [s];
+  };
   return {
     locale(lang) {
       return (locale = lang || locale);
@@ -34,7 +44,13 @@ export function createTranslate<T extends object>(obj?: Record<string, T>): Tran
     }) as Translate<T>['dict'],
 
     t(key, params, lang) {
-      const val = get(tree[lang || locale], key, '') as any;
+      let val: any;
+      for (const k of keyOfDict(lang || locale)) {
+        val = get(tree[k], key, '');
+        if (val) {
+          break;
+        }
+      }
       if (process.env.NODE_ENV === 'development') {
         if (val == null) {
           return console.error(

package/src/index.ts

@@ -22,15 +22,18 @@ export { timeout, TimeoutError } from './asyncs/timeout';
 export { isPromise } from './asyncs/isPromise';
 // export * from './async/promiseOfCallback';
 
-// validations
+// langs
+export { shallowEqual } from './langs/shallowEqual';
+export { deepEqual } from './langs/deepEqual';
+export { classOf } from './langs/classOf';
+export { shallowClone } from './langs/shallowClone';
+
+// assertions
 export { isClass } from './validations/isClass';
 export { isDefined } from './validations/isDefined';
 export { isEmptyObject } from './validations/isEmptyObject';
-export { shallowEqual } from './langs/shallowEqual';
-export { deepEqual } from './langs/deepEqual';
 export { isUUID } from './validations/isUUID';
-
-export { classOf } from './langs/classOf';
+export { isPlainObject } from './validations/isPlainObject';
 
 // modules
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
@@ -54,6 +57,7 @@ export { createTranslate } from './i18n/createTranslate';
 export { isBuffer } from './io/isBuffer';
 export { isTransferable } from './io/isTransferable';
 export { ArrayBuffers } from './io/ArrayBuffers';
+export { Buffer } from './io/Buffer';
 export type { AbstractEncoding } from './io/AbstractEncoding';
 
 // browser
@@ -68,8 +72,10 @@ export { structuredClone } from './isomorphics/structuredClone';
 
 // crypto
 export { randomUUID } from './crypto/randomUUID';
+export { getRandomValues } from './crypto/getRandomValues';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
 export { hex } from './crypto/base';
+export { isULID, createULID, ulid, parseULID } from './crypto/ulid';
 
 // misc
 export { createRandom } from './maths/random';

package/src/io/ArrayBuffers.base64.test.ts

@@ -2,7 +2,7 @@ import test from 'ava';
 import { ArrayBuffers } from './ArrayBuffers';
 
 test.before(() => {
-  ArrayBuffers._allowedBuffer = false;
+  ArrayBuffers.setAllowedNativeBuffer(false);
 });
 
 test('base64: ignore whitespace', function (t) {

package/src/io/ArrayBuffers.ts

@@ -66,21 +66,31 @@ type ToStringEncoding =
   | 'utf-8'
   | 'hex';
 
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export const ArrayBuffers = {
-  _allowedBuffer: true,
-  isArrayBuffer: (v: any): v is ArrayBuffer => {
+export class ArrayBuffers {
+  static #_allowedNativeBuffer: boolean = true;
+
+  static #isNativeBufferValid() {
+    return this.#_allowedNativeBuffer && !(globalThis.Buffer as any)?.isPollyfill?.();
+  }
+
+  static setAllowedNativeBuffer(v: boolean) {
+    this.#_allowedNativeBuffer = v;
+  }
+
+  static isArrayBuffer = (v: any): v is ArrayBuffer => {
     return v instanceof ArrayBuffer;
-  },
-  slice: (o: TypedArray, start?: number, end?: number) => {
+  };
+
+  static slice = (o: TypedArray, start?: number, end?: number) => {
     // NodeJS Buffer slice is not the same as UInt8Array slice
     // https://nodejs.org/api/buffer.html#bufslicestart-end
     if (isBuffer(o)) {
       return Uint8Array.prototype.slice.call(o, start, end);
     }
     return o.slice(start, end);
-  },
-  asView: <C extends ArrayBufferViewConstructor<unknown>, I extends InstanceType<C>>(
+  };
+
+  static asView = <C extends ArrayBufferViewConstructor<unknown>, I extends InstanceType<C>>(
     TypedArray: C,
     v: BufferSource,
     byteOffset?: number,
@@ -90,20 +100,21 @@ export const ArrayBuffers = {
       return v as I;
     }
     if (ArrayBuffer.isView(v) || isBuffer(v)) {
-      if (ArrayBuffers._allowedBuffer && typeof Buffer !== 'undefined' && (TypedArray as any) === Buffer) {
+      if (ArrayBuffers.#isNativeBufferValid() && (TypedArray as any) === Buffer) {
         // new Buffer() is deprecated
         return Buffer.from(v.buffer, byteOffset, byteLength) as I;
       }
       return new TypedArray(v.buffer, v.byteOffset + (byteOffset ?? 0), byteLength ?? v.byteLength) as I;
     }
     return new TypedArray(v, byteOffset, byteLength) as I;
-  },
-  toString: (buf: BufferSource | string, encoding: ToStringEncoding = 'utf8') => {
+  };
+
+  static toString = (buf: BufferSource | string, encoding: ToStringEncoding = 'utf8') => {
     // 'ascii'  'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'
     if (typeof buf === 'string') {
       return buf;
     }
-    if (typeof Buffer !== 'undefined' && ArrayBuffers._allowedBuffer) {
+    if (ArrayBuffers.#isNativeBufferValid()) {
       return Buffer.from(ArrayBuffers.asView(Uint8Array, buf)).toString(encoding);
     }
     // reference
@@ -148,11 +159,13 @@ export const ArrayBuffers = {
       default:
         throw new Error(`[ArrayBuffers.toString] Unknown encoding: ${encoding}`);
     }
-  },
-  toJSON: (v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any) => {
+  };
+
+  static toJSON = (v: BufferSource | string, reviver?: (this: any, key: string, value: any) => any) => {
     return JSON.parse(ArrayBuffers.toString(v), reviver);
-  },
-  alloc: (size: number, fill?: string | number, encoding?: ToStringEncoding) => {
+  };
+
+  static alloc = (size: number, fill?: string | number, encoding?: ToStringEncoding) => {
     if (fill !== undefined) {
       if (typeof fill === 'number') {
         return new Uint8Array(size).fill(fill);
@@ -162,8 +175,9 @@ export const ArrayBuffers = {
       return ArrayBuffers.asView(Uint8Array, ArrayBuffers.from(fill, encoding)).slice(0, size);
     }
     return new ArrayBuffer(size);
-  },
-  from: (
+  };
+
+  static from = (
     v: string | BufferSource | ArrayLike<number> | Iterable<number>,
     encoding: ToStringEncoding = 'utf8',
   ): BufferSource => {
@@ -171,7 +185,7 @@ export const ArrayBuffers = {
       return new ArrayBuffer(0);
     }
     if (typeof v === 'string') {
-      if (typeof Buffer !== 'undefined' && ArrayBuffers._allowedBuffer) {
+      if (ArrayBuffers.#isNativeBufferValid()) {
         return Buffer.from(v, encoding);
       }
 
@@ -203,8 +217,9 @@ export const ArrayBuffers = {
     }
     const type = classOf(v);
     throw new TypeError(`ArrayBuffers.from unsupported type ${type}`);
-  },
-  isEncoding: (encoding?: string) => {
+  };
+
+  static isEncoding = (encoding?: string) => {
     switch (String(encoding).toLowerCase()) {
       case 'hex':
       case 'utf8':
@@ -221,8 +236,9 @@ export const ArrayBuffers = {
       default:
         return false;
     }
-  },
-  concat: (buffers: Array<BufferSource>, result?: ArrayBuffer, offset = 0) => {
+  };
+
+  static concat = (buffers: Array<BufferSource>, result?: ArrayBuffer, offset = 0) => {
     // https://stackoverflow.com/questions/10786128/appending-arraybuffers
 
     const length = buffers.reduce((a, b) => a + b.byteLength, 0);
@@ -241,8 +257,8 @@ export const ArrayBuffers = {
       offset += buffer.byteLength;
     }
     return r.buffer;
-  },
-};
+  };
+}
 
 export type TypedArray =
   | Uint8Array

package/src/io/Buffer.test.ts

@@ -0,0 +1,23 @@
+import test from 'ava';
+import { Buffer } from './Buffer';
+import { isBuffer } from './isBuffer';
+
+test('basic', (t) => {
+  {
+    const buf = new Buffer(0);
+    t.true(Buffer.isBuffer(buf));
+    t.true(isBuffer(buf));
+  }
+  // const b = new Buffer(10)
+  // t.is(b.length,10)
+  // t.is(b.byteLength,10)
+  // t.is(b.byteOffset,0)
+  // t.is(b.buffer.byteLength,10)
+  // t.is(b.buffer.byteOffset,0)
+  // t.is(b.buffer.length,1)
+  // t.is(b.buffer[0].byteLength,10)
+  // t.is(b.buffer[0].byteOffset,0)
+  // t.is(b.buffer[0].length,10)
+  // t.is(b.buffer[0][0],0)
+  // t.is(b.buffer[0][9],0)
+});

package/src/io/Buffer.ts

@@ -1,15 +1,29 @@
 import { ArrayBuffers } from './ArrayBuffers';
+import { isBuffer } from './isBuffer';
 
+/**
+ * Buffer is a polyfill version of NodeJS Buffer
+ */
 export class Buffer extends Uint8Array {
   // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {
   //   super(buffer, byteOffset, length);
   // }
 
+  static get isPolyfill() {
+    return true;
+  }
+
+  static isBuffer(v: any): v is Buffer {
+    return v instanceof Buffer || isBuffer(v);
+  }
+
   static from(array: string | BufferSource | ArrayLike<number> | Iterable<number>, arg2?: any): Buffer {
     // todo mapfn
     return new Buffer(ArrayBuffers.from(array, arg2) as ArrayBuffer);
   }
 
+  static isEncoding = ArrayBuffers.isEncoding;
+
   toString(encoding?: string): string {
     return ArrayBuffers.toString(this, encoding as any);
   }

package/src/isomorphics/structuredClone.ts

@@ -4,7 +4,7 @@ import { classOf } from '../langs/classOf';
 /**
  * Clone an object using structured cloning algorithm
  *
- * - Chrome 98, Safari 15.4
+ * - Chrome 98, Safari 15.4, NodeJS 17
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone}
  * @see {@link https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/web.structured-clone.js core-js}