@wener/utils 1.1.2 → 1.1.4

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,5 @@
-import { urljoin } from './urljoin';
 import test from 'ava';
+import { urljoin } from './urljoin';
 
 test('join ext', (t) => {
   t.is(urljoin('http://wener.me/sub/', '/a/', '/hello.js'), 'http://wener.me/sub/a/hello.js');

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

package/src/validations/shallow.ts

@@ -0,0 +1,26 @@
+/**
+ * shallow compare - support object, array
+ *
+ * @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) {
+  if (Object.is(objA, objB)) {
+    return true;
+  }
+  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  if (keysA.length !== Object.keys(objB).length) {
+    return false;
+  }
+  for (let i = 0; i < keysA.length; i++) {
+    if (
+      !Object.prototype.hasOwnProperty.call(objB, keysA[i] as string) ||
+      !Object.is(objA[keysA[i] as keyof T], objB[keysA[i] as keyof U])
+    ) {
+      return false;
+    }
+  }
+  return true;
+}