@wener/utils 1.1.6 → 1.1.7

package/src/asyncs/createLazyPromise.test.ts

@@ -3,9 +3,9 @@ import { createLazyPromise } from './createLazyPromise';
 import { sleep } from './sleep';
 
 test('basic', async (t) => {
-  let promise = createLazyPromise();
+  const promise = createLazyPromise();
   let r = 0;
-  promise.then((v) => (r = v));
+  void promise.then((v) => (r = v));
   t.is(r, 0);
   const { resolve, reject } = promise;
   t.truthy(resolve);
@@ -17,7 +17,7 @@ test('basic', async (t) => {
 });
 
 test('manual resolve skip exec', async (t) => {
-  let promise = createLazyPromise(() => {
+  const promise = createLazyPromise(() => {
     t.fail();
   });
   promise.resolve(-1);
@@ -26,7 +26,7 @@ test('manual resolve skip exec', async (t) => {
 
 test('exec', async (t) => {
   let r = 0;
-  let promise = createLazyPromise((resolve) => {
+  const promise = createLazyPromise((resolve) => {
     r++;
     resolve(10);
   });

package/src/asyncs/createLazyPromise.ts

@@ -18,7 +18,7 @@ export function createLazyPromise<T = any>(
       throw new Error('pending reject');
     },
   };
-  let future = Object.assign(
+  const future = Object.assign(
     new Promise<T>((resolve, reject) => {
       holder.reject = reject;
       holder.resolve = resolve;
@@ -52,7 +52,7 @@ export function createLazyPromise<T = any>(
     like.catch = future.catch.bind(future);
     if (future.finally) like.finally = future.finally;
 
-    Object.defineProperty(like, Symbol.species, {
+    void Object.defineProperty(like, Symbol.species, {
       get() {
         return Promise;
       },

package/src/asyncs/generatorOfStream.ts

@@ -3,6 +3,7 @@ export function* generatorOfStream<T = any>(stream: any): IterableIterator<Promi
   stream.on('end', () => {
     done = true;
   });
+  // eslint-disable-next-line no-unmodified-loop-condition
   while (!done) {
     yield new Promise((resolve, reject) => {
       stream.once('data', resolve);

package/src/asyncs/timeout.ts

@@ -3,7 +3,7 @@ export function timeout<T = any>(v: Promise<T>, ms: number): Promise<T> {
   let timeout: any;
   return Promise.race([
     v,
-    new Promise((_, reject) => {
+    new Promise((_resolve, reject) => {
       timeout = setTimeout(() => reject(error), ms);
     }),
   ]).then(

package/src/browsers/copy.ts

@@ -1,6 +1,8 @@
-// https://gist.github.com/rproenca/64781c6a1329b48a455b645d361a9aa3
+import { MaybePromise } from '../asyncs/MaybePromise';
+
 let _copy: (s: any) => void;
 
+// https://gist.github.com/rproenca/64781c6a1329b48a455b645d361a9aa3
 function initCopy() {
   let textArea: HTMLTextAreaElement;
 
@@ -49,13 +51,12 @@ function initCopy() {
  * Write text to clipboard
  * @param content content
  */
-export function copy(content: string) {
+export function copy(content: string): MaybePromise<void> {
   if (window.navigator?.clipboard?.writeText) {
-    window.navigator.clipboard.writeText(content);
-    return;
+    return window.navigator.clipboard.writeText(content);
   }
   if (!_copy) {
     initCopy();
   }
-  _copy(content);
+  return _copy(content);
 }

package/src/browsers/loaders.ts

@@ -26,21 +26,16 @@ export function loadScripts(
   options?: { attributes: Record<string, string> },
 ): Promise<HTMLScriptElement | HTMLScriptElement[]> {
   if (Array.isArray(src)) {
-    return new Promise(async (resolve, reject) => {
+    return Promise.resolve().then(async () => {
       const all = [];
-      try {
-        for (let s of src) {
-          all.push(await loadScripts(s));
-        }
-      } catch (e) {
-        reject(e);
-        return;
+      for (const s of src) {
+        all.push(await loadScripts(s));
       }
-      resolve(all);
+      return all;
     });
   }
   // todo quote ?
-  let $ele = document.querySelector(`script[src="${src}"]`) as HTMLScriptElement;
+  const $ele = document.querySelector(`script[src="${src}"]`) as HTMLScriptElement;
   if ($ele) {
     return Promise.resolve($ele);
   }
@@ -52,7 +47,7 @@ export function loadScripts(
 }
 
 export function loadStyles(href: string, options?: { attributes: Record<string, string> }): Promise<HTMLLinkElement> {
-  let $ele = document.querySelector(`link[href="${href}"]`) as HTMLLinkElement;
+  const $ele = document.querySelector(`link[href="${href}"]`) as HTMLLinkElement;
   if ($ele) {
     return Promise.resolve($ele);
   }

package/src/crypto/{hex.ts → base.ts}

@@ -1,3 +1,6 @@
+/**
+ * hex string
+ */
 export function hex(s: Uint8Array | ArrayBuffer) {
   return Array.from(new Uint8Array(s))
     .map((v) => v.toString(16).padStart(2, '0'))

package/src/crypto/hashing.test.ts

@@ -2,7 +2,7 @@ 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 { hex } from './base';
 import { _randomUUID } from './randomUUID';
 
 test.before(async () => {

package/src/crypto/hashing.ts

@@ -1,16 +1,16 @@
-export async function sha1(s: string | BufferSource) {
+export function sha1(s: string | BufferSource) {
   return digestOf('SHA-1', s);
 }
 
-export async function sha256(s: string | BufferSource) {
+export function sha256(s: string | BufferSource) {
   return digestOf('SHA-256', s);
 }
 
-export async function sha384(s: string | BufferSource) {
+export function sha384(s: string | BufferSource) {
   return digestOf('SHA-384', s);
 }
 
-export async function sha512(s: string | BufferSource) {
+export function sha512(s: string | BufferSource) {
   return digestOf('SHA-512', s);
 }
 

package/src/crypto/randomUUID.ts

@@ -3,6 +3,9 @@
  */
 export const randomUUID: () => string = globalThis.crypto?.randomUUID || _randomUUID;
 
+/**
+ * @internal
+ */
 export function _randomUUID() {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
     const r = (Math.random() * 16) | 0;

package/src/i18n/createTranslate.test.ts

@@ -2,7 +2,7 @@ import test from 'ava';
 import { createTranslate } from './createTranslate';
 
 test('exports', (t) => {
-  let out = createTranslate();
+  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');
@@ -10,7 +10,7 @@ test('exports', (t) => {
 });
 
 test('usage', (t) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: { hello: 'Hello, {{name}}!' },
     es: { hello: 'Hola {{name}}!' },
     pt: { foo: 'foo {{name}}~!' },
@@ -18,23 +18,23 @@ test('usage', (t) => {
 
   t.deepEqual(ctx.dict('en'), { hello: 'Hello, {{name}}!' });
 
-  t.is(ctx.dict('foobar'), undefined);
+  t.true(ctx.dict('foobar') === undefined);
 
-  let foo = ctx.t('hello');
+  const 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');
+  const 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' });
+  const baz = ctx.t('hello', { name: 'world' });
   t.is(baz, 'Hello, world!', '~> interpolations successful');
 
-  let bat = ctx.t('hello', { name: 'world' }, 'es');
+  const bat = ctx.t('hello', { name: 'world' }, 'es');
   t.not(bat, '', '(es) found "hello" key');
   t.is(bat, 'Hola world!', '~> success');
 
@@ -42,11 +42,11 @@ test('usage', (t) => {
 
   t.is(ctx.dict('pt', { hello: 'Oí {{name}}!' }), undefined, '>>> ctx.dict()');
 
-  let quz = ctx.t('hello', { name: 'world' }, 'pt');
+  const 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');
+  const qut = ctx.t('foo', { name: 'bar' }, 'pt');
   t.not(qut, '', '(pt) found "foo" key');
   t.is(qut, 'foo bar~!', '~> success');
 
@@ -58,7 +58,7 @@ test('usage', (t) => {
   t.is(ctx.locale(null as any), 'es');
   t.is(ctx.locale(0 as any), 'es');
 
-  let qux = ctx.t('hello', { name: 'default' });
+  const qux = ctx.t('hello', { name: 'default' });
   t.not(qux, '', '(es) found "hello" key');
   t.is(qux, 'Hola default!', '~> success');
 
@@ -66,13 +66,13 @@ test('usage', (t) => {
 
   t.is(ctx.dict('de', { hello: 'Hallo {{name}}!' }), undefined, '>>> ctx.dict(de)');
 
-  let qar = ctx.t('hello', { name: 'world' }, 'de');
+  const 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({
+  const ctx = createTranslate({
     en: {
       hello(value: any) {
         return `hello ${value || 'stranger'}~!`;
@@ -82,18 +82,18 @@ test('functional', (t) => {
 
   ctx.locale('en');
 
-  let foo = ctx.t('hello');
+  const foo = ctx.t('hello');
   t.is(foo, 'hello stranger~!', '~> called function w/o param');
 
-  let bar = ctx.t('hello', 'world' as any);
+  const 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]);
+  const 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({
+  const ctx = createTranslate({
     en: {
       fruits: {
         apple: 'apple',
@@ -126,7 +126,7 @@ test('nested', (t) => {
 });
 
 test('arrays', (t) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: {
       foo: '{{0}} + {{1}} = {{2}}',
       bar: [
@@ -145,7 +145,7 @@ test('arrays', (t) => {
 });
 
 test('invalid value', (t) => {
-  let ctx = createTranslate({
+  const ctx = createTranslate({
     en: {
       foo: ['bar'],
     },

package/src/i18n/createTranslate.ts

@@ -45,7 +45,7 @@ export function createTranslate<T extends object>(obj?: Record<string, T>): Tran
         }
       }
       if (typeof val === 'function') return val(params);
-      if (typeof val === 'string') return renderTemplate(val, params!, 'common');
+      if (typeof val === 'string') return renderTemplate(val, params, 'common');
       return val;
     },
   };

package/src/index.ts

@@ -53,6 +53,8 @@ export { createTranslate } from './i18n/createTranslate';
 // io
 export { isBuffer } from './io/isBuffer';
 export { isTransferable } from './io/isTransferable';
+export { ArrayBuffers } from './io/ArrayBuffers';
+export type { AbstractEncoding } from './io/AbstractEncoding';
 
 // browser
 export { copy } from './browsers/copy';
@@ -67,8 +69,7 @@ export { structuredClone } from './isomorphics/structuredClone';
 // crypto
 export { randomUUID } from './crypto/randomUUID';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
-export { hex } from './crypto/hex';
+export { hex } from './crypto/base';
 
 // misc
 export { createRandom } from './maths/random';
-export { urljoin } from './shim/urljoin';

package/src/io/AbstractEncoding.ts

@@ -0,0 +1,21 @@
+/**
+ * AbstractEncoding contract
+ *
+ * @see https://github.com/mafintosh/abstract-encoding
+ */
+export interface AbstractEncoding<T> {
+  /**
+   * encode a value to a buffer
+   */
+  encode(data: T, buffer?: ArrayBuffer, offset?: number): BufferSource;
+
+  /**
+   * decode data from buffer
+   */
+  decode(buffer: BufferSource, start?: number, end?: number): T;
+
+  /**
+   * byteLength of data
+   */
+  byteLength?: (data: T) => number;
+}

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

@@ -0,0 +1,4 @@
+import { expectType } from 'tsd';
+import { ArrayBuffers } from './ArrayBuffers';
+
+expectType<Buffer>(ArrayBuffers.asView(Buffer, new Uint8Array()));

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

@@ -0,0 +1,61 @@
+import test from 'ava';
+import { ArrayBuffers } from './ArrayBuffers';
+
+test.before(() => {
+  ArrayBuffers._allowedBuffer = false;
+});
+
+test('base64: ignore whitespace', function (t) {
+  const text = '\n   YW9ldQ==  ';
+  const buf = ArrayBuffers.from(text, 'base64');
+  t.is(ArrayBuffers.toString(buf), 'aoeu');
+});
+
+test('base64: strings without padding', function (t) {
+  t.is(ArrayBuffers.toString(ArrayBuffers.from('YW9ldQ', 'base64')), 'aoeu');
+});
+
+test('base64: newline in utf8 -- should not be an issue', function (t) {
+  t.is(
+    ArrayBuffers.toString(
+      ArrayBuffers.from('LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK', 'base64'),
+      'utf8',
+    ),
+    '---\ntitle: Three dashes marks the spot\ntags:\n',
+  );
+});
+
+test('base64: newline in base64 -- should get stripped', function (t) {
+  t.is(
+    ArrayBuffers.toString(
+      ArrayBuffers.from(
+        'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\nICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
+        'base64',
+      ),
+      'utf8',
+    ),
+    '---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-',
+  );
+});
+
+test('base64: tab characters in base64 - should get stripped', function (t) {
+  t.is(
+    ArrayBuffers.toString(
+      ArrayBuffers.from(
+        'LS0tCnRpdGxlOiBUaHJlZSBkYXNoZXMgbWFya3MgdGhlIHNwb3QKdGFnczoK\t\t\t\tICAtIHlhbWwKICAtIGZyb250LW1hdHRlcgogIC0gZGFzaGVzCmV4cGFuZWQt',
+        'base64',
+      ),
+      'utf8',
+    ),
+    '---\ntitle: Three dashes marks the spot\ntags:\n  - yaml\n  - front-matter\n  - dashes\nexpaned-',
+  );
+});
+
+test('base64: invalid non-alphanumeric characters -- should be stripped', function (t) {
+  t.is(ArrayBuffers.toString(ArrayBuffers.from('!"#$%&\'()*,.:;<=>?@[\\]^`{|}~', 'base64'), 'utf8'), '');
+});
+
+test('base64: high byte', function (t) {
+  const highByte = ArrayBuffers.from([128]);
+  t.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
+});

package/src/io/ArrayBuffers.test.ts

@@ -0,0 +1,23 @@
+import test from 'ava';
+import { ArrayBuffers } from './ArrayBuffers';
+
+test('concat', (t) => {
+  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}`);
+  };
+  check(Uint8Array);
+  check(Uint16Array, [0xff, 0xffff]);
+  check(Uint32Array, [0xfffffff]);
+});
+
+test('asView for Buffer', (t) => {
+  const buf = Buffer.from([1, 2, 3, 4, 5]);
+  t.is(ArrayBuffers.asView(Buffer, buf), buf);
+  const uint8 = ArrayBuffers.asView(Uint8Array, buf);
+  t.is(ArrayBuffers.asView(Buffer, uint8).buffer, buf.buffer);
+
+  t.deepEqual(uint8, buf);
+  t.deepEqual(ArrayBuffers.asView(Buffer, uint8), buf);
+});