@wener/utils 1.1.4 → 1.1.6

package/src/asyncs/createLazyPromise.test.ts

@@ -0,0 +1,39 @@
+import test from 'ava';
+import { createLazyPromise } from './createLazyPromise';
+import { sleep } from './sleep';
+
+test('basic', async (t) => {
+  let promise = createLazyPromise();
+  let r = 0;
+  promise.then((v) => (r = v));
+  t.is(r, 0);
+  const { resolve, reject } = promise;
+  t.truthy(resolve);
+  t.truthy(reject);
+  resolve(1);
+  t.is(r, 0);
+  await promise;
+  t.is(r, 1);
+});
+
+test('manual resolve skip exec', async (t) => {
+  let promise = createLazyPromise(() => {
+    t.fail();
+  });
+  promise.resolve(-1);
+  t.is(await promise, -1);
+});
+
+test('exec', async (t) => {
+  let r = 0;
+  let promise = createLazyPromise((resolve) => {
+    r++;
+    resolve(10);
+  });
+  await sleep(10);
+  t.is(r, 0);
+  t.is(await promise, 10);
+  t.is(r, 1);
+  promise.resolve(20);
+  t.is(await promise, 10);
+});

package/src/asyncs/createLazyPromise.ts

@@ -0,0 +1,63 @@
+export type LazyPromise<T> = Promise<T> & {
+  reject(reason?: any): void;
+  resolve(v?: T | PromiseLike<T>): void;
+};
+
+/**
+ * createLazyPromise return a promise that can be resolved or rejected manually.
+ * if you pass a function to it, it will be executed when the promise try to resolve.
+ */
+export function createLazyPromise<T = any>(
+  executor?: (resolve: LazyPromise<T>['resolve'], reject: LazyPromise<T>['reject']) => void,
+): LazyPromise<T> {
+  const holder = {
+    resolve(_: any): void {
+      throw new Error('pending resolve');
+    },
+    reject(_: any): void {
+      throw new Error('pending reject');
+    },
+  };
+  let future = Object.assign(
+    new Promise<T>((resolve, reject) => {
+      holder.reject = reject;
+      holder.resolve = resolve;
+    }),
+    {
+      resolve(v: any) {
+        holder.resolve(v);
+      },
+      reject(v: any) {
+        holder.resolve(v);
+      },
+    },
+  );
+  if (executor) {
+    const r = holder.resolve;
+    let shouldExec = true;
+    holder.resolve = (v: any) => {
+      shouldExec = false;
+      r(v);
+    };
+    const then = future.then.bind(future);
+    future.then = (...args) => {
+      if (shouldExec) {
+        shouldExec = false;
+        executor(holder.resolve, holder.reject);
+      }
+      return then(...args);
+    };
+    const like = holder as LazyPromise<T>;
+    like.then = future.then;
+    like.catch = future.catch.bind(future);
+    if (future.finally) like.finally = future.finally;
+
+    Object.defineProperty(like, Symbol.species, {
+      get() {
+        return Promise;
+      },
+    });
+    return like;
+  }
+  return future;
+}

package/src/crypto/hashing.test.ts

@@ -1,13 +1,12 @@
 import test from 'ava';
+import { polyfillCrypto } from '../server/polyfillCrypto';
+import { isUUID } from '../validations/isUUID';
 import { sha1, sha256, sha384, sha512 } from './hashing';
 import { hex } from './hex';
-import { randomUUID } from './randomUUID';
+import { _randomUUID } from './randomUUID';
 
