@wener/utils 1.1.12 → 1.1.14

package/src/i18n/createTranslate.test.ts

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

package/src/i18n/createTranslate.ts

@@ -53,11 +53,12 @@ export function createTranslate<T extends object>(obj?: Record<string, T>): Tran
       }
       if (process.env.NODE_ENV === 'development') {
         if (val == null) {
-          return console.error(
+          console.error(
             `[Translate] Missing the "${[].concat(key as any).join('.')}" key within the "${
               lang || locale
             }" dictionary`,
           );
+          return;
         }
       }
       if (typeof val === 'function') return val(params);

package/src/index.ts

@@ -72,6 +72,7 @@ export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer';
 
 // polyfills
 export { getGlobalThis } from './isomorphics/getGlobalThis';
+export { globalThis } from './isomorphics/globalThis';
 export { structuredClone } from './isomorphics/structuredClone';
 
 // crypto

package/src/io/ArrayBuffer.test-d.ts

@@ -1,4 +1,6 @@
-import { expectType } from 'tsd';
+import { expectTypeOf, test } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
-expectType<Buffer>(ArrayBuffers.asView(Buffer, new Uint8Array()));
+test('my types work properly', () => {
+  expectTypeOf(ArrayBuffers.asView(Buffer, new Uint8Array())).toMatchTypeOf<Buffer>();
+});

package/src/io/ArrayBuffers.base64.test.ts

@@ -1,23 +1,23 @@
-import test from 'ava';
+import { test, beforeAll, assert, expect } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
-test.before((t) => {
-  t.true(ArrayBuffers.isNativeBufferAvailable());
+beforeAll(() => {
+  expect(ArrayBuffers.isNativeBufferAvailable()).toBeTruthy();
   ArrayBuffers.setNativeBufferAllowed(false);
 });
 
-test('base64: ignore whitespace', function (t) {
+test('base64: ignore whitespace', function () {
   const text = '\n   YW9ldQ==  ';
   const buf = ArrayBuffers.from(text, 'base64');
-  t.is(ArrayBuffers.toString(buf), 'aoeu');
+  expect(ArrayBuffers.toString(buf)).toBe('aoeu');
 });
 
-test('base64: strings without padding', function (t) {
-  t.is(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64')), 'aoeu');
+test('base64: strings without padding', function () {
+  expect(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64'))).toBe('aoeu');
 });
 
-test('base64: newline in utf8 -- should not be an issue', function (t) {
-  t.is(
+test('base64: newline in utf8 -- should not be an issue', function () {
+  assert.equal(
     ArrayBuffers.toString(
       ArrayBuffers.from('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK', 'base64'),
       'utf8',
@@ -26,8 +26,8 @@ test('base64: newline in utf8 -- should not be an issue', function (t) {
   );
 });
 
-test('base64: newline in base64 -- should get stripped', function (t) {
-  t.is(
+test('base64: newline in base64 -- should get stripped', function () {
+  assert.equal(
     ArrayBuffers.toString(
       ArrayBuffers.from(
         'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\nICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
@@ -39,8 +39,8 @@ test('base64: newline in base64 -- should get stripped', function (t) {
   );
 });
 
-test('base64: tab characters in base64 - should get stripped', function (t) {
-  t.is(
+test('base64: tab characters in base64 - should get stripped', function () {
+  assert.equal(
     ArrayBuffers.toString(
       ArrayBuffers.from(
         'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\t\t\t\tICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
@@ -52,11 +52,11 @@ test('base64: tab characters in base64 - should get stripped', function (t) {
   );
 });
 
-test('base64: invalid non-alphanumeric characters -- should be stripped', function (t) {
-  t.is(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8'), '');
+test('base64: invalid non-alphanumeric characters -- should be stripped', function () {
+  expect(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8')).toBe('');
 });
 
-test('base64: high byte', function (t) {
+test('base64: high byte', function () {
   const highByte = ArrayBuffers.from([128]);
-  t.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
+  assert.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
 });

package/src/io/ArrayBuffers.test.ts

@@ -1,23 +1,23 @@
-import test from 'ava';
+import { test, expect } from 'vitest';
 import { ArrayBuffers } from './ArrayBuffers';
 
-test('concat', (t) => {
+test('concat', () => {
   const check = (Type: any = Uint8Array, va = [1, 2, 3], vb = [4, 5, 6]) => {
     const a = new Type(va);
     const b = new Type(vb);
-    t.deepEqual(ArrayBuffers.concat([a, b]), new Type([...va, ...vb]).buffer, `should concat ${Type}`);
+    expect(ArrayBuffers.concat([a, b]), `should concat ${Type}`).toStrictEqual(new Type([...va, ...vb]).buffer);
   };
   check(Uint8Array);
   check(Uint16Array, [0xff, 0xffff]);
   check(Uint32Array, [0xfffffff]);
 });
 
-test('asView for Buffer', (t) => {
+test('asView for Buffer', () => {
   const buf = Buffer.from([1, 2, 3, 4, 5]);
-  t.is(ArrayBuffers.asView(Buffer, buf), buf);
+  expect(ArrayBuffers.asView(Buffer, buf)).toBe(buf);
   const uint8 = ArrayBuffers.asView(Uint8Array, buf);
-  t.is(ArrayBuffers.asView(Buffer, uint8).buffer, buf.buffer);
+  expect(ArrayBuffers.asView(Buffer, uint8).buffer).toBe(buf.buffer);
 
-  t.deepEqual(uint8, buf);
-  t.deepEqual(ArrayBuffers.asView(Buffer, uint8), buf);
+  expect(uint8).toEqual(buf);
+  expect(ArrayBuffers.asView(Buffer, uint8)).toEqual(buf);
 });

package/src/io/ArrayBuffers.ts

@@ -1,3 +1,4 @@
+import { globalThis } from '../isomorphics/globalThis';
 import { classOf } from '../langs/classOf';
 import { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64';
 import { isBuffer } from './isBuffer';

package/src/io/Buffer.test.ts

@@ -1,12 +1,12 @@
-import test from 'ava';
+import { test, expect } from 'vitest';
 import { Buffer } from './Buffer';
 import { isBuffer } from './isBuffer';
 
-test('basic', (t) => {
+test('basic', () => {
   {
     const buf = new Buffer(0);
-    t.true(Buffer.isBuffer(buf));
-    t.true(isBuffer(buf));
+    expect(Buffer.isBuffer(buf)).toBeTruthy();
+    expect(isBuffer(buf)).toBeTruthy();
   }
   // const b = new Buffer(10)
   // t.is(b.length,10)

package/src/io/isBuffer.test.ts

@@ -1,9 +1,9 @@
-import test from 'ava';
 import { Buffer } from 'node:buffer';
+import { expect, test } from 'vitest';
 import { classOf } from '../langs/classOf';
 import { isBuffer } from './isBuffer';
 
-test('isBuffer', (t) => {
-  t.true(isBuffer(Buffer.from('')));
-  t.is(classOf(Buffer), 'Function');
+test('isBuffer', () => {
+  expect(isBuffer(Buffer.from(''))).toBeTruthy();
+  expect(classOf(Buffer)).toBe('Function');
 });

package/src/io/isTransferable.test.ts

@@ -1,10 +1,11 @@
-import test from 'ava';
 import { Buffer } from 'node:buffer';
+import { expect, test } from 'vitest';
 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)));
+test('isTransferable', () => {
+  expect(isTransferable(0)).toBeFalsy();
+  expect(isTransferable(Buffer.from(''))).toBeFalsy();
+
+  expect(new ArrayBuffer(0) instanceof ArrayBuffer).toBeTruthy();
+  expect(isTransferable(new ArrayBuffer(0))).toBeTruthy();
 });

package/src/io/isTransferable.ts

@@ -1,3 +1,5 @@
+import { globalThis } from '../isomorphics/globalThis';
+
 /**
  * transferable object pass between workers, can work with structuredClone
  *

package/src/isomorphics/getGlobalThis.ts

@@ -5,6 +5,8 @@ declare const global: typeof globalThis;
  *
  * globalThis supported by ff 65, Chrome 71, Node 12, babel
  *
+ * non-standard globalThis supported for Alipay Miniprogram
+ *
  * @see https://caniuse.com/#search=globalThis
  * @see https://v8.dev/features/globalthis
  */
@@ -13,6 +15,6 @@ export const getGlobalThis = (): typeof globalThis => {
   if (typeof self !== 'undefined') return self;
   if (typeof window !== 'undefined') return window;
   if (typeof global !== 'undefined') return global as any;
-  // if (typeof this !== 'undefined') return this;
+  if (typeof this !== 'undefined') return this as any;
   throw new Error('Unable to locate global `this`');
 };

package/src/isomorphics/globalThis.ts

@@ -0,0 +1,3 @@
+import { getGlobalThis } from './getGlobalThis';
+
+export const globalThis = getGlobalThis();

package/src/isomorphics/structuredClone.test.ts

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

package/src/isomorphics/structuredClone.ts

@@ -1,5 +1,6 @@
 /* eslint no-proto:0 */
 import { classOf } from '../langs/classOf';
+import { globalThis } from './globalThis';
 
 /**
  * Clone an object using structured cloning algorithm

package/src/langs/deepEqual.test.ts

@@ -1,8 +1,8 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 import { deepEqual } from './deepEqual';
 
-test('deep equal', (t) => {
-  t.true(
+test('deep equal', () => {
+  expect(
     deepEqual(
       {
         a: null,
@@ -13,5 +13,5 @@ test('deep equal', (t) => {
         b: Infinity,
       },
     ),
-  );
+  ).toBeTruthy();
 });

package/src/langs/langs.test.ts

@@ -1,7 +1,7 @@
-import test from 'ava';
+import { expect, test } from 'vitest';
 import { classOf } from './classOf';
 
-test('classOf', (t) => {
+test('classOf', () => {
   for (const [k, v] of [
     [0, 'Number'],
     ['', 'String'],
@@ -18,6 +18,6 @@ test('classOf', (t) => {
     [new DataView(new ArrayBuffer(0)), 'DataView'],
     [new Int8Array(0), 'Int8Array'],
   ]) {
-    t.is(classOf(k), v as any);
+    expect(classOf(k)).toBe(v);
   }
 });