@wener/utils 1.1.7 → 1.1.9

package/src/crypto/ulid.ts

@@ -0,0 +1,183 @@
+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 {
+  // ttttttttttrrrrrrrrrrrrrrrr
+  return str?.length === 26 && /^[0-9A-HJKMNP-TV-Z]{26}$/i.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): { timestamp: 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 { timestamp: 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 && lastRandom) {
+      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,20 @@ 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';
+export { parseTimestamp } from './validations/parseTimestamp';
+export { parseBoolean } from './validations/parseBoolean';
 
 // modules
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
@@ -38,7 +43,7 @@ export { isModule, type Module } from './modules/isModule';
 
 // logging
 export { type Logger, type LogLevel } from './logging/Logger';
-export { createWriteLogger } from './logging/createWriteLogger';
+export { createLogger } from './logging/createLogger';
 export { createNoopLogger } from './logging/createNoopLogger';
 export { createChildLogger } from './logging/createChildLogger';
 
@@ -54,6 +59,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 +74,12 @@ 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';
+
+export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;

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}

package/src/langs/shallowClone.ts

@@ -0,0 +1,13 @@
+export function shallowClone<T>(obj: T): T {
+  if (!obj) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.slice() as T;
+  }
+  if (typeof obj === 'object') {
+    return Object.assign({}, obj);
+  }
+  // skip Map, Set, WeakMap, WeakSet, Date, RegExp, etc.
+  return obj;
+}

package/src/logging/createChildLogger.ts

@@ -1,11 +1,11 @@
-import { Logger, LoggerWithChild } from './Logger';
-import { createWriteLogger } from './createWriteLogger';
+import type { Logger, LoggerWithChild } from './Logger';
+import { createLogger } from './createLogger';
 
 export function createChildLogger(l: Logger, ctx: object): LoggerWithChild {
   if (l.child) {
     return l.child(ctx) as LoggerWithChild;
   }
-  return createWriteLogger((o) => {
+  return createLogger((o) => {
     const { level, values, ...c } = o;
     if (Object.keys(c).length) {
       l[level](c, ...values);

package/src/logging/createLogger.ts

@@ -0,0 +1,31 @@
+import type { LoggerWithChild, LogLevel } from './Logger';
+
+export function createLogger(
+  write: (o: { level: LogLevel; values: any[] } & Record<string | symbol, any>) => void = ({
+    level,
+    values,
+    ...ctx
+  }) => {
+    ({ values, ...ctx } = merge(ctx, values));
+    console[level]?.(...values, ctx);
+  },
+  context: object = {},
+): LoggerWithChild {
+  return {
+    trace: (...values) => write({ ...context, level: 'trace', values }),
+    debug: (...values) => write({ ...context, level: 'debug', values }),
+    info: (...values) => write({ ...context, level: 'info', values }),
+    warn: (...values) => write({ ...context, level: 'warn', values }),
+    error: (...values) => write({ ...context, level: 'error', values }),
+    child: (ctx) => createLogger(write, { ...context, ...ctx }),
+  };
+}
+
+// logger.info({name:'wener'},'message')
+// merge initial context with message object
+function merge(ctx: any, values: any[]) {
+  if (values[0] && typeof values[0] === 'object') {
+    return { ...ctx, ...values[0], values: values.slice(1) };
+  }
+  return { ...ctx, values };
+}

package/src/logging/createNoopLogger.ts

@@ -1,4 +1,4 @@
-import { LoggerWithChild } from './Logger';
+import type { LoggerWithChild } from './Logger';
 
 export function createNoopLogger(): LoggerWithChild {
   const noop = (..._: any[]) => undefined;

package/src/logging/logger.test.ts

@@ -1,11 +1,11 @@
 import test from 'ava';
 import { createChildLogger } from './createChildLogger';
-import { createWriteLogger } from './createWriteLogger';
+import { createLogger } from './createLogger';
 
 test('logger', (t) => {
   {
     const logs: any[] = [];
-    const base = createWriteLogger((o) => logs.push(o));
+    const base = createLogger((o) => logs.push(o));
     const l = createChildLogger(base, { c: 'test' });
     l.info('hello');
     t.deepEqual(logs.shift(), { level: 'info', values: ['hello'], c: 'test' });
@@ -15,7 +15,7 @@ test('logger', (t) => {
   createChildLogger(console, { c: 'test' }).info('hello');
   {
     let pass = 0;
-    const l = createWriteLogger(
+    const l = createLogger(
       (o) => {
         pass++;
         t.log(`${o.level}: [${[o.m, o.c].filter(Boolean).join('.') || 'default'}]`, ...o.values);
@@ -30,5 +30,7 @@ test('logger', (t) => {
     t.is(pass, 2);
     createChildLogger(l, { m: 'Child' }).info('nice 3');
     t.is(pass, 3);
+
+    createLogger().child({ name: 'wener' }).info({ x: 1 }, 'Nice');
   }
 });

package/src/objects/get.ts

@@ -1,4 +1,5 @@
-import { ObjectKey, parseObjectPath } from './parseObjectPath';
+import type { ObjectKey} from './parseObjectPath';
+import { parseObjectPath } from './parseObjectPath';
 
 /**
  * get by path

package/src/objects/set.ts

@@ -1,4 +1,5 @@
-import { ObjectKey, ObjectPath, parseObjectPath } from './parseObjectPath';
+import type { ObjectKey, ObjectPath} from './parseObjectPath';
+import { parseObjectPath } from './parseObjectPath';
 
 /**
  * Deep set

package/src/server/polyfillBrowser.test.ts

@@ -1,7 +1,11 @@
 import test from 'ava';
+import * as nodeFetch from 'node-fetch';
 import { polyfillBrowser } from './polyfillBrowser';
+import { polyfillFetch } from './polyfillFetch';
 
-test.before(async () => {
+test.before(async (t) => {
+  t.true(polyfillFetch(nodeFetch));
+  t.false(polyfillFetch());
   await polyfillBrowser();
 });