@wener/utils 1.1.4 → 1.1.6

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;
   }

package/src/logging/logger.test.ts

@@ -13,4 +13,22 @@ test('logger', (t) => {
     t.deepEqual(logs.shift(), { level: 'trace', values: ['trace'], c: 'test', m: 1 });
   }
   createChildLogger(console, { c: 'test' }).info('hello');
+  {
+    let pass = 0;
+    let l = createWriteLogger(
+      (o) => {
+        pass++;
+        t.log(`${o.level}: [${[o.m, o.c].filter(Boolean).join('.') || 'default'}]`, ...o.values);
+      },
+      {
+        m: 'Root',
+      },
+    );
+    l.info('nice');
+    t.is(pass, 1);
+    l.child({}).info('nice 2');
+    t.is(pass, 2);
+    createChildLogger(l, { m: 'Child' }).info('nice 3');
+    t.is(pass, 3);
+  }
 });

package/src/modules/isModule.ts

@@ -1,3 +1,10 @@
-export function isModule(o: any) {
+export function isModule(o: any): o is Module {
   return o && o[Symbol.toStringTag] === 'Module';
 }
+
+export interface Module {
+  [Symbol.toStringTag]: 'Module';
+  default?: any;
+
+  [k: string | symbol]: any;
+}

package/src/modules/parseModuleId.ts

@@ -17,6 +17,11 @@ export type ParsedModuleId = {
     }
 );
 
+/**
+ * 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' }
+ */
 export function parseModuleId(s: string): ParsedModuleId | undefined {
   const groups = s.match(regModuleId)?.groups;
   if (!groups) {

package/src/objects/get.test.ts

@@ -0,0 +1,116 @@
+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 = {
+    undef: undefined,
+    zero: 0,
+    one: 1,
+    n: null,
+    f: false,
+    a: {
+      two: 2,
+      b: {
+        three: 3,
+        c: {
+          four: 4,
+        },
+      },
+    },
+    arr: [5, [6, { v: 7 }]],
+  } as const;
+
+  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);
+    if (path) {
+      const arr = parseObjectPath(path);
+      t.is(get(obj, arr, def), value, `get(obj,${JSON.stringify(arr)}, ${def})`);
+    }
+  }
+
+  check('', undefined);
+  check('one', obj.one);
+  check('one.two', undefined);
+  check('a', obj.a);
+  check('a.two', obj.a.two);
+  check('a.b', obj.a.b);
+  check('a.b.three', obj.a.b.three);
+  check('a.b.c', obj.a.b.c);
+  check('a.b.c.four', obj.a.b.c.four);
+  check('n', obj.n);
+  check('n.badkey', undefined);
+  check('f', false);
+  check('f.badkey', undefined);
+
+  check('', 'foo', 'foo');
+  check('undef', 'foo', 'foo');
+  check('n', null, 'foo');
+  check('n.badkey', 'foo', 'foo');
+  check('zero', 0, 'foo');
+  check('a.badkey', 'foo', 'foo');
+  check('a.badkey.anotherbadkey', 'foo', 'foo');
+  check('f', false, 'foo');
+  check('f.badkey', 'foo', 'foo');
+
+  check('arr.0', 5);
+  check('arr.1.0', 6);
+  check('arr.1.1.v', 7);
+  check('arr[0]', 5);
+  check('arr[1][0]', 6);
+  check('arr[1][1][v]', 7);
+});

package/src/objects/get.ts

@@ -0,0 +1,49 @@
+import { ObjectKey, parseObjectPath } from './parseObjectPath';
+
+/**
+ * get by path
+ *
+ * {@link https://github.com/developit/dlv dlv}
+ */
+export function get<O extends object, P extends ObjectKey, OrElse extends unknown>(
+  obj: O,
+  key: P | P[],
+  def?: OrElse,
+): ResolveObjectPathType<O, P, OrElse> {
+  const undef = undefined;
+  const path = parseObjectPath(key);
+  let out: any = obj;
+  for (const i of path) {
+    out = out ? out[i] : undef;
+  }
+  return out === undef ? def : out;
+}
+
+/**
+ * It tries to resolve the path of the given object, otherwise it will return OrElse
+ *
+ * {@link https://github.com/Pouja/typescript-deep-path-safe typescript-deep-path-safe}
+ */
+export type ResolveObjectPathType<
+  ObjectType,
+  Path extends string | symbol | number,
+  OrElse,
+> = Path extends keyof ObjectType
+  ? ObjectType[Path]
+  : Path extends `${infer LeftSide}.${infer RightSide}`
+  ? LeftSide extends keyof ObjectType
+    ? ResolveObjectPathType<ObjectType[LeftSide], RightSide, OrElse>
+    : Path extends `${infer LeftSide}[${number}].${infer RightSide}`
+    ? LeftSide extends keyof ObjectType
+      ? ObjectType[LeftSide] extends Array<infer U>
+        ? ResolveObjectPathType<U, RightSide, OrElse>
+        : OrElse
+      : OrElse
+    : OrElse
+  : Path extends `${infer LeftSide}[${number}]`
+  ? LeftSide extends keyof ObjectType
+    ? ObjectType[LeftSide] extends Array<infer U>
+      ? U
+      : OrElse
+    : OrElse
+  : OrElse;

package/src/objects/parseObjectPath.test.ts

@@ -0,0 +1,18 @@
+import test from 'ava';
+import { parseObjectPath } from './parseObjectPath';
+
+test('parseObjectPath', (t) => {
+  for (const [k, v] of [
+    ['a.b.c', ['a', 'b', 'c']],
+    ['a[1].c', ['a', '1', 'c']],
+    ['a.1.c', ['a', '1', 'c']],
+    ['a[b].c', ['a', 'b', 'c']],
+    ['arr[1][0]', ['arr', '1', '0']],
+    ['arr.2', ['arr', '2']],
+    ['arr[2]', ['arr', '2']],
+    [Symbol.toStringTag, [Symbol.toStringTag]],
+    [[Symbol.toStringTag], [Symbol.toStringTag]],
+  ]) {
+    t.deepEqual(parseObjectPath(k), v);
+  }
+});

package/src/objects/parseObjectPath.ts

@@ -0,0 +1,40 @@
+export type ObjectKey = string | symbol | number;
+export type ObjectPath = Array<ObjectKey>;
+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]
+ *
+ */
+export function parseObjectPath(s: ObjectPathLike): ObjectPath {
+  if (typeof s !== 'string') {
+    return Array.isArray(s) ? s : [s];
+  }
+  const parts = s.split('.');
+  // fast path
+  if (!s.includes('[')) {
+    return parts;
+  }
+
+  const result = [];
+  for (const part of parts) {
+    if (!part.endsWith(']')) {
+      result.push(part);
+    } else {
+      // a[0][1]
+      // try parseInt can extend to support a[-1] to use .at access
+      const s = part.split('[');
+      for (let sub of s) {
+        if (sub.endsWith(']')) {
+          sub = sub.slice(0, -1);
+        }
+        result.push(sub);
+      }
+    }
+  }
+  return result;
+}