@wener/utils 1.1.13 → 1.1.14

package/src/objects/set.test.ts

@@ -1,36 +1,30 @@
 /* eslint no-proto:0 no-prototype-builtins:0 */
-import test from 'ava';
+import { describe, expect, test, it } from 'vitest';
 import { set } from './set';
 
-test('set basics', (t) => {
-  t.is(set({}, 'c', 3), undefined, 'should not give return value');
+test('set basics', () => {
+  expect(set({}, 'c', 3), 'should not give return value').toBe(undefined);
   {
     const item = { foo: 1 };
     set(item, 'bar', 123);
-    t.is(item, item);
-    t.deepEqual(
-      item,
-      {
-        foo: 1,
-        bar: 123,
-      },
-      'should mutate original object',
-    );
+    expect(item, 'should mutate original object').toEqual({
+      foo: 1,
+      bar: 123,
+    });
   }
 });
 
-test('set objects', (t) => {
+describe('set objects', () => {
   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 set = (a: any, b: any, c: any) => {
+      orig(a, b, c, isMerge);
+    };
     const verb = isMerge ? 'merge' : 'overwrite';
-    objects(`should ${verb} existing object value :: simple`, () => {
+    it(`should ${verb} existing object value :: simple`, () => {
       const { input } = prepare({
         hello: { a: 1 },
       });
@@ -38,20 +32,20 @@ test('set objects', (t) => {
       set(input, 'hello', { foo: 123 });
 
       if (isMerge) {
-        t.deepEqual(input, {
+        expect(input).toStrictEqual({
           hello: {
             a: 1,
             foo: 123,
           },
         });
       } else {
-        t.deepEqual(input, {
+        expect(input).toStrictEqual({
           hello: { foo: 123 },
         });
       }
     });
 
-    objects(`should ${verb} existing object value :: nested`, () => {
+    it(`should ${verb} existing object value :: nested`, () => {
       const { input, copy } = prepare({
         a: {
           b: {
@@ -68,22 +62,22 @@ test('set objects', (t) => {
         copy.a.b = { foo: 123 };
       }
 
-      t.deepEqual(input, copy);
+      expect(input).toStrictEqual(copy);
     });
 
-    objects(`should ${verb} existing array value :: simple`, () => {
+    it(`should ${verb} existing array value :: simple`, () => {
       const { input } = prepare([{ foo: 1 }]);
 
       set(input, '0', { bar: 2 });
 
       if (isMerge) {
-        t.deepEqual(input, [{ foo: 1, bar: 2 }]);
+        expect(input).toEqual([{ foo: 1, bar: 2 }]);
       } else {
-        t.deepEqual(input, [{ bar: 2 }]);
+        expect(input).toEqual([{ bar: 2 }]);
       }
     });
 
-    objects(`should ${verb} existing array value :: nested`, () => {
+    it(`should ${verb} existing array value :: nested`, () => {
       const { input } = prepare([
         { name: 'bob', age: 56, friends: ['foobar'] },
         { name: 'alice', age: 47, friends: ['mary'] },
@@ -94,13 +88,13 @@ test('set objects', (t) => {
       set(input, '2', { name: 'mary', age: 49, friends: ['bob'] });
 
       if (isMerge) {
-        t.deepEqual(input, [
+        expect(input).toEqual([
           { name: 'bob', age: 57, friends: ['alice', 'mary'] },
           { name: 'alice', age: 47, friends: ['bob'] },
           { name: 'mary', age: 49, friends: ['bob'] },
         ]);
       } else {
-        t.deepEqual(input, [
+        expect(input).toEqual([
           { age: 57, friends: ['alice', 'mary'] },
           { friends: ['bob'] },
           { name: 'mary', age: 49, friends: ['bob'] },
@@ -113,56 +107,53 @@ test('set objects', (t) => {
   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', () => {
+describe('set arrays', () => {
+  it('should create array instead of object via numeric key :: simple', () => {
     const input: any = { a: 1 };
     set(input, 'e.0', 2);
-    t.true(Array.isArray(input.e));
-    t.is(input.e[0], 2);
-    t.deepEqual(input, {
+    expect(Array.isArray(input.e)).toBeTruthy();
+    expect(input.e[0]).toBe(2);
+    expect(input).toStrictEqual({
       a: 1,
       e: [2],
     });
   });
 
-  arrays('should create array instead of object via numeric key :: nested', () => {
+  it('should create array instead of object via numeric key :: nested', () => {
     const 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, {
+    expect(input.e instanceof Array).toBeTruthy();
+    expect(input.e[0][0]).toBe(123);
+    expect(input).toEqual({
       a: 1,
       e: [[123]],
     });
   });
 
-  arrays('should be able to create object inside of array', () => {
+  it('should be able to create object inside of array', () => {
     const input: any = {};
     set(input, ['x', '0', 'z'], 123);
-    t.true(input.x instanceof Array);
-    t.deepEqual(input, {
+    expect(input.x instanceof Array).toBeTruthy();
+
+    expect(input).toEqual({
       x: [{ z: 123 }],
     });
   });
 
-  arrays('should create arrays with hole(s) if needed', () => {
+  it('should create arrays with hole(s) if needed', () => {
     const input: any = {};
     set(input, ['x', '1', 'z'], 123);
-    t.true(input.x instanceof Array);
-    t.deepEqual(input, {
+    expect(input.x instanceof Array).toBeTruthy();
+    expect(input).toEqual({
       x: [undefined, { z: 123 }],
     });
   });
 
-  arrays('should create object from decimal-like key :: array :: zero :: string', () => {
+  it('should create object from decimal-like key :: array :: zero :: string', () => {
     const input: any = {};
     set(input, ['x', '10.0', 'z'], 123);
-    t.false(input.x instanceof Array);
-    t.deepEqual(input, {
+    expect(input.x instanceof Array).toBeFalsy();
+    expect(input).toEqual({
       x: {
         '10.0': {
           z: 123,
@@ -171,21 +162,21 @@ test('set arrays', (t) => {
     });
   });
 
-  arrays('should create array from decimal-like key :: array :: zero :: number', () => {
+  it('should create array from decimal-like key :: array :: zero :: number', () => {
     const input: any = {};
     set(input, ['x', 10.0, 'z'], 123);
-    t.true(input.x instanceof Array);
+    expect(input.x instanceof Array).toBeTruthy();
 
     const x = Array(10);
     x.push({ z: 123 });
-    t.deepEqual(input, { x });
+    expect(input).toEqual({ x });
   });
 
-  arrays('should create object from decimal-like key :: array :: nonzero', () => {
+  it('should create object from decimal-like key :: array :: nonzero', () => {
     const input: any = {};
     set(input, ['x', '10.2', 'z'], 123);
-    t.false(input.x instanceof Array);
-    t.deepEqual(input, {
+    expect(input.x instanceof Array).toBeFalsy();
+    expect(input).toEqual({
       x: {
         '10.2': {
           z: 123,
@@ -195,55 +186,51 @@ test('set arrays', (t) => {
   });
 });
 
-test('set pollution', (t) => {
-  const pollution = (s: string, f: Function) => {
-    t.log(s);
-    f();
-  };
-  pollution('should protect against "__proto__" assignment', () => {
+describe('set pollution', () => {
+  it('should protect against "__proto__" assignment', () => {
     const input: any = { abc: 123 };
     const before = input.__proto__;
     set(input, '__proto__.hello', 123);
 
-    t.deepEqual(input.__proto__, before);
-    t.deepEqual(input, {
+    expect(input.__proto__).toEqual(before);
+    expect(input).toEqual({
       abc: 123,
     });
   });
 
-  pollution('should protect against "__proto__" assignment :: nested', () => {
+  it('should protect against "__proto__" assignment :: nested', () => {
     const input: any = { abc: 123 };
     const before = input.__proto__;
     set(input, ['xyz', '__proto__', 'hello'], 123);
 
-    t.deepEqual(input.__proto__, before);
-    t.deepEqual(input, {
+    expect(input.__proto__).toEqual(before);
+    expect(input).toEqual({
       abc: 123,
       xyz: {
         // empty
       },
     });
 
-    t.is(input.hello, undefined);
+    expect(input.hello).toBe(undefined);
   });
 
-  pollution('should ignore "prototype" assignment', () => {
+  it('should ignore "prototype" assignment', () => {
     const input: any = { a: 123 };
     set(input, 'a.prototype.hello', 'world');
 
-    t.is(input.a.prototype, undefined);
-    t.is(input.a.hello, undefined);
+    expect(input.a.prototype).toBe(undefined);
+    expect(input.a.hello).toBe(undefined);
 
-    t.deepEqual(input, {
+    expect(input).toEqual({
       a: {
         // converted, then aborted
       },
     });
 
-    t.is(JSON.stringify(input), '{"a":{}}');
+    expect(JSON.stringify(input)).toBe('{"a":{}}');
   });
 
-  pollution('should ignore "constructor" assignment :: direct', () => {
+  it('should ignore "constructor" assignment :: direct', () => {
     const input: any = { a: 123 };
 
     function Custom() {
@@ -251,55 +238,52 @@ test('set pollution', (t) => {
     }
 
     set(input, 'a.constructor', Custom);
-    t.not(input.a.constructor, Custom);
-    t.false(input.a instanceof Custom);
+    expect(input.a.constructor).not.toBe(Custom);
+    expect(input.a instanceof Custom).toBeFalsy();
 
-    t.true(input.a.constructor instanceof Object, '~> 123 -> {}');
-    t.is(input.a.hasOwnProperty('constructor'), false);
-    t.deepEqual(input, { a: {} });
+    expect(input.a.constructor instanceof Object, '~> 123 -> {}').toBeTruthy();
+    expect(input.a.hasOwnProperty('constructor')).toBe(false);
+    expect(input).toEqual({ a: {} });
   });
 
-  pollution('should ignore "constructor" assignment :: nested', () => {
+  it('should ignore "constructor" assignment :: nested', () => {
     const input: any = {};
 
     set(input, 'constructor.prototype.hello', 'world');
-    t.is(input.hasOwnProperty('constructor'), false);
-    t.is(input.hasOwnProperty('hello'), false);
+    expect(input.hasOwnProperty('constructor')).toBe(false);
+    expect(input.hasOwnProperty('hello')).toBe(false);
 
-    t.deepEqual(input, {
+    expect(input).toEqual({
       // empty
     });
   });
 
   // Test for CVE-2022-25645 - CWE-1321
-  pollution('should ignore JSON.parse crafted object with "__proto__" key', () => {
+  it('should ignore JSON.parse crafted object with "__proto__" key', () => {
     const a: any = { b: { c: 1 } };
-    t.is(a.polluted, undefined);
+    expect(a.polluted).toBe(undefined);
     set(a, 'b', JSON.parse('{"__proto__":{"polluted":"Yes!"}}'));
-    t.is(a.polluted, undefined);
+    expect(a.polluted).toBe(undefined);
   });
 });
-test('set assigns', (t) => {
-  const assigns = (s: string, f: Function) => {
-    t.log(s);
-    f();
-  };
-  assigns('should add value to key path :: shallow :: string', () => {
+
+describe('set assigns', () => {
+  it('should add value to key path :: shallow :: string', () => {
     const input: any = {};
     set(input, 'abc', 123);
-    t.deepEqual(input, { abc: 123 });
+    expect(input).toEqual({ abc: 123 });
   });
 
-  assigns('should add value to key path :: shallow :: array', () => {
+  it('should add value to key path :: shallow :: array', () => {
     const input: any = {};
     set(input, ['abc'], 123);
-    t.deepEqual(input, { abc: 123 });
+    expect(input).toEqual({ abc: 123 });
   });
 
-  assigns('should add value to key path :: nested :: string', () => {
+  it('should add value to key path :: nested :: string', () => {
     const input: any = {};
     set(input, 'a.b.c', 123);
-    t.deepEqual(input, {
+    expect(input).toEqual({
       a: {
         b: {
           c: 123,
@@ -308,10 +292,10 @@ test('set assigns', (t) => {
     });
   });
 
-  assigns('should add value to key path :: nested :: array', () => {
+  it('should add value to key path :: nested :: array', () => {
     const input: any = {};
     set(input, ['a', 'b', 'c'], 123);
-    t.deepEqual(input, {
+    expect(input).toEqual({
       a: {
         b: {
           c: 123,
@@ -320,30 +304,27 @@ test('set assigns', (t) => {
     });
   });
 
-  assigns('should create Array via integer key :: string', () => {
+  it('should create Array via integer key :: string', () => {
     const input: any = {};
     set(input, ['foo', '0'], 123);
-    t.true(input.foo instanceof Array);
-    t.deepEqual(input, {
+    expect(input.foo instanceof Array).toBeTruthy();
+    expect(input).toEqual({
       foo: [123],
     });
   });
 
-  assigns('should create Array via integer key :: number', () => {
+  it('should create Array via integer key :: number', () => {
     const input: any = {};
     set(input, ['foo', 0], 123);
-    t.true(input.foo instanceof Array);
-    t.deepEqual(input, {
+    expect(input.foo instanceof Array).toBeTruthy();
+    expect(input).toEqual({
       foo: [123],
     });
   });
 });
-test('set preserves', (t) => {
-  const preserves = (s: string, f: Function) => {
-    t.log(s);
-    f();
-  };
-  preserves('should preserve existing object structure', () => {
+
+describe('set preserves', () => {
+  it('should preserve existing object structure', () => {
     const input = {
       a: {
         b: {
@@ -354,7 +335,7 @@ test('set preserves', (t) => {
 
     set(input, 'a.b.x.y', 456);
 
-    t.deepEqual(input, {
+    expect(input).toEqual({
       a: {
         b: {
           c: 123,
@@ -366,7 +347,7 @@ test('set preserves', (t) => {
     });
   });
 
-  preserves('should overwrite existing non-object values as object', () => {
+  it('should overwrite existing non-object values as object', () => {
     const input = {
       a: {
         b: 123,
@@ -375,7 +356,7 @@ test('set preserves', (t) => {
 
     set(input, 'a.b.c', 'hello');
 
-    t.deepEqual(input, {
+    expect(input).toEqual({
       a: {
         b: {
           c: 'hello',
@@ -384,7 +365,7 @@ test('set preserves', (t) => {
     });
   });
 
-  preserves('should preserve existing object tree w/ array value', () => {
+  it('should preserve existing object tree w/ array value', () => {
     const input = {
       a: {
         b: {
@@ -398,7 +379,7 @@ test('set preserves', (t) => {
 
     set(input, 'a.b.d.z', [1, 2, 3, 4]);
 
-    t.deepEqual(input.a.b.d, {
+    expect(input.a.b.d).toEqual({
       e: 5,
       z: [1, 2, 3, 4],
     });

package/src/server.ts

@@ -2,4 +2,6 @@ export { polyfillCrypto } from './servers/polyfillCrypto';
 export { polyfillFetch } from './servers/polyfillFetch';
 export { polyfillJsDom } from './servers/polyfillJsDom';
 export { polyfillBrowser } from './servers/polyfillBrowser';
-export { createProxyFetch } from './servers/createProxyFetch';
+export { createFetchWithProxyByNodeFetch } from './servers/createFetchWithProxyByNodeFetch';
+export { createFetchWithProxyByUndici } from './servers/createFetchWithProxyByUndici';
+export { createFetchWithProxy } from './servers/createFetchWithProxy';

package/src/servers/createFetchWithLogger.ts

@@ -0,0 +1,75 @@
+import { FetchLike } from '../fetch';
+
+export function createFetchWithLogger({
+  fetch = globalThis.fetch,
+  logger = console.log,
+}: {
+  fetch?: FetchLike;
+  logger?: (s: string) => void;
+} = {}): FetchLike {
+  return async (...args) => {
+    const [, init = { method: 'GET', headers: {} } as RequestInit] = args;
+    const url = typeof args[0] === 'string' ? args[0] : args[0].url;
+
+    let dumpRequest = `-> ${init.method} ${url}
+${Array.from(new Headers(init.headers).entries())
+  .map(([k, v]) => `${k}: ${v}`)
+  .join('\n')}
+`;
+
+    if (init.body) {
+      if (init.body instanceof ReadableStream) {
+        const [a, b] = init.body.tee();
+        init.body = a;
+        const signal = init.signal;
+        Promise.resolve().then(async () => {
+          const reader = b.getReader();
+          logger(dumpRequest);
+          while (true) {
+            if (signal?.aborted) {
+              break;
+            }
+
+            let { done, value } = await reader.read();
+            value instanceof Uint8Array && (value = new TextDecoder().decode(value));
+            dumpRequest += value;
+            logger(value);
+            if (!done) {
+              break;
+            }
+          }
+          // maybe for archive
+          dumpRequest += `\n`;
+        });
+      } else {
+        dumpRequest += `
+${init.body}
+`;
+      }
+    }
+    console.log(dumpRequest);
+
+    try {
+      let res = await fetch(...args);
+      let dumpResponse = `<- ${res.status} ${res.statusText} ${init.method} ${url}
+  ${Array.from(res.headers.entries())
+    .map(([k, v]) => `${k}: ${v}`)
+    .join('\n')}
+   `;
+      let contentType = res.headers.get('content-type');
+      // text/event-stream
+      if (contentType?.includes('application/json') || contentType?.includes('text/plain')) {
+        const body = await res.text();
+        dumpResponse += `\n${body}\n`;
+        res = new Response(body, res);
+      }
+
+      logger(dumpResponse);
+
+      return res;
+    } catch (e) {
+      console.error(`[Error] -> ${init.method} ${url} :${e}`);
+      throw e;
+    }
+  };
+}

package/src/servers/createFetchWithProxy.ts

@@ -0,0 +1,12 @@
+import { FetchLike } from '../fetch';
+import { createFetchWithProxyByNodeFetch } from '../server';
+import { createFetchWithProxyByUndici } from './createFetchWithProxyByUndici';
+
+export function createFetchWithProxy({ proxy, fetch }: { proxy?: string; fetch?: FetchLike }): FetchLike {
+  if (!proxy) {
+    return fetch || globalThis.fetch;
+  }
+  return parseInt(process.versions.node) >= 18
+    ? createFetchWithProxyByUndici({ proxy, fetch })
+    : createFetchWithProxyByNodeFetch({ proxy, fetch });
+}

package/src/servers/{createProxyFetch.ts → createFetchWithProxyByNodeFetch.ts}

@@ -1,7 +1,10 @@
 import { type FetchLike } from '../fetch';
 import { globalThis } from '../isomorphics/globalThis';
 
-export function createProxyFetch(proxy?: string, fetch?: FetchLike): FetchLike {
+export function createFetchWithProxyByNodeFetch({
+  proxy,
+  fetch,
+}: { proxy?: string; fetch?: FetchLike } = {}): FetchLike {
   if (!proxy) {
     return fetch || globalThis.fetch;
   }

package/src/servers/createFetchWithProxyByUndici.ts

@@ -0,0 +1,36 @@
+import { MaybePromise } from 'rollup';
+import { FetchLike } from '../fetch';
+
+export function createFetchWithProxyByUndici({
+  proxy,
+  fetch,
+  undici,
+}: {
+  proxy?: string;
+  fetch?: FetchLike;
+  undici?: MaybePromise<{ fetch: any; ProxyAgent: any }>;
+} = {}): FetchLike {
+  if (!proxy) {
+    return fetch || globalThis.fetch;
+  }
+  let agent: any;
+  return async (...args) => {
+    const init: RequestInit & { duplex?: string; dispatcher?: any } = (args[1] ||= {});
+    if (init.body instanceof ReadableStream) {
+      // https://github.com/nodejs/node/issues/46221
+      init.duplex ||= 'half';
+    }
+    if (!agent) {
+      // if in next use 'next/dist/compiled/undici'
+      undici ||= import('undici');
+      const mod = await undici;
+      const ProxyAgent = mod.ProxyAgent;
+      fetch ||= mod.fetch;
+      agent = new ProxyAgent(proxy);
+      // https://github.com/nodejs/node/issues/43187#issuecomment-1134634174
+      // (global as any)[Symbol.for('undici.globalDispatcher.1')] = agent;
+    }
+    init.dispatcher = agent;
+    return await fetch!(...args);
+  };
+}

package/src/servers/polyfillBrowser.test.ts

@@ -1,20 +1,20 @@
-import test from 'ava';
 import * as nodeFetch from 'node-fetch';
+import { test, expect, beforeAll } from 'vitest';
 import { polyfillBrowser } from './polyfillBrowser';
 import { polyfillFetch } from './polyfillFetch';
 
-test.before(async (t) => {
+beforeAll(async () => {
   // return false in nodejs18
   polyfillFetch(nodeFetch);
-  t.false(polyfillFetch());
+  expect(polyfillFetch()).toBeFalsy();
   await polyfillBrowser();
 });
 
-test('polyfillBrowser', (t) => {
-  t.truthy(fetch);
-  t.truthy(window);
-  t.truthy(document);
-  t.truthy(crypto);
+test('polyfillBrowser', () => {
+  expect(fetch).toBeTruthy();
+  expect(window).toBeTruthy();
+  expect(document).toBeTruthy();
+  expect(crypto).toBeTruthy();
   // not the same
-  t.not(window, globalThis);
+  expect(window).not.toBe(globalThis);
 });

package/src/strings/renderTemplate.test.ts

@@ -1,8 +1,8 @@
 /* eslint no-template-curly-in-string:0 */
-import test from 'ava';
+import { expect, test } from 'vitest';
 import { renderTemplate } from './renderTemplate';
 
-test('renderTemplate', (t) => {
+test('renderTemplate', () => {
   const obj = {
     name: 'wener',
     authors: [
@@ -15,12 +15,9 @@ test('renderTemplate', (t) => {
     'My name is ${name}': 'My name is wener',
     'My name is ${  authors[0].name  }': 'My name is wener',
   })) {
-    t.is(renderTemplate(k, obj), v);
+    expect(renderTemplate(k, obj)).toBe(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');
+  expect(renderTemplate('My name is ${name}', (v) => v)).toBe('My name is name');
+  expect(renderTemplate('My name is ${name}', obj, 'common')).toBe('My name is ${name}');
+  expect(renderTemplate('My name is {{name}}', obj, 'common')).toBe('My name is wener');
 });