@wener/utils 1.1.5 → 1.1.6

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

@@ -13,7 +13,7 @@ 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';
 
@@ -26,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';
@@ -42,21 +45,30 @@ export { createChildLogger } from './logging/createChildLogger';
 // strings
 export { pascalCase, camelCase } from './strings/camelCase';
 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/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;
     }

package/src/langs/langs.test.ts

@@ -0,0 +1,23 @@
+import test from 'ava';
+import { classOf } from './classOf';
+
+test('classOf', (t) => {
+  for (const [k, v] of [
+    [0, 'Number'],
+    ['', 'String'],
+    [true, 'Boolean'],
+    [null, 'Null'],
+    [undefined, 'Undefined'],
+    [{}, 'Object'],
+    [[], 'Array'],
+    [new ArrayBuffer(0), 'ArrayBuffer'],
+    [new Map(), 'Map'],
+    [new Set(), 'Set'],
+    [new Date(), 'Date'],
+    [new RegExp(''), 'RegExp'],
+    [new DataView(new ArrayBuffer(0)), 'DataView'],
+    [new Int8Array(0), 'Int8Array'],
+  ]) {
+    t.is(classOf(k), v as any);
+  }
+});

package/src/{validations/shallow.ts → langs/shallowEqual.ts}

@@ -3,7 +3,7 @@
  *
  * @see {@link https://github.com/pmndrs/zustand/blob/main/src/shallow.ts zustand/src/shallow.ts}
  */
-export function shallow<T, U>(objA: T, objB: U) {
+export function shallowEqual<T, U>(objA: T, objB: U) {
   if (Object.is(objA, objB)) {
     return true;
   }

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