@wener/utils 1.1.3 → 1.1.5

package/src/index.ts

@@ -7,6 +7,11 @@ export {
   type MaybeArray,
 } from './arrays/MaybeArray';
 
+// object
+export { get } from './objects/get';
+export { set } from './objects/set';
+export { parseObjectPath } from './objects/parseObjectPath';
+
 // async
 export { createLazyPromise, type LazyPromise } from './asyncs/LazyPromise';
 export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval';
@@ -26,10 +31,17 @@ export { dequal } from './validations/dequal';
 
 // modules
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
+export { isModule } from './modules/isModule';
+
+// logging
+export { type Logger, type LogLevel } from './logging/Logger';
+export { createWriteLogger } from './logging/createWriteLogger';
+export { createNoopLogger } from './logging/createNoopLogger';
+export { createChildLogger } from './logging/createChildLogger';
 
 // strings
 export { pascalCase, camelCase } from './strings/camelCase';
-export { templateString } from './strings/templates';
+export { renderTemplate } from './strings/renderTemplate';
 
 export { createRandom } from './maths/random';
 export { isBuffer } from './io/isBuffer';

package/src/io/isBuffer.ts

@@ -1,4 +1,8 @@
-// https://github.com/feross/is-buffer/blob/master/index.js
+/**
+ * check {@code obj} is Buffer
+ *
+ * {@link https://github.com/feross/is-buffer feross/is-buffer}
+ */
 export function isBuffer(obj: any): obj is Buffer {
   return (
     obj != null &&

package/src/logging/Logger.ts

@@ -0,0 +1,19 @@
+export interface Logger {
+  trace(...data: any[]): void;
+
+  debug(...data: any[]): void;
+
+  info(...data: any[]): void;
+
+  warn(...data: any[]): void;
+
+  error(...data: any[]): void;
+
+  child?: (o: object) => Logger;
+}
+
+export interface LoggerWithChild extends Logger {
+  child: (o: object) => LoggerWithChild;
+}
+
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';

package/src/logging/createChildLogger.ts

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

package/src/logging/createNoopLogger.ts

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

package/src/logging/createWriteLogger.ts

@@ -0,0 +1,15 @@
+import { LoggerWithChild, LogLevel } from './Logger';
+
+export function createWriteLogger(
+  write: (o: { level: LogLevel; values: any[] } & Record<string | symbol, any>) => void,
+  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) => createWriteLogger(write, { ...context, ...ctx }),
+  };
+}

package/src/logging/logger.test.ts

@@ -0,0 +1,34 @@
+import test from 'ava';
+import { createChildLogger } from './createChildLogger';
+import { createWriteLogger } from './createWriteLogger';
+
+test('logger', (t) => {
+  {
+    let logs: any[] = [];
+    const base = createWriteLogger((o) => logs.push(o));
+    let l = createChildLogger(base, { c: 'test' });
+    l.info('hello');
+    t.deepEqual(logs.shift(), { level: 'info', values: ['hello'], c: 'test' });
+    l.child({ m: 1 }).trace('trace');
+    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

@@ -0,0 +1,10 @@
+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;
+}