@wener/utils 1.1.1 → 1.1.3

package/package.json

@@ -1,70 +1,85 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.1",
+  "version": "1.1.3",
+  "type": "module",
   "description": "Utils for daily use",
-  "keywords": [
-    "utils",
-    "core library",
-    "helper"
-  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/wener/wode.git"
   },
-  "license": "MIT",
+  "homepage": "https://github.com/wenerme/wode#readme",
   "author": "wener",
-  "main": "lib/cjs/index.js",
-  "module": "lib/esm/index.js",
-  "types": "src/index.ts",
-  "esnext": "lib/esnext/index.js",
-  "umd:main": "dist/utils.js",
-  "unpkg": "dist/utils.js",
-  "jsdelivr": "dist/utils.js",
-  "jsnext:main": "dist/utils.esm.js",
+  "license": "MIT",
+  "engines": {
+    "node": "16",
+    "npm": "8"
+  },
+  "main": "dist/cjs/index.js",
   "exports": {
     ".": {
-      "import": "./lib/esm/index.js",
-      "require": "./lib/cjs/index.js"
-    }
+      "types": "./src/index.ts",
+      "import": "./lib/index.js",
+      "system": {
+        "default": "./dist/system/index.js"
+      },
+      "require": "./dist/cjs/index.js"
+    },
+    "./types": {
+      "types": "./src/types.d.ts"
+    },
+    "./server": {
+      "types": "./src/server.ts",
+      "import": "./lib/server.js",
+      "system": {
+        "default": "./dist/system/server.js"
+      },
+      "require": "./dist/cjs/server.js"
+    },
+    "./src/*": "./src/",
+    "./package.json": "./package.json"
   },
-  "homepage": "https://github.com/wenerme/wode#readme",
+  "types": "src/index.ts",
   "files": [
-    "index.js",
-    "index.d.ts",
-    "lib",
     "dist",
+    "index.ts",
+    "lib",
+    "server.ts",
     "src",
-    "README.md",
-    "rollup.config.ts",
-    "jest.config.js",
-    "jest.setup.js",
-    "tsconfig.rollup.json",
-    "tsconfig.jest.json",
     "tsconfig.json"
   ],
-  "scripts": {
-    "build": "make prepublish",
-    "clean": "make clean",
-    "dev": "make dev",
-    "test": "jest"
-  },
+  "keywords": [
+    "utils",
+    "core library",
+    "helper"
+  ],
   "devDependencies": {
-    "@types/jest": "^28",
     "@types/lodash": "^4",
-    "@types/node": "^16",
-    "dotenv": "^16",
-    "esbuild": "^0.14",
-    "jest": "^28",
-    "lodash": "^4",
-    "ts-jest": "^28",
-    "tslib": "^2",
-    "typescript": "^4"
+    "ava": "^4.3.3",
+    "lodash": "^4"
   },
   "publishConfig": {
     "access": "public"
   },
-  "engines": {
-    "node": "16",
-    "npm": "8"
+  "sideEffects": false,
+  "ava": {
+    "extensions": {
+      "ts": "module"
+    },
+    "nodeArguments": [
+      "--loader=tsx"
+    ]
+  },
+  "import": "lib/index.js",
+  "rollup": {
+    "input": [
+      "./src/index.ts",
+      "./src/server.ts"
+    ]
+  },
+  "scripts": {
+    "build": "make prepublish",
+    "clean": "make clean",
+    "dev": "make dev",
+    "test": "make test"
   }
-}
+}

package/server.ts

@@ -0,0 +1 @@
+export * from './src/server';

package/src/arrays/MaybeArray.ts

@@ -1,14 +1,18 @@
+/**
+ * Array or element of an array
+ */
 export type MaybeArray<T> = T | T[];
 
+/**
+ * convert to single value object
+ */
 export function objectOfMaybeArray<T = any>(
   o: Record<string, MaybeArray<T>>,
   keys: string[] | null = null,
-  picker = firstOfMaybeArray
+  picker = firstOfMaybeArray,
 ): Record<string, T> {
   if (keys === null) {
-    return Object.fromEntries(
-      Object.entries(o).map(([k, v]) => [k, picker(v)])
-    );
+    return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, picker(v)]));
   }
   return Object.fromEntries(keys.map((v) => [v, picker(v)])) as any;
 }

package/src/browsers/copy.ts

@@ -45,13 +45,17 @@ function initCopy() {
   };
 }
 
