@wener/utils 1.1.4 → 1.1.6

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/server/polyfillBrowser.test.ts

@@ -0,0 +1,15 @@
+import test from 'ava';
+import { polyfillBrowser } from './polyfillBrowser';
+
+test.before(async () => {
+  await polyfillBrowser();
+});
+
+test('polyfillBrowser', (t) => {
+  t.truthy(fetch);
+  t.truthy(window);
+  t.truthy(document);
+  t.truthy(crypto);
+  // not the same
+  t.not(window, globalThis);
+});

package/src/server/polyfillBrowser.ts

@@ -0,0 +1,9 @@
+import { polyfillCrypto } from './polyfillCrypto';
+import { polyfillFetch } from './polyfillFetch';
+import { polyfillJsDom } from './polyfillJsDom';
+
+export async function polyfillBrowser() {
+  await polyfillCrypto();
+  await polyfillFetch();
+  await polyfillJsDom();
+}

package/src/server/polyfillCrypto.ts

@@ -0,0 +1,7 @@
+export async function polyfillCrypto() {
+  if ('crypto' in globalThis) {
+    return false;
+  }
+  globalThis.crypto = (await import('node:crypto')).webcrypto as Crypto;
+  return true;
+}

package/src/server/polyfillFetch.ts

@@ -0,0 +1,29 @@
+export async function polyfillFetch() {
+  if ('fetch' in globalThis) {
+    return false;
+  }
+  const {
+    default: fetch,
+    Response,
+    Headers,
+    Request,
+    AbortError,
+    FetchError,
+    FormData,
+    Blob,
+    File,
+    // @ts-ignore
+  } = await import('node-fetch');
+  Object.assign(globalThis, {
+    fetch,
+    Response,
+    Headers,
+    Request,
+    AbortError,
+    FetchError,
+    FormData,
+    Blob,
+    File,
+  });
+  return true;
+}

package/src/server/polyfillJsDom.ts

@@ -0,0 +1,84 @@
+import { ConstructorOptions, ResourceLoaderConstructorOptions } from 'jsdom';
+
+export async function polyfillJsDom() {
+  if (typeof window !== 'undefined') {
+    return false;
+  }
+
+  const { ResourceLoader, JSDOM } = await import('jsdom');
+
+  // https://github.com/lukechilds/window/blob/master/src/index.js
+  class Window {
+    constructor(opts: ResourceLoaderConstructorOptions & ConstructorOptions = {}) {
+      const { proxy, strictSSL, userAgent, ...jsdomOpts } = opts;
+      const resources = new ResourceLoader({
+        proxy,
+        strictSSL,
+        userAgent,
+      });
+      return new JSDOM(
+        '',
+        Object.assign(jsdomOpts, {
+          resources,
+        }),
+      ).window;
+    }
+  }
+
+  // https://github.com/lukechilds/browser-env/blob/master/src/index.js
+  // Default jsdom config.
+  // These settings must override any custom settings to make sure we can iterate
+  // over the window object.
+  const defaultJsdomConfig = {
+    // features: {
+    //   FetchExternalResources: false,
+    //   ProcessExternalResources: false,
+    // },
+  };
+  // IIFE executed on import to return an array of global Node.js properties that
+  // conflict with global browser properties.
+  const protectedProperties = (() =>
+    Object.getOwnPropertyNames(new Window(defaultJsdomConfig)).filter(
+      (prop) => typeof globalThis[prop as keyof typeof globalThis] !== 'undefined',
+    ))();
+
+  function installEnv(...args: any[]) {
+    // Sets up global browser environment
+    // Extract options from args
+    const properties = args.filter((arg: any) => Array.isArray(arg))[0];
+    const userJsdomConfig = args.filter((arg: any) => !Array.isArray(arg))[0];
+
+    // Create window object
+    const window = new Window(Object.assign({}, userJsdomConfig, defaultJsdomConfig));
+
+    // Get all global browser properties
+    Object.getOwnPropertyNames(window)
+
+      // Remove protected properties
+      .filter((prop) => protectedProperties.indexOf(prop) === -1)
+
+      // If we're only applying specific required properties remove everything else
+      .filter((prop) => !(properties && properties.indexOf(prop) === -1))
+      .filter((prop) => {
+        switch (prop) {
+          case 'undefined':
+            return false;
+        }
+        return true;
+      })
+
+      // Copy what's left to the Node.js global scope
+      .forEach((prop) => {
+        // console.debug(`define globalThis.${prop}`);
+        Object.defineProperty(globalThis, prop, {
+          configurable: true,
+          get: () => window[prop as keyof Window] as any,
+        });
+      });
+
+    return window;
+  }
+
+  installEnv({ url: 'http://localhost' });
+  return true;
+}

package/src/server.ts

@@ -1 +1,4 @@
-export { polyfill } from './server/polyfill';
+export { polyfillCrypto } from './server/polyfillCrypto';
+export { polyfillFetch } from './server/polyfillFetch';
+export { polyfillJsDom } from './server/polyfillJsDom';
+export { polyfillBrowser } from './server/polyfillBrowser';

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,34 @@
+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 (!data) {
+    // todo warning in dev
+    getter = () => '';
+  } else 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/src/validations/isUUID.ts

@@ -0,0 +1,3 @@
+export function isUUID(str: string) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str);
+}

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,