@wener/utils 1.1.4 → 1.1.5

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

package/src/objects/set.test.ts

@@ -0,0 +1,405 @@
+import test from 'ava';
+import { set } from './set';
+
+test('set basics', (t) => {
+  t.is(set({}, 'c', 3), undefined, 'should not give return value');
+  {
+    let item = { foo: 1 };
+    set(item, 'bar', 123);
+    t.is(item, item);
+    t.deepEqual(
+      item,
+      {
+        foo: 1,
+        bar: 123,
+      },
+      'should mutate original object',
+    );
+  }
+});
+
+test('set objects', (t) => {
+  const prepare = (x: any) => ({ input: x, copy: JSON.parse(JSON.stringify(x)) });
+  const objects = (s: string, f: Function) => {
+    t.log(s);
+    f();
+  };
+  const orig = set;
+
+  function run(isMerge: boolean) {
+    const set = (a: any, b: any, c: any) => orig(a, b, c, isMerge);
+    const verb = isMerge ? 'merge' : 'overwrite';
+    objects(`should ${verb} existing object value :: simple`, () => {
+      let { input } = prepare({
+        hello: { a: 1 },
+      });
+
+      set(input, 'hello', { foo: 123 });
+
+      if (isMerge) {
+        t.deepEqual(input, {
+          hello: {
+            a: 1,
+            foo: 123,
+          },
+        });
+      } else {
+        t.deepEqual(input, {
+          hello: { foo: 123 },
+        });
+      }
+    });
+
+    objects(`should ${verb} existing object value :: nested`, () => {
+      let { input, copy } = prepare({
+        a: {
+          b: {
+            c: 123,
+          },
+        },
+      });
+
+      set(input, 'a.b', { foo: 123 });
+
+      if (isMerge) {
+        Object.assign(copy.a.b, { foo: 123 });
+      } else {
+        copy.a.b = { foo: 123 };
+      }
+
+      t.deepEqual(input, copy);
+    });
+
+    objects(`should ${verb} existing array value :: simple`, () => {
+      let { input } = prepare([{ foo: 1 }]);
+
+      set(input, '0', { bar: 2 });
+
+      if (isMerge) {
+        t.deepEqual(input, [{ foo: 1, bar: 2 }]);
+      } else {
+        t.deepEqual(input, [{ bar: 2 }]);
+      }
+    });
+
+    objects(`should ${verb} existing array value :: nested`, () => {
+      let { input } = prepare([
+        { name: 'bob', age: 56, friends: ['foobar'] },
+        { name: 'alice', age: 47, friends: ['mary'] },
+      ]);
+
+      set(input, '0', { age: 57, friends: ['alice', 'mary'] });
+      set(input, '1', { friends: ['bob'] });
+      set(input, '2', { name: 'mary', age: 49, friends: ['bob'] });
+
+      if (isMerge) {
+        t.deepEqual(input, [
+          { name: 'bob', age: 57, friends: ['alice', 'mary'] },
+          { name: 'alice', age: 47, friends: ['bob'] },
+          { name: 'mary', age: 49, friends: ['bob'] },
+        ]);
+      } else {
+        t.deepEqual(input, [
+          { age: 57, friends: ['alice', 'mary'] },
+          { friends: ['bob'] },
+          { name: 'mary', age: 49, friends: ['bob'] },
+        ]);
+      }
+    });
+  }
+
+  run(true);
+  run(false);
+});
+
+test('set arrays', (t) => {
+  const arrays = (s: string, f: Function) => {
+    t.log(s);
+    f();
+  };
+  arrays('should create array instead of object via numeric key :: simple', () => {
+    let input: any = { a: 1 };
+    set(input, 'e.0', 2);
+    t.true(Array.isArray(input.e));
+    t.is(input.e[0], 2);
+    t.deepEqual(input, {
+      a: 1,
+      e: [2],
+    });
+  });
+
+  arrays('should create array instead of object via numeric key :: nested', () => {
+    let input: any = { a: 1 };
+    set(input, 'e.0.0', 123);
+    t.true(input.e instanceof Array);
+    t.is(input.e[0][0], 123);
+    t.deepEqual(input, {
+      a: 1,
+      e: [[123]],
+    });
+  });
+
+  arrays('should be able to create object inside of array', () => {
+    let input: any = {};
+    set(input, ['x', '0', 'z'], 123);
+    t.true(input.x instanceof Array);
+    t.deepEqual(input, {
+      x: [{ z: 123 }],
+    });
+  });
+
+  arrays('should create arrays with hole(s) if needed', () => {
+    let input: any = {};
+    set(input, ['x', '1', 'z'], 123);
+    t.true(input.x instanceof Array);
+    t.deepEqual(input, {
+      x: [, { z: 123 }],
+    });
+  });
+
+  arrays('should create object from decimal-like key :: array :: zero :: string', () => {
+    let input: any = {};
+    set(input, ['x', '10.0', 'z'], 123);
+    t.false(input.x instanceof Array);
+    t.deepEqual(input, {
+      x: {
+        '10.0': {
+          z: 123,
+        },
+      },
+    });
+  });
+
+  arrays('should create array from decimal-like key :: array :: zero :: number', () => {
+    let input: any = {};
+    set(input, ['x', 10.0, 'z'], 123);
+    t.true(input.x instanceof Array);
+
+    let x = Array(10);
+    x.push({ z: 123 });
+    t.deepEqual(input, { x });
+  });
+
+  arrays('should create object from decimal-like key :: array :: nonzero', () => {
+    let input: any = {};
+    set(input, ['x', '10.2', 'z'], 123);
+    t.false(input.x instanceof Array);
+    t.deepEqual(input, {
+      x: {
+        '10.2': {
+          z: 123,
+        },
+      },
+    });
+  });
+});
+
+test('set pollution', (t) => {
+  const pollution = (s: string, f: Function) => {
+    t.log(s);
+    f();
+  };
+  pollution('should protect against "__proto__" assignment', () => {
+    let input: any = { abc: 123 };
+    let before = input.__proto__;
+    set(input, '__proto__.hello', 123);
+
+    t.deepEqual(input.__proto__, before);
+    t.deepEqual(input, {
+      abc: 123,
+    });
+  });
+
+  pollution('should protect against "__proto__" assignment :: nested', () => {
+    let input: any = { abc: 123 };
+    let before = input.__proto__;
+    set(input, ['xyz', '__proto__', 'hello'], 123);
+
+    t.deepEqual(input.__proto__, before);
+    t.deepEqual(input, {
+      abc: 123,
+      xyz: {
+        // empty
+      },
+    });
+
+    t.is(input.hello, undefined);
+  });
+
+  pollution('should ignore "prototype" assignment', () => {
+    let input: any = { a: 123 };
+    set(input, 'a.prototype.hello', 'world');
+
+    t.is(input.a.prototype, undefined);
+    t.is(input.a.hello, undefined);
+
+    t.deepEqual(input, {
+      a: {
+        // converted, then aborted
+      },
+    });
+
+    t.is(JSON.stringify(input), '{"a":{}}');
+  });
+
+  pollution('should ignore "constructor" assignment :: direct', () => {
+    let input: any = { a: 123 };
+
+    function Custom() {
+      //
+    }
+
+    set(input, 'a.constructor', Custom);
+    t.not(input.a.constructor, Custom);
+    t.false(input.a instanceof Custom);
+
+    t.true(input.a.constructor instanceof Object, '~> 123 -> {}');
+    t.is(input.a.hasOwnProperty('constructor'), false);
+    t.deepEqual(input, { a: {} });
+  });
+
+  pollution('should ignore "constructor" assignment :: nested', () => {
+    let input: any = {};
+
+    set(input, 'constructor.prototype.hello', 'world');
+    t.is(input.hasOwnProperty('constructor'), false);
+    t.is(input.hasOwnProperty('hello'), false);
+
+    t.deepEqual(input, {
+      // empty
+    });
+  });
+
+  // Test for CVE-2022-25645 - CWE-1321
+  pollution('should ignore JSON.parse crafted object with "__proto__" key', () => {
+    let a: any = { b: { c: 1 } };
+    t.is(a.polluted, undefined);
+    set(a, 'b', JSON.parse('{"__proto__":{"polluted":"Yes!"}}'));
+    t.is(a.polluted, undefined);
+  });
+});
+test('set assigns', (t) => {
+  const assigns = (s: string, f: Function) => {
+    t.log(s);
+    f();
+  };
+  assigns('should add value to key path :: shallow :: string', () => {
+    let input: any = {};
+    set(input, 'abc', 123);
+    t.deepEqual(input, { abc: 123 });
+  });
+
+  assigns('should add value to key path :: shallow :: array', () => {
+    let input: any = {};
+    set(input, ['abc'], 123);
+    t.deepEqual(input, { abc: 123 });
+  });
+
+  assigns('should add value to key path :: nested :: string', () => {
+    let input: any = {};
+    set(input, 'a.b.c', 123);
+    t.deepEqual(input, {
+      a: {
+        b: {
+          c: 123,
+        },
+      },
+    });
+  });
+
+  assigns('should add value to key path :: nested :: array', () => {
+    let input: any = {};
+    set(input, ['a', 'b', 'c'], 123);
+    t.deepEqual(input, {
+      a: {
+        b: {
+          c: 123,
+        },
+      },
+    });
+  });
+
+  assigns('should create Array via integer key :: string', () => {
+    let input: any = {};
+    set(input, ['foo', '0'], 123);
+    t.true(input.foo instanceof Array);
+    t.deepEqual(input, {
+      foo: [123],
+    });
+  });
+
+  assigns('should create Array via integer key :: number', () => {
+    let input: any = {};
+    set(input, ['foo', 0], 123);
+    t.true(input.foo instanceof Array);
+    t.deepEqual(input, {
+      foo: [123],
+    });
+  });
+});
+test('set preserves', (t) => {
+  const preserves = (s: string, f: Function) => {
+    t.log(s);
+    f();
+  };
+  preserves('should preserve existing object structure', () => {
+    let input = {
+      a: {
+        b: {
+          c: 123,
+        },
+      },
+    };
+
+    set(input, 'a.b.x.y', 456);
+
+    t.deepEqual(input, {
+      a: {
+        b: {
+          c: 123,
+          x: {
+            y: 456,
+          },
+        },
+      },
+    });
+  });
+
+  preserves('should overwrite existing non-object values as object', () => {
+    let input = {
+      a: {
+        b: 123,
+      },
+    };
+
+    set(input, 'a.b.c', 'hello');
+
+    t.deepEqual(input, {
+      a: {
+        b: {
+          c: 'hello',
+        },
+      },
+    });
+  });
+
+  preserves('should preserve existing object tree w/ array value', () => {
+    let input = {
+      a: {
+        b: {
+          c: 123,
+          d: {
+            e: 5,
+          },
+        },
+      },
+    };
+
+    set(input, 'a.b.d.z', [1, 2, 3, 4]);
+
+    t.deepEqual(input.a.b.d, {
+      e: 5,
+      z: [1, 2, 3, 4],
+    });
+  });
+});

package/src/objects/set.ts

@@ -0,0 +1,48 @@
+import { ObjectKey, ObjectPath, parseObjectPath } from './parseObjectPath';
+
+/**
+ * Deep set
+ *
+ * {@link https://github.com/lukeed/dset dset}
+ */
+export function set<T extends object, V>(obj: T, key: ObjectKey | ObjectPath, val: V, merging = true) {
+  const path = parseObjectPath(key);
+  let i = 0;
+  const len = path.length;
+  let current: any = obj;
+  let x, k;
+  while (i < len) {
+    k = path[i++];
+    if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
+    // noinspection PointlessArithmeticExpressionJS
+    current = current[k] =
+      i === len
+        ? merging
+          ? merge(current[k], val)
+          : val
+        : typeof (x = current[k]) === typeof path
+        ? x
+        : // @ts-ignore hacky type check
+        path[i] * 0 !== 0 || !!~('' + path[i]).indexOf('.')
+        ? {}
+        : [];
+  }
+}
+
+export function merge(a: any, b: any) {
+  let k;
+  if (typeof a === 'object' && typeof b === 'object') {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      for (k = 0; k < b.length; k++) {
+        a[k] = merge(a[k], b[k]);
+      }
+    } else {
+      for (k in b) {
+        if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
+        a[k] = merge(a[k], b[k]);
+      }
+    }
+    return a;
+  }
+  return b;
+}

package/src/strings/renderTemplate.test.ts

@@ -0,0 +1,25 @@
+import test from 'ava';
+import { renderTemplate } from './renderTemplate';
+
+test('renderTemplate', (t) => {
+  const obj = {
+    name: 'wener',
+    authors: [
+      {
+        name: 'wener',
+      },
+    ],
+  };
+  for (const [k, v] of Object.entries({
+    'My name is ${name}': 'My name is wener',
+    'My name is ${  authors[0].name  }': 'My name is wener',
+  })) {
+    t.is(renderTemplate(k, obj), v);
+  }
+  t.is(
+    renderTemplate('My name is ${name}', (v) => v),
+    'My name is name',
+  );
+  t.is(renderTemplate('My name is ${name}', obj, 'common'), 'My name is ${name}');
+  t.is(renderTemplate('My name is {{name}}', obj, 'common'), 'My name is wener');
+});