-test.before(async (t) => {
-  if (!('crypto' in globalThis)) {
-    (globalThis as any).crypto = (await import('node:crypto')).webcrypto;
-    t.log(`load node:crypto`);
-  }
+test.before(async () => {
+  await polyfillCrypto();
 });
 
 test('sha', async (t) => {
@@ -22,5 +21,10 @@ test('sha', async (t) => {
     hex(await sha512('')),
     'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e',
   );
-  t.regex(randomUUID(), /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+});
+
+test('randomUUID', (t) => {
+  for (let i = 0; i < 20; i++) {
+    t.true(isUUID(_randomUUID()));
+  }
 });

package/src/crypto/randomUUID.ts

@@ -1,10 +1,9 @@
 /**
  * generate random UUIDv4
  */
-export function randomUUID() {
-  if ('randomUUID' in crypto) {
-    return crypto.randomUUID();
-  }
+export const randomUUID: () => string = globalThis.crypto?.randomUUID || _randomUUID;
+
+export function _randomUUID() {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
     const r = (Math.random() * 16) | 0;
     const v = c === 'x' ? r : (r & 0x3) | 0x8;

package/src/i18n/createTranslate.test.ts

@@ -0,0 +1,155 @@
+import test from 'ava';
+import { createTranslate } from './createTranslate';
+
+test('exports', (t) => {
+  let out = createTranslate();
+  t.is(typeof out, 'object', 'returns an object');
+  t.is(typeof out.t, 'function', '~> has "t" function');
+  t.is(typeof out.dict, 'function', '~> has "set" function');
+  t.is(typeof out.locale, 'function', '~> has "locale" function');
+});
+
+test('usage', (t) => {
+  let ctx = createTranslate({
+    en: { hello: 'Hello, {{name}}!' },
+    es: { hello: 'Hola {{name}}!' },
+    pt: { foo: 'foo {{name}}~!' },
+  });
+
+  t.deepEqual(ctx.dict('en'), { hello: 'Hello, {{name}}!' });
+
+  t.is(ctx.dict('foobar'), undefined);
+
+  let foo = ctx.t('hello');
+  t.is(foo, '', '~> "" w/o locale');
+
+  t.is(ctx.locale('en'), 'en', '>>> ctx.locale()');
+
+  t.is(ctx.locale(), 'en');
+
+  let bar = ctx.t('hello');
+  t.not(bar, '', '(en) found "hello" key');
+  t.is(bar, 'Hello, !', '~> interpolations empty if missing param');
+
+  let baz = ctx.t('hello', { name: 'world' });
+  t.is(baz, 'Hello, world!', '~> interpolations successful');
+
+  let bat = ctx.t('hello', { name: 'world' }, 'es');
+  t.not(bat, '', '(es) found "hello" key');
+  t.is(bat, 'Hola world!', '~> success');
+
+  t.is(ctx.t('hello', { name: 'world' }, 'pt'), '', '(pt) did NOT find "hello" key');
+
+  t.is(ctx.dict('pt', { hello: 'Oí {{name}}!' }), undefined, '>>> ctx.dict()');
+
+  let quz = ctx.t('hello', { name: 'world' }, 'pt');
+  t.not(quz, '', '(pt) found "hello" key');
+  t.is(quz, 'Oí world!', '~> success');
+
+  let qut = ctx.t('foo', { name: 'bar' }, 'pt');
+  t.not(qut, '', '(pt) found "foo" key');
+  t.is(qut, 'foo bar~!', '~> success');
+
+  t.is(ctx.locale('es'), 'es', '>>> ctx.locale()');
+
+  t.is(ctx.locale(), 'es');
+  t.is(ctx.locale(''), 'es');
+  t.is(ctx.locale(false as any), 'es');
+  t.is(ctx.locale(null as any), 'es');
+  t.is(ctx.locale(0 as any), 'es');
+
+  let qux = ctx.t('hello', { name: 'default' });
+  t.not(qux, '', '(es) found "hello" key');
+  t.is(qux, 'Hola default!', '~> success');
+
+  t.is(ctx.t('hello', { name: 'world' }, 'de'), '', '(de) did NOT find "hello" key');
+
+  t.is(ctx.dict('de', { hello: 'Hallo {{name}}!' }), undefined, '>>> ctx.dict(de)');
+
+  let qar = ctx.t('hello', { name: 'world' }, 'de');
+  t.not(qar, '', '(de) found "hello" key');
+  t.is(qar, 'Hallo world!', '~> success');
+});
+
+test('functional', (t) => {
+  let ctx = createTranslate({
+    en: {
+      hello(value: any) {
+        return `hello ${value || 'stranger'}~!`;
+      },
+    },
+  });
+
+  ctx.locale('en');
+
+  let foo = ctx.t('hello');
+  t.is(foo, 'hello stranger~!', '~> called function w/o param');
+
+  let bar = ctx.t('hello', 'world' as any);
+  t.is(bar, 'hello world~!', '~> called function w/ param (string)');
+
+  let baz = ctx.t('hello', [1, 2, 3]);
+  t.is(baz, 'hello 1,2,3~!', '~> called function w/ param (array)');
+});
+
+test('nested', (t) => {
+  let ctx = createTranslate({
+    en: {
+      fruits: {
+        apple: 'apple',
+        orange: 'orange',
+        grape: 'grape',
+      },
+    },
+    es: {
+      fruits: {
+        apple: 'manzana',
+        orange: 'naranja',
+        grape: 'uva',
+      },
+    },
+  });
+
+  ctx.locale('en');
+  t.is(ctx.t('fruits.apple'), 'apple', '(en) fruits.apple');
+  t.is(ctx.t('fruits.orange'), 'orange', '(en) fruits.orange');
+  t.is(ctx.t(['fruits', 'grape']), 'grape', '(en) ["fruits","grape"]');
+  t.is(ctx.t('fruits.404'), '', '(en) fruits.404 ~> ""');
+  t.is(ctx.t('error.404'), '', '(en) error.404 ~> ""');
+
+  ctx.locale('es');
+  t.is(ctx.t('fruits.apple'), 'manzana', '(es) fruits.apple');
+  t.is(ctx.t('fruits.orange'), 'naranja', '(es) fruits.orange');
+  t.is(ctx.t(['fruits', 'grape']), 'uva', '(es) ["fruits","grape"]');
+  t.is(ctx.t('fruits.404'), '', '(es) fruits.404 ~> ""');
+  t.is(ctx.t('error.404'), '', '(es) error.404 ~> ""');
+});
+
+test('arrays', (t) => {
+  let ctx = createTranslate({
+    en: {
+      foo: '{{0}} + {{1}} = {{2}}',
+      bar: [
+        {
+          baz: 'roses are {{colors.0}}, violets are {{colors.1}}',
+        },
+      ],
+    },
+  });
+
+  ctx.locale('en');
+
+  t.is(ctx.t('foo', [1, 2, 3]), '1 + 2 = 3', '~> foo');
+
+  t.is(ctx.t('bar.0.baz', { colors: ['red', 'blue'] }), 'roses are red, violets are blue', '~> bar.0.baz');
+});
+
+test('invalid value', (t) => {
+  let ctx = createTranslate({
+    en: {
+      foo: ['bar'],
+    },
+  });
+
+  t.deepEqual(ctx.t('foo', null as any, 'en'), ['bar']);
+});

package/src/i18n/createTranslate.ts

@@ -0,0 +1,52 @@
+import { get } from '../objects/get';
+import { ObjectPathLike } from '../objects/parseObjectPath';
+import { renderTemplate } from '../strings/renderTemplate';
+
+export interface Translate<T extends object> {
+  /** Get/Set the language key */
+  locale(lang?: string): string;
+
+  /** Define the dict of translations for a language */
+  dict(lang: string, dict: T): void;
+
+  /** Get the dict of translations for a language */
+  dict(lang: string): T;
+
+  /** Retrieve a translation segment for the current language */
+  t<X extends Record<string, any> | any[]>(key: ObjectPathLike, params?: X, lang?: string): string;
+}
+
+export function createTranslate<T extends object>(obj?: Record<string, T>): Translate<T> {
+  let locale = '';
+  const tree = obj || {};
+
+  return {
+    locale(lang) {
+      return (locale = lang || locale);
+    },
+
+    dict: ((lang, dict?) => {
+      if (dict) {
+        tree[lang] = Object.assign(tree[lang] || {}, dict);
+        return;
+      }
+      return tree[lang];
+    }) as Translate<T>['dict'],
+
+    t(key, params, lang) {
+      const val = get(tree[lang || locale], key, '') as any;
+      if (process.env.NODE_ENV === 'development') {
+        if (val == null) {
+          return console.error(
+            `[Translate] Missing the "${[].concat(key as any).join('.')}" key within the "${
+              lang || locale
+            }" dictionary`,
+          );
+        }
+      }
+      if (typeof val === 'function') return val(params);
+      if (typeof val === 'string') return renderTemplate(val, params!, 'common');
+      return val;
+    },
+  };
+}

package/src/index.ts

@@ -7,8 +7,13 @@ 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 { createLazyPromise, type LazyPromise } from './asyncs/createLazyPromise';
 export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval';
 export { type MaybePromise } from './asyncs/MaybePromise';
 
@@ -21,12 +26,15 @@ export { isPromise } from './asyncs/isPromise';
 export { isClass } from './validations/isClass';
 export { isDefined } from './validations/isDefined';
 export { isEmptyObject } from './validations/isEmptyObject';
-export { shallow } from './validations/shallow';
-export { dequal } from './validations/dequal';
+export { shallowEqual } from './langs/shallowEqual';
+export { deepEqual } from './langs/deepEqual';
+export { isUUID } from './validations/isUUID';
+
+export { classOf } from './langs/classOf';
 
 // modules
 export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
-export { isModule } from './modules/isModule';
+export { isModule, type Module } from './modules/isModule';
 
 // logging
 export { type Logger, type LogLevel } from './logging/Logger';
@@ -36,22 +44,31 @@ export { createChildLogger } from './logging/createChildLogger';
 
 // strings
 export { pascalCase, camelCase } from './strings/camelCase';
-export { templateString } from './strings/templates';
+export { renderTemplate } from './strings/renderTemplate';
+export { formatBytes } from './strings/formatBytes';
 
-export { createRandom } from './maths/random';
+// i18n
+export { createTranslate } from './i18n/createTranslate';
+
+// io
 export { isBuffer } from './io/isBuffer';
+export { isTransferable } from './io/isTransferable';
 
+// browser
 export { copy } from './browsers/copy';
 export { download } from './browsers/download';
 export { loadScripts, loadStyles } from './browsers/loaders';
 export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer';
 
+// polyfills
 export { getGlobalThis } from './isomorphics/getGlobalThis';
-
-export { formatBytes } from './formats/formatBytes';
-export { urljoin } from './shim/urljoin';
+export { structuredClone } from './isomorphics/structuredClone';
 
 // crypto
 export { randomUUID } from './crypto/randomUUID';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
 export { hex } from './crypto/hex';
+
+// misc
+export { createRandom } from './maths/random';
+export { urljoin } from './shim/urljoin';

package/src/io/isBuffer.test.ts

@@ -0,0 +1,7 @@
+import test from 'ava';
+import { Buffer } from 'node:buffer';
+import { isBuffer } from './isBuffer';
+
+test('isBuffer', (t) => {
+  t.true(isBuffer(Buffer.from('')));
+});

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/io/isTransferable.test.ts

@@ -0,0 +1,10 @@
+import test from 'ava';
+import { Buffer } from 'node:buffer';
+import { isTransferable } from './isTransferable';
+
+test('isTransferable', (t) => {
+  t.false(isTransferable(0));
+  t.false(isTransferable(Buffer.from('')));
+  t.true(new ArrayBuffer(0) instanceof ArrayBuffer);
+  t.true(isTransferable(new ArrayBuffer(0)));
+});

package/src/io/isTransferable.ts

@@ -0,0 +1,50 @@
+/**
+ * transferable object pass between workers, can work with structuredClone
+ *
+ * - Chrome 87, FF 103, Safari X, NodeJS X
+ *
+ * {@link https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects | Transferable objects}
+ */
+export function isTransferable(v: any): v is TransferableObject {
+  _ctors ||= ctors();
+  return _ctors.some((ctor) => v instanceof ctor);
+}
+
+let _ctors: any[];
+
+function ctors() {
+  const o: any = globalThis.window || globalThis || global;
+  return [
+    o.ArrayBuffer,
+    o.MessagePort,
+    o.ReadableStream,
+    o.WritableStream,
+    o.TransformStream,
+    o.AudioData,
+    o.ImageBitmap,
+    o.VideoFrame,
+    o.OffscreenCanvas,
+    o.RTCDataChannel,
+  ].filter(Boolean);
+}
+
+export type TransferableObject =
+  | Transferable
+  | ArrayBuffer
+  | MessagePort
+  | ReadableStream
+  | WritableStream
+  | TransformStream
+  | AudioData
+  | ImageBitmap
+  | VideoFrame
+  | OffscreenCanvas
+  | RTCDataChannel;
+
+declare global {
+  interface OffscreenCanvas {}
+
+  interface VideoFrame {}
+
+  interface AudioData {}
+}

package/src/isomorphics/structuredClone.test.ts

@@ -0,0 +1,14 @@
+import test from 'ava';
+import { classOf } from '../langs/classOf';
+import { _clone } from './structuredClone';
+
+test('structuredClone', (t) => {
+  for (const [k, v] of [
+    ['', ''],
+    [Number(1), 1],
+  ]) {
+    let c = _clone(k);
+    t.deepEqual(c, v);
+    t.is(classOf(c), classOf(v));
+  }
+});

package/src/isomorphics/structuredClone.ts

@@ -0,0 +1,85 @@
+/**
+ * Chrome 98, Safari 15.4
+ *
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone}
+ * {@link https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/web.structured-clone.js core-js}
+ */
+import { classOf } from '../langs/classOf';
+
+export const structuredClone: <T>(value: T, options?: StructuredSerializeOptions) => T =
+  globalThis.structuredClone || _clone;
+
+function set(obj: any, key: any, val: any) {
+  if (typeof val.value === 'object') val.value = _clone(val.value);
+  if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {
+    Object.defineProperty(obj, key, val);
+  } else obj[key] = val.value;
+}
+
+/**
+ * {@link https://github.com/lukeed/klona/blob/master/src/full.js klona}
+ */
+export function _clone(x: any): any {
+  // too complex
+  // https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/web.structured-clone.js
+
+  if (typeof x !== 'object') return x;
+
+  let i = 0;
+  let k;
+  let list;
+  let tmp: any;
+  const str = classOf(x);
+  switch (str) {
+    case 'Array':
+      tmp = Array(x.length);
+      break;
+    case 'Object':
+      tmp = Object.create(x.__proto__ || null);
+      break;
+    case 'Set':
+      tmp = new Set();
+      x.forEach(function (val: any) {
+        tmp.add(_clone(val));
+      });
+      break;
+    case 'Map':
+      tmp = new Map();
+      x.forEach(function (val: any, key: any) {
+        tmp.set(_clone(key), _clone(val));
+      });
+      break;
+    case 'Date':
+      tmp = new Date(+x);
+      break;
+    case 'RegExp':
+      tmp = new RegExp(x.source, x.flags);
+      break;
+    case 'DataView':
+      tmp = new x.constructor(_clone(x.buffer));
+      break;
+    case 'ArrayBuffer':
+      tmp = x.slice(0);
+      break;
+    default:
+      // typed arrays
+      if (str.endsWith('Array')) {
+        // ArrayBuffer.isView(x)
+        // ~> `new` bcuz `Buffer.slice` => ref
+        tmp = new x.constructor(x);
+      }
+  }
+
+  if (tmp) {
+    for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) {
+      set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
+    }
+
+    for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
+      if (Object.hasOwnProperty.call(tmp, (k = list[i])) && tmp[k] === x[k]) continue;
+      set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
+    }
+  }
+
+  return tmp || x;
+}

package/src/langs/classOf.ts

@@ -0,0 +1,3 @@
+export function classOf(o: any) {
+  return Object.prototype.toString.call(o).slice(8, -1);
+}

package/src/{validations/dequal.test.ts → langs/deepEqual.test.ts}

@@ -1,9 +1,9 @@
 import test from 'ava';
-import { dequal } from './dequal';
+import { deepEqual } from './deepEqual';
 
 test('deep equal', (t) => {
   t.true(
-    dequal(
+    deepEqual(
       {
         a: null,
         b: Infinity,

package/src/{validations/dequal.ts → langs/deepEqual.ts}

@@ -3,7 +3,7 @@ const hasElementType = typeof Element !== 'undefined';
 
 function find(iter: any, tar: any, key?: any) {
   for (key of iter.keys()) {
-    if (dequal(key, tar)) return key;
+    if (deepEqual(key, tar)) return key;
   }
 }
 
@@ -12,7 +12,7 @@ function find(iter: any, tar: any, key?: any) {
  * @see {@link https://github.com/lukeed/dequal/blob/master/src/lite.js dequal/src/lite.js}
  * @see {@link https://github.com/FormidableLabs/react-fast-compare/blob/master/index.js react-fast-compare/index.js}
  */
-export function dequal(foo: any, bar: any) {
+export function deepEqual(foo: any, bar: any) {
   let ctor, len, tmp;
   if (foo === bar) return true;
 
@@ -22,7 +22,7 @@ export function dequal(foo: any, bar: any) {
 
     if (ctor === Array) {
       if ((len = foo.length) === bar.length) {
-        while (len-- && dequal(foo[len], bar[len]));
+        while (len-- && deepEqual(foo[len], bar[len]));
       }
       return len === -1;
     }
@@ -52,7 +52,7 @@ export function dequal(foo: any, bar: any) {
           tmp = find(bar, tmp);
           if (!tmp) return false;
         }
-        if (!dequal(len[1], bar.get(tmp))) {
+        if (!deepEqual(len[1], bar.get(tmp))) {
           return false;
         }
       }
@@ -95,7 +95,7 @@ export function dequal(foo: any, bar: any) {
         }
 
         if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor])) return false;
       }
       return Object.keys(bar).length === len;
     }