-export function copy(text: string) {
+/**
+ * Write text to clipboard
+ * @param content content
+ */
+export function copy(content: string) {
   if (window.navigator?.clipboard?.writeText) {
-    window.navigator.clipboard.writeText(text);
+    window.navigator.clipboard.writeText(content);
     return;
   }
   if (!_copy) {
     initCopy();
   }
-  _copy(text);
+  _copy(content);
 }

package/src/browsers/download.ts

@@ -1,3 +1,10 @@
+/**
+ * Trigger browser download
+ * @param filename download as filename
+ * @param data data or url to download
+ * @param type content type
+ * @param raw if true, data is treated as raw data, not url
+ */
 export function download(filename: string, data: any, { type = 'application/octet-stream', raw = false } = {}) {
   const a = document.createElement('a');
   let closer: () => void = () => null;

package/src/browsers/loaders.ts

@@ -4,7 +4,7 @@ function load(
   reject: (v: any) => void,
   options: { attributes: Record<string, string> } | undefined,
 ) {
-  el.onload = resolve;
+  el.onload = () => resolve(el);
   el.onerror = (e) => {
     el.remove();
     reject(e);
@@ -15,10 +15,34 @@ function load(
   document.head.appendChild(el);
 }
 
-export function loadScripts(src: string, options?: { attributes: Record<string, string> }) {
+export function loadScripts(
+  src: string[],
+  options?: { attributes: Record<string, string> },
+): Promise<HTMLScriptElement[]>;
+export function loadScripts(src: string, options?: { attributes: Record<string, string> }): Promise<HTMLScriptElement>;
+
+export function loadScripts(
+  src: string | string[],
+  options?: { attributes: Record<string, string> },
+): Promise<HTMLScriptElement | HTMLScriptElement[]> {
+  if (Array.isArray(src)) {
+    return new Promise(async (resolve, reject) => {
+      const all = [];
+      try {
+        for (let s of src) {
+          all.push(await loadScripts(s));
+        }
+      } catch (e) {
+        reject(e);
+        return;
+      }
+      resolve(all);
+    });
+  }
   // todo quote ?
-  if (document.querySelector(`script[src="${src}"]`)) {
-    return Promise.resolve();
+  let $ele = document.querySelector(`script[src="${src}"]`) as HTMLScriptElement;
+  if ($ele) {
+    return Promise.resolve($ele);
   }
   return new Promise((resolve, reject) => {
     const el = document.createElement('script');
@@ -27,9 +51,10 @@ export function loadScripts(src: string, options?: { attributes: Record<string,
   });
 }
 
-export function loadStyles(href: string, options?: { attributes: Record<string, string> }) {
-  if (document.querySelector(`link[href="${href}"]`)) {
-    return Promise.resolve();
+export function loadStyles(href: string, options?: { attributes: Record<string, string> }): Promise<HTMLLinkElement> {
+  let $ele = document.querySelector(`link[href="${href}"]`) as HTMLLinkElement;
+  if ($ele) {
+    return Promise.resolve($ele);
   }
 
   return new Promise((resolve, reject) => {

package/src/crypto/hashing.test.ts

@@ -0,0 +1,26 @@
+import test from 'ava';
+import { sha1, sha256, sha384, sha512 } from './hashing';
+import { hex } from './hex';
+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('sha', async (t) => {
+  t.is(hex(await sha1('')), 'da39a3ee5e6b4b0d3255bfef95601890afd80709');
+  t.is(hex(await sha1('abc')), 'a9993e364706816aba3e25717850c26c9cd0d89d');
+  t.is(hex(await sha256('')), 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+  t.is(
+    hex(await sha384('')),
+    '38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b',
+  );
+  t.is(
+    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}$/);
+});

package/src/crypto/hashing.ts

@@ -0,0 +1,27 @@
+export async function sha1(s: string | BufferSource) {
+  return digestOf('SHA-1', s);
+}
+
+export async function sha256(s: string | BufferSource) {
+  return digestOf('SHA-256', s);
+}
+
+export async function sha384(s: string | BufferSource) {
+  return digestOf('SHA-384', s);
+}
+
+export async function sha512(s: string | BufferSource) {
+  return digestOf('SHA-512', s);
+}
+
+function digestOf(a: string, s: string | BufferSource) {
+  return crypto.subtle.digest(a, bufferOf(s));
+}
+
+function bufferOf(s: string | BufferSource) {
+  // ArrayBuffer, TypedArray, DataView
+  if (typeof s === 'string') {
+    return new TextEncoder().encode(s);
+  }
+  return s;
+}

package/src/crypto/hex.ts

@@ -0,0 +1,5 @@
+export function hex(s: Uint8Array | ArrayBuffer) {
+  return Array.from(new Uint8Array(s))
+    .map((v) => v.toString(16).padStart(2, '0'))
+    .join('');
+}

package/src/crypto/randomUUID.ts

@@ -0,0 +1,13 @@
+/**
+ * generate random UUIDv4
+ */
+export function randomUUID() {
+  if ('randomUUID' in crypto) {
+    return crypto.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;
+    return v.toString(16);
+  });
+}

package/src/index.ts

@@ -1,11 +1,50 @@
-export * from './arrays/index';
-export * from './asyncs';
-export * from './validations';
-export * from './strings';
-export * from './maths';
-export * from './io';
-export * from './browsers';
+// arrays
+export {
+  firstOfMaybeArray,
+  lastOfMaybeArray,
+  arrayOfMaybeArray,
+  objectOfMaybeArray,
+  type MaybeArray,
+} from './arrays/MaybeArray';
+
+// async
+export { createLazyPromise, type LazyPromise } from './asyncs/LazyPromise';
+export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval';
+export { type MaybePromise } from './asyncs/MaybePromise';
+
+export { sleep } from './asyncs/sleep';
+export { timeout, TimeoutError } from './asyncs/timeout';
+export { isPromise } from './asyncs/isPromise';
+// export * from './async/promiseOfCallback';
+
+// validations
+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';
+
+// modules
+export { parseModuleId, type ParsedModuleId } from './modules/parseModuleId';
+
+// strings
+export { pascalCase, camelCase } from './strings/camelCase';
+export { templateString } from './strings/templates';
+
+export { createRandom } from './maths/random';
+export { isBuffer } from './io/isBuffer';
+
+export { copy } from './browsers/copy';
+export { download } from './browsers/download';
+export { loadScripts, loadStyles } from './browsers/loaders';
+export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer';
 
 export { getGlobalThis } from './isomorphics/getGlobalThis';
+
 export { formatBytes } from './formats/formatBytes';
 export { urljoin } from './shim/urljoin';
+
+// crypto
+export { randomUUID } from './crypto/randomUUID';
+export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
+export { hex } from './crypto/hex';

package/src/modules/parseModuleId.test.ts

@@ -0,0 +1,68 @@
+import test from 'ava';
+import { parseModuleId } from './parseModuleId';
+
+test('parseModuleId', (t) => {
+  const tests = {
+    '@wener/reaction': {
+      id: `@wener/reaction@latest`,
+      name: '@wener/reaction',
+      range: 'latest',
+      scoped: true,
+      org: 'wener',
+      pkg: 'reaction',
+    },
+    reaction: {
+      id: `reaction@latest`,
+      name: 'reaction',
+      range: 'latest',
+      pkg: 'reaction',
+      scoped: false,
+    },
+    'reaction@1': {
+      id: `reaction@1`,
+      name: 'reaction',
+      range: '1',
+      pkg: 'reaction',
+      scoped: false,
+    },
+    'reaction@1.1.1': {
+      id: `reaction@1.1.1`,
+      name: 'reaction',
+      version: '1.1.1',
+      range: '1.1.1',
+      pkg: 'reaction',
+      scoped: false,
+    },
+    'reaction@1.1.1-alpha': {
+      id: `reaction@1.1.1-alpha`,
+      name: 'reaction',
+      version: '1.1.1-alpha',
+      range: '1.1.1-alpha',
+      pkg: 'reaction',
+
+      scoped: false,
+    },
+    'reaction@1.1.1/index.js': {
+      id: `reaction@1.1.1`,
+      name: 'reaction',
+      version: '1.1.1',
+      range: '1.1.1',
+      scoped: false,
+      pkg: 'reaction',
+
+      path: '/index.js',
+    },
+    'reaction@1.1.1/': {
+      id: `reaction@1.1.1`,
+      name: 'reaction',
+      version: '1.1.1',
+      range: '1.1.1',
+      scoped: false,
+      pkg: 'reaction',
+      path: '/',
+    },
+  };
+  for (const [k, v] of Object.entries(tests)) {
+    t.deepEqual(parseModuleId(k), v);
+  }
+});

package/src/modules/parseModuleId.ts

@@ -0,0 +1,46 @@
+// https://regex101.com/r/eMcXQ9/1
+const regModuleId =
+  /^(?<n>(?:@(?<org>[a-z0-9-~][a-z0-9-._~]*)\/)?(?<pkg>[a-z0-9-~][a-z0-9-._~]*))(?:@(?<v>[-a-z0-9><=_.^~]+))?(?<p>\/[^\r\n]*)?$/;
+
+export type ParsedModuleId = {
+  id: string; // name@version
+  name: string; // @org/pkg, pkg
+  version?: string; // 1.1.1
+  range: string; // version, tag, range
+  pkg: string;
+  path?: string;
+} & (
+  | { scoped: false }
+  | {
+      scoped: true;
+      org?: string;
+    }
+);
+
+export function parseModuleId(s: string): ParsedModuleId | undefined {
+  const groups = s.match(regModuleId)?.groups;
+  if (!groups) {
+    return undefined;
+  }
+  const { n: name, v: version, p: path, org, pkg } = groups;
+  let scoped = Boolean(org);
+  const v = /^\d+\.\d+\.\d+/.test(version) ? version : undefined;
+  let range = version || 'latest';
+  const o = {
+    id: `${name}@${range}`,
+    name,
+    range: range,
+    scoped,
+    pkg,
+  } as ParsedModuleId;
+  if (v) {
+    o.version = v;
+  }
+  if (path) {
+    o.path = path;
+  }
+  if (o.scoped) {
+    o.org = org;
+  }
+  return o;
+}

package/src/server/polyfill.ts

@@ -0,0 +1,5 @@
+export async function polyfill() {
+  if (!('crypto' in globalThis)) {
+    (globalThis as any).crypto = (await import('node:crypto')).webcrypto;
+  }
+}

package/src/server.ts

@@ -0,0 +1 @@
+export { polyfill } from './server/polyfill';

package/src/shim/urljoin.test.ts

@@ -1,5 +1,6 @@
+import test from 'ava';
 import { urljoin } from './urljoin';
 
-test('join ext', () => {
-  expect(urljoin('http://wener.me/sub/', '/a/', '/hello.js')).toBe('http://wener.me/sub/a/hello.js');
+test('join ext', (t) => {
+  t.is(urljoin('http://wener.me/sub/', '/a/', '/hello.js'), 'http://wener.me/sub/a/hello.js');
 });

package/src/types.d.ts

@@ -0,0 +1,7 @@
+declare var __DEV__: boolean;
+
+namespace NodeJS {
+  interface ProcessEnv {
+    readonly NODE_ENV: 'development' | 'production' | 'test';
+  }
+}

package/src/validations/dequal.test.ts

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

package/src/validations/dequal.ts

@@ -0,0 +1,105 @@
+const has = Object.prototype.hasOwnProperty;
+const hasElementType = typeof Element !== 'undefined';
+
+function find(iter: any, tar: any, key?: any) {
+  for (key of iter.keys()) {
+    if (dequal(key, tar)) return key;
+  }
+}
+
+/**
+ * deep equal - support react, dom, Date, RegExp, Array, ArrayBuffer, Set, Map, Object
+ * @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) {
+  let ctor, len, tmp;
+  if (foo === bar) return true;
+
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return foo.getTime() === bar.getTime();
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && dequal(foo[len], bar[len]));
+      }
+      return len === -1;
+    }
+
+    if (ctor === Set) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len;
+        if (tmp && typeof tmp === 'object') {
+          tmp = find(bar, tmp);
+          if (!tmp) return false;
+        }
+        if (!bar.has(tmp)) return false;
+      }
+      return true;
+    }
+
+    if (ctor === Map) {
+      if (foo.size !== bar.size) {
+        return false;
+      }
+      for (len of foo) {
+        tmp = len[0];
+        if (tmp && typeof tmp === 'object') {
+          tmp = find(bar, tmp);
+          if (!tmp) return false;
+        }
+        if (!dequal(len[1], bar.get(tmp))) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    if (ctor === ArrayBuffer) {
+      foo = new Uint8Array(foo);
+      bar = new Uint8Array(bar);
+    } else if (ctor === DataView) {
+      if ((len = foo.byteLength) === bar.byteLength) {
+        while (len-- && foo.getInt8(len) === bar.getInt8(len));
+      }
+      return len === -1;
+    }
+
+    if (ArrayBuffer.isView(foo)) {
+      if ((len = foo.byteLength) === bar.byteLength) {
+        while (len-- && (foo as any)[len] === bar[len]);
+      }
+      return len === -1;
+    }
+
+    // react & dom
+    if (hasElementType && foo instanceof Element) return false;
+
+    if (!ctor || typeof foo === 'object') {
+      len = 0;
+      for (ctor in foo) {
+        if ((ctor === '_owner' || ctor === '__v' || ctor === '__o') && foo.$$typeof) {
+          // React-specific: avoid traversing React elements' _owner
+          // Preact-specific: avoid traversing Preact elements' __v and __o
+          //    __v = $_original / $_vnode
+          //    __o = $_owner
+          // These properties contain circular references and are not needed when
+          // comparing the actual elements (and not their owners)
+          // .$$typeof and ._store on just reasonable markers of elements
+
+          continue;
+        }
+
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+
+  return foo !== foo && bar !== bar;
+}