@wener/utils 1.1.5 → 1.1.7

package/src/io/isBuffer.ts

@@ -1,13 +1,8 @@
 /**
- * check {@code obj} is Buffer
+ * check {@link obj} is Buffer
  *
- * {@link https://github.com/feross/is-buffer feross/is-buffer}
+ * @see {@link https://github.com/feross/is-buffer feross/is-buffer}
  */
 export function isBuffer(obj: any): obj is Buffer {
-  return (
-    obj != null &&
-    obj.constructor != null &&
-    typeof obj.constructor.isBuffer === 'function' &&
-    obj.constructor.isBuffer(obj)
-  );
+  return obj?.constructor?.isBuffer?.(obj);
 }

package/src/io/isTransferable.test.ts

@@ -0,0 +1,10 @@
+import test from 'ava';
+import { Buffer } from 'node:buffer';
+import { isTransferable } from './isTransferable';
+
+test('isTransferable', (t) => {
+  t.false(isTransferable(0));
+  t.false(isTransferable(Buffer.from('')));
+  t.true(new ArrayBuffer(0) instanceof ArrayBuffer);
+  t.true(isTransferable(new ArrayBuffer(0)));
+});

package/src/io/isTransferable.ts

@@ -0,0 +1,50 @@
+/**
+ * transferable object pass between workers, can work with structuredClone
+ *
+ * - Chrome 87, FF 103, Safari X, NodeJS X
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects | Transferable objects}
+ */
+export function isTransferable(v: any): v is TransferableObject {
+  _ctors ||= ctors();
+  return _ctors.some((ctor) => v instanceof ctor);
+}
+
+let _ctors: any[];
+
+function ctors() {
+  const o: any = globalThis.window || globalThis || global;
+  return [
+    o.ArrayBuffer,
+    o.MessagePort,
+    o.ReadableStream,
+    o.WritableStream,
+    o.TransformStream,
+    o.AudioData,
+    o.ImageBitmap,
+    o.VideoFrame,
+    o.OffscreenCanvas,
+    o.RTCDataChannel,
+  ].filter(Boolean);
+}
+
+export type TransferableObject =
+  | Transferable
+  | ArrayBuffer
+  | MessagePort
+  | ReadableStream
+  | WritableStream
+  | TransformStream
+  | AudioData
+  | ImageBitmap
+  | VideoFrame
+  | OffscreenCanvas
+  | RTCDataChannel;
+
+declare global {
+  interface OffscreenCanvas {}
+
+  interface VideoFrame {}
+
+  interface AudioData {}
+}

package/src/isomorphics/structuredClone.test.ts

@@ -0,0 +1,14 @@
+import test from 'ava';
+import { classOf } from '../langs/classOf';
+import { _clone } from './structuredClone';
+
+test('structuredClone', (t) => {
+  for (const [k, v] of [
+    ['', ''],
+    [Number(1), 1],
+  ]) {
+    const c = _clone(k);
+    t.deepEqual(c, v);
+    t.is(classOf(c), classOf(v));
+  }
+});

package/src/isomorphics/structuredClone.ts

@@ -0,0 +1,88 @@
+/* eslint no-proto:0 */
+import { classOf } from '../langs/classOf';
+
+/**
+ * Clone an object using structured cloning algorithm
+ *
+ * - Chrome 98, Safari 15.4
+ *
+ * @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}
+ */
+export const structuredClone: <T>(value: T, options?: StructuredSerializeOptions) => T =
+  globalThis.structuredClone || _clone;
+
+function set(obj: any, key: any, val: any) {
+  if (typeof val.value === 'object') val.value = _clone(val.value);
+  if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {
+    Object.defineProperty(obj, key, val);
+  } else obj[key] = val.value;
+}
+
+/**
+ * @see {@link https://github.com/lukeed/klona/blob/master/src/full.js klona}
+ */
+export function _clone(x: any): any {
+  // too complex
+  // https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/web.structured-clone.js
+
+  if (typeof x !== 'object') return x;
+
+  let i = 0;
+  let k;
+  let list;
+  let tmp: any;
+  const str = classOf(x);
+  switch (str) {
+    case 'Array':
+      tmp = Array(x.length);
+      break;
+    case 'Object':
+      tmp = Object.create(x.__proto__ || null);
+      break;
+    case 'Set':
+      tmp = new Set();
+      x.forEach(function (val: any) {
+        tmp.add(_clone(val));
+      });
+      break;
+    case 'Map':
+      tmp = new Map();
+      x.forEach(function (val: any, key: any) {
+        tmp.set(_clone(key), _clone(val));
+      });
+      break;
+    case 'Date':
+      tmp = new Date(+x);
+      break;
+    case 'RegExp':
+      tmp = new RegExp(x.source, x.flags);
+      break;
+    case 'DataView':
+      tmp = new x.constructor(_clone(x.buffer));
+      break;
+    case 'ArrayBuffer':
+      tmp = x.slice(0);
+      break;
+    default:
+      // typed arrays
+      if (str.endsWith('Array')) {
+        // ArrayBuffer.isView(x)
+        // ~> `new` bcuz `Buffer.slice` => ref
+        tmp = new x.constructor(x);
+      }
+  }
+
+  if (tmp) {
+    for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) {
+      set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
+    }
+
+    for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
+      if (Object.hasOwnProperty.call(tmp, (k = list[i])) && tmp[k] === x[k]) continue;
+      set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+    }
+  }
+
+  return tmp || x;
+}

package/src/langs/classOf.ts

@@ -0,0 +1,3 @@
+export function classOf(o: any) {
+  return Object.prototype.toString.call(o).slice(8, -1);
+}

package/src/{validations/dequal.test.ts → langs/deepEqual.test.ts}

@@ -1,9 +1,9 @@
 import test from 'ava';
-import { dequal } from './dequal';
+import { deepEqual } from './deepEqual';
 
 test('deep equal', (t) => {
   t.true(
-    dequal(
+    deepEqual(
       {
         a: null,
         b: Infinity,

package/src/{validations/dequal.ts → langs/deepEqual.ts}

@@ -3,7 +3,7 @@ const hasElementType = typeof Element !== 'undefined';
 
 function find(iter: any, tar: any, key?: any) {
   for (key of iter.keys()) {
-    if (dequal(key, tar)) return key;
+    if (deepEqual(key, tar)) return key;
   }
 }
 
@@ -12,7 +12,7 @@ function find(iter: any, tar: any, key?: any) {
  * @see {@link https://github.com/lukeed/dequal/blob/master/src/lite.js dequal/src/lite.js}
  * @see {@link https://github.com/FormidableLabs/react-fast-compare/blob/master/index.js react-fast-compare/index.js}
  */
-export function dequal(foo: any, bar: any) {
+export function deepEqual(foo: any, bar: any) {
   let ctor, len, tmp;
   if (foo === bar) return true;
 
@@ -22,7 +22,7 @@ export function dequal(foo: any, bar: any) {
 
     if (ctor === Array) {
       if ((len = foo.length) === bar.length) {
-        while (len-- && dequal(foo[len], bar[len]));
+        while (len-- && deepEqual(foo[len], bar[len]));
       }
       return len === -1;
     }
@@ -52,7 +52,7 @@ export function dequal(foo: any, bar: any) {
           tmp = find(bar, tmp);
           if (!tmp) return false;
         }
-        if (!dequal(len[1], bar.get(tmp))) {
+        if (!deepEqual(len[1], bar.get(tmp))) {
           return false;
         }
       }
@@ -95,11 +95,12 @@ export function dequal(foo: any, bar: any) {
         }
 
         if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
       }
       return Object.keys(bar).length === len;
     }
   }
 
+  // eslint-disable-next-line no-self-compare
   return foo !== foo && bar !== bar;
 }

package/src/langs/langs.test.ts

@@ -0,0 +1,23 @@
+import test from 'ava';
+import { classOf } from './classOf';
+
+test('classOf', (t) => {
+  for (const [k, v] of [
+    [0, 'Number'],
+    ['', 'String'],
+    [true, 'Boolean'],
+    [null, 'Null'],
+    [undefined, 'Undefined'],
+    [{}, 'Object'],
+    [[], 'Array'],
+    [new ArrayBuffer(0), 'ArrayBuffer'],
+    [new Map(), 'Map'],
+    [new Set(), 'Set'],
+    [new Date(), 'Date'],
+    [new RegExp(''), 'RegExp'],
+    [new DataView(new ArrayBuffer(0)), 'DataView'],
+    [new Int8Array(0), 'Int8Array'],
+  ]) {
+    t.is(classOf(k), v as any);
+  }
+});

package/src/{validations/shallow.ts → langs/shallowEqual.ts}

@@ -3,7 +3,7 @@
  *
  * @see {@link https://github.com/pmndrs/zustand/blob/main/src/shallow.ts zustand/src/shallow.ts}
  */
-export function shallow<T, U>(objA: T, objB: U) {
+export function shallowEqual<T, U>(objA: T, objB: U) {
   if (Object.is(objA, objB)) {
     return true;
   }
@@ -16,7 +16,7 @@ export function shallow<T, U>(objA: T, objB: U) {
   }
   for (let i = 0; i < keysA.length; i++) {
     if (
-      !Object.prototype.hasOwnProperty.call(objB, keysA[i] as string) ||
+      !Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
       !Object.is(objA[keysA[i] as keyof T], objB[keysA[i] as keyof U])
     ) {
       return false;

package/src/logging/Logger.ts

@@ -1,3 +1,6 @@
+/**
+ * Logger interface satisfies the `console`, `pino` logger interface.
+ */
 export interface Logger {
   trace(...data: any[]): void;
 
@@ -9,6 +12,9 @@ export interface Logger {
 
   error(...data: any[]): void;
 
+  /**
+   * create child logger with given context
+   */
   child?: (o: object) => Logger;
 }
 

package/src/logging/createNoopLogger.ts

@@ -1,7 +1,7 @@
 import { LoggerWithChild } from './Logger';
 
 export function createNoopLogger(): LoggerWithChild {
-  const noop = (..._: any[]) => void 0;
+  const noop = (..._: any[]) => undefined;
   return {
     trace: noop,
     debug: noop,

package/src/logging/logger.test.ts

@@ -4,9 +4,9 @@ import { createWriteLogger } from './createWriteLogger';
 
 test('logger', (t) => {
   {
-    let logs: any[] = [];
+    const logs: any[] = [];
     const base = createWriteLogger((o) => logs.push(o));
-    let l = createChildLogger(base, { c: 'test' });
+    const l = createChildLogger(base, { c: 'test' });
     l.info('hello');
     t.deepEqual(logs.shift(), { level: 'info', values: ['hello'], c: 'test' });
     l.child({ m: 1 }).trace('trace');
@@ -15,7 +15,7 @@ test('logger', (t) => {
   createChildLogger(console, { c: 'test' }).info('hello');
   {
     let pass = 0;
-    let l = createWriteLogger(
+    const l = createWriteLogger(
       (o) => {
         pass++;
         t.log(`${o.level}: [${[o.m, o.c].filter(Boolean).join('.') || 'default'}]`, ...o.values);

package/src/modules/isModule.ts

@@ -1,3 +1,6 @@
+/**
+ * Check is ESM Module
+ */
 export function isModule(o: any): o is Module {
   return o && o[Symbol.toStringTag] === 'Module';
 }

package/src/modules/parseModuleId.test.ts

@@ -10,6 +10,7 @@ test('parseModuleId', (t) => {
       scoped: true,
       org: 'wener',
       pkg: 'reaction',
+      versioned: false,
     },
     reaction: {
       id: `reaction@latest`,
@@ -17,6 +18,7 @@ test('parseModuleId', (t) => {
       range: 'latest',
       pkg: 'reaction',
       scoped: false,
+      versioned: false,
     },
     'reaction@1': {
       id: `reaction@1`,
@@ -24,6 +26,7 @@ test('parseModuleId', (t) => {
       range: '1',
       pkg: 'reaction',
       scoped: false,
+      versioned: true,
     },
     'reaction@1.1.1': {
       id: `reaction@1.1.1`,
@@ -32,6 +35,7 @@ test('parseModuleId', (t) => {
       range: '1.1.1',
       pkg: 'reaction',
       scoped: false,
+      versioned: true,
     },
     'reaction@1.1.1-alpha': {
       id: `reaction@1.1.1-alpha`,
@@ -39,7 +43,7 @@ test('parseModuleId', (t) => {
       version: '1.1.1-alpha',
       range: '1.1.1-alpha',
       pkg: 'reaction',
-
+      versioned: true,
       scoped: false,
     },
     'reaction@1.1.1/index.js': {
@@ -49,7 +53,7 @@ test('parseModuleId', (t) => {
       range: '1.1.1',
       scoped: false,
       pkg: 'reaction',
-
+      versioned: true,
       path: '/index.js',
     },
     'reaction@1.1.1/': {
@@ -60,6 +64,7 @@ test('parseModuleId', (t) => {
       scoped: false,
       pkg: 'reaction',
       path: '/',
+      versioned: true,
     },
   };
   for (const [k, v] of Object.entries(tests)) {

package/src/modules/parseModuleId.ts

@@ -9,18 +9,22 @@ export type ParsedModuleId = {
   range: string; // version, tag, range
   pkg: string;
   path?: string;
+  org?: string;
+  versioned: boolean; // is module id contain a version specifier
 } & (
   | { scoped: false }
   | {
       scoped: true;
-      org?: string;
+      org: string;
     }
 );
 
 /**
  * Parse NPM module id
  *
- *    parseModuleId('@wener/reaction@latest/index.js') // => { id: '@wener/reaction@latest', name: '@wener/reaction', version: 'latest', range: 'latest', pkg: 'reaction', path: '/index.js', scoped: true, org: 'wener' }
+ * @example
+ * parseModuleId('@wener/reaction@latest/index.js')
+ * // { id: '@wener/reaction@latest', name: '@wener/reaction', version: 'latest', range: 'latest', pkg: 'reaction', path: '/index.js', scoped: true, org: 'wener' }
  */
 export function parseModuleId(s: string): ParsedModuleId | undefined {
   const groups = s.match(regModuleId)?.groups;
@@ -28,24 +32,26 @@ export function parseModuleId(s: string): ParsedModuleId | undefined {
     return undefined;
   }
   const { n: name, v: version, p: path, org, pkg } = groups;
-  let scoped = Boolean(org);
+  const scoped = Boolean(org);
   const v = /^\d+\.\d+\.\d+/.test(version) ? version : undefined;
-  let range = version || 'latest';
-  const o = {
+  const range = version || 'latest';
+  const o: ParsedModuleId = {
     id: `${name}@${range}`,
     name,
-    range: range,
+    range,
     scoped,
     pkg,
-  } as ParsedModuleId;
+    org,
+    versioned: Boolean(version),
+  };
   if (v) {
     o.version = v;
   }
   if (path) {
     o.path = path;
   }
-  if (o.scoped) {
-    o.org = org;
+  if (!o.scoped) {
+    delete o.org;
   }
   return o;
 }

package/src/objects/get.test-d.ts

@@ -0,0 +1,51 @@
+import { expectType } from 'tsd';
+import { get } from './get';
+
+interface TestClass {
+  normal: string;
+  nested: {
+    a: number;
+    b: {
+      c: boolean;
+    };
+  };
+  arr: number[];
+  nestedArr: {
+    sum: number;
+    other: null;
+  }[];
+  deep: {
+    arr: string[];
+  };
+  deeplvl1: {
+    deeplvl2: {
+      deeplvl3: {
+        deeplvl4: {
+          value: RegExp;
+        };
+      }[];
+    };
+  }[];
+}
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+const obj = {} as TestClass;
+
+expectType<number>(get(obj, 'nested.a', null));
+expectType<string>(get(obj, 'normal', null));
+expectType<number>(get(obj, 'nested.a'));
+expectType<boolean>(get(obj, 'nested.b.c'));
+expectType<number[]>(get(obj, 'arr'));
+expectType<number>(get(obj, 'arr[13]'));
+expectType<number>(get(obj, 'arr.13'));
+expectType<null>(get(obj, 'nestedArr[3].other'));
+expectType<string[]>(get(obj, 'deep.deep'));
+expectType<string>(get(obj, 'deep.arr[333]'));
+expectType<number>(get(obj, 'deep.arr[333].length'));
+expectType<boolean>(get(obj, 'nested["b"]["c"]'));
+expectType<never>(get(obj, ''));
+expectType<number>(get(obj, '', 3));
+expectType<never>(get(obj, 'nested.asdfasdf'));
+expectType<RegExp>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl3[88].deeplvl4.value'));
+expectType<never>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value'));
+expectType<TestClass>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value', obj));
+expectType<string>(get(obj, 'nested["dd"]', ''));

package/src/objects/get.test.ts

@@ -1,62 +1,9 @@
 import test from 'ava';
-import { expectType } from 'tsd';
 import { get } from './get';
 import { parseObjectPath } from './parseObjectPath';
 
-test('get typed', (t) => {
-  interface TestClass {
-    normal: string;
-    nested: {
-      a: number;
-      b: {
-        c: boolean;
-      };
-    };
-    arr: number[];
-    nestedArr: {
-      sum: number;
-      other: null;
-    }[];
-    deep: {
-      arr: string[];
-    };
-    deeplvl1: {
-      deeplvl2: {
-        deeplvl3: {
-          deeplvl4: {
-            value: RegExp;
-          };
-        }[];
-      };
-    }[];
-  }
-
-  const obj = {} as TestClass;
-
-  expectType<number>(get(obj, 'nested.a', null));
-  expectType<string>(get(obj, 'normal', null));
-  expectType<number>(get(obj, 'nested.a'));
-  expectType<boolean>(get(obj, 'nested.b.c'));
-  expectType<number[]>(get(obj, 'arr'));
-  expectType<number>(get(obj, 'arr[13]'));
-  expectType<number>(get(obj, 'arr.13'));
-  expectType<null>(get(obj, 'nestedArr[3].other'));
-  expectType<string[]>(get(obj, 'deep.deep'));
-  expectType<string>(get(obj, 'deep.arr[333]'));
-  expectType<number>(get(obj, 'deep.arr[333].length'));
-  expectType<boolean>(get(obj, 'nested["b"]["c"]'));
-  expectType<never>(get(obj, ''));
-  expectType<number>(get(obj, '', 3));
-  expectType<never>(get(obj, 'nested.asdfasdf'));
-  expectType<RegExp>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl3[88].deeplvl4.value'));
-  expectType<never>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value'));
-  expectType<TestClass>(get(obj, 'deeplvl1[1].deeplvl2.deeplvl1[88].deeplvl4.value', obj));
-  expectType<string>(get(obj, 'nested["dd"]', ''));
-  t.pass();
-});
-
 test('get', (t) => {
-  let obj = {
+  const obj = {
     undef: undefined,
     zero: 0,
     one: 1,
@@ -76,7 +23,7 @@ test('get', (t) => {
 
   function check(path: string, value: any, def?: any) {
     const out = get(obj, path, def);
-    t.is(out, value, 'get(obj, "' + path + '") should be ' + value + ', got ' + out);
+    t.is(out, value, `get(obj, "${path}") should be ${value}, got ${out}`);
     if (path) {
       const arr = parseObjectPath(path);
       t.is(get(obj, arr, def), value, `get(obj,${JSON.stringify(arr)}, ${def})`);

package/src/objects/parseObjectPath.ts

@@ -5,9 +5,10 @@ export type ObjectPathLike = ObjectKey | ObjectPath;
 /**
  * Parse object path
  *
- *   parseObjectPath('a.b.c') // => ['a', 'b', 'c']
- *   parseObjectPath('a[0].b') // => ['a', 0, 'b']
- *   parseObjectPath('a[0][1]') // => ['a', 0, 1]
+ * @example
+ * parseObjectPath('a.b.c') // => ['a', 'b', 'c']
+ * parseObjectPath('a[0].b') // => ['a', 0, 'b']
+ * parseObjectPath('a[0][1]') // => ['a', 0, 1]
  *
  */
 export function parseObjectPath(s: ObjectPathLike): ObjectPath {