@wener/utils 1.1.3 → 1.1.5

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

package/src/strings/renderTemplate.ts

@@ -0,0 +1,31 @@
+import { get } from '../objects/get';
+
+/**
+ * 替换类似于 JS 的模板字符串
+ *
+ *   templateString('My name is ${name}',{name:'wener'}) // => 'My name is wener'
+ *
+ */
+export function renderTemplate(
+  template: string,
+  data: ((v: string) => any) | object,
+  match: 'js' | 'common' | RegExp = 'js',
+) {
+  let getter: Function;
+  if (typeof data === 'function') {
+    getter = data;
+  } else {
+    getter = (v: string) => get(data, v);
+  }
+  if (typeof match === 'string') {
+    match = Matches[match] || Matches['js'];
+  }
+  return template.replace(match, (_, g) => {
+    return getter(g.trim());
+  });
+}
+
+const Matches = {
+  js: /\${(.*?)}/g,
+  common: /{{(.*?)}}/g,
+};

package/tsconfig.json

@@ -11,12 +11,8 @@
     "strict": true,
     "sourceMap": true,
     "skipLibCheck": true,
-    "declaration": false,
     "esModuleInterop": true,
-    "importHelpers": true,
     "allowSyntheticDefaultImports": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
     "noImplicitAny": true,
     "noImplicitReturns": true,
     "noUnusedLocals": true,

package/lib/strings/templates.js

@@ -1,8 +0,0 @@
-function templateString(template, getter) {
-  return template.replace(/\${(.*?)}/g, (_, g) => {
-    return getter(g.trim());
-  });
-}
-
-export { templateString };
-//# sourceMappingURL=templates.js.map

package/lib/strings/templates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"templates.js","sources":["../../src/strings/templates.ts"],"sourcesContent":["/**\n * 替换类似于 JS 的模板字符串\n *\n * @example\n * templateString('My name is ${name}',{name:'wener'})\n */\nexport function templateString(template: string, getter: (v: string) => any) {\n  return template.replace(/\\${(.*?)}/g, (_, g) => {\n    // variables[g.trim()]\n    // 支持路径 - 例如 a.b[0]\n    return getter(g.trim());\n  });\n}\n"],"names":[],"mappings":"AAMgB,SAAA,cAAA,CAAe,UAAkB,MAA4B,EAAA;AAC3E,EAAA,OAAO,QAAS,CAAA,OAAA,CAAQ,YAAc,EAAA,CAAC,GAAG,CAAM,KAAA;AAG9C,IAAO,OAAA,MAAA,CAAO,CAAE,CAAA,IAAA,EAAM,CAAA,CAAA;AAAA,GACvB,CAAA,CAAA;AACH;;;;"}

package/src/strings/templates.ts

@@ -1,13 +0,0 @@
-/**
- * 替换类似于 JS 的模板字符串
- *
- * @example
- * templateString('My name is ${name}',{name:'wener'})
- */
-export function templateString(template: string, getter: (v: string) => any) {
-  return template.replace(/\${(.*?)}/g, (_, g) => {
-    // variables[g.trim()]
-    // 支持路径 - 例如 a.b[0]
-    return getter(g.trim());
-  });
-}