@wener/utils 1.1.47 → 1.1.48

package/src/crypto/getNodeCrypto.ts

@@ -1,17 +1,21 @@
-let nodeCrypto: Awaited<typeof import('node:crypto')>;
+import { getGlobalThis } from '../runtime/getGlobalThis';
+
+let nodeCrypto;
 // globalThis.process?.release?.name
 
+// avoid import node
 // avoid process.browser
-if (typeof window === 'undefined') {
-  try {
-    // avoid `node:` UnhandledSchemeError https://github.com/vercel/next.js/issues/28774
-    if (typeof require === 'undefined') {
-      void import('crypto').then((v) => (nodeCrypto = v.default));
-    } else {
-      nodeCrypto = require('crypto');
-    }
-  } catch (e) {}
-}
+// if (typeof window === 'undefined') {
+//   try {
+//     // avoid `node:` UnhandledSchemeError https://github.com/vercel/next.js/issues/28774
+//     if (typeof require === 'undefined') {
+//       void import('crypto').then((v) => (nodeCrypto = v.default));
+//     } else {
+//       nodeCrypto = require('crypto');
+//     }
+//   } catch (e) {}
+// }
 export function getNodeCrypto() {
+  nodeCrypto ||= getGlobalThis().crypto;
   return nodeCrypto;
 }

package/src/crypto/getRandomValues.ts

@@ -4,10 +4,15 @@ import { getGlobalThis } from '../runtime/getGlobalThis';
 import { getNodeCrypto } from './getNodeCrypto';
 
 const globalThis = getGlobalThis();
+
+// chrome 11+, safari 5+, nodejs 17.4+
+// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
 export let getRandomValues: <T extends Exclude<TypedArray, Float32Array | Float64Array>>(typedArray: T) => T =
   globalThis.crypto?.getRandomValues?.bind(globalThis.crypto) ||
   (globalThis as any).msCrypto?.getRandomValues?.bind((globalThis as any).msCrypto) ||
-  _getRandomValues;
+  (() => {
+    throw new Error('[getRandomValues]: No secure random number generator available.');
+  });
 
 function _getRandomValues<T extends Exclude<TypedArray, Float32Array | Float64Array>>(buf: T) {
   const nodeCrypto = getNodeCrypto();

package/src/emitter/types.ts

@@ -0,0 +1,18 @@
+export type EventType = string | symbol;
+
+export type Handler<E extends keyof T, T = Record<string, unknown>> = (evt: { type: E; payload: T[E] }) => void;
+export type WildcardHandler<T = Record<string, unknown>> = <E extends keyof T>(evt: { type: E; payload: T[E] }) => void;
+
+export interface Emitter<Events extends Record<EventType, unknown>> {
+  on<Key extends keyof Events>(type: Key, handler: Handler<Key, Events>): void;
+
+  on(type: '*', handler: WildcardHandler<Events>): void;
+
+  off<Key extends keyof Events>(type: Key, handler?: Handler<Key, Events>): void;
+
+  off(type: '*', handler: WildcardHandler<Events>): void;
+
+  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+
+  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}

package/src/fetch/http.types.ts

@@ -0,0 +1,46 @@
+// from hono
+
+export type InfoStatusCode = 100 | 101 | 102 | 103;
+export type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+export type DeprecatedStatusCode = 305 | 306;
+export type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+export type ClientErrorStatusCode =
+  | 400
+  | 401
+  | 402
+  | 403
+  | 404
+  | 405
+  | 406
+  | 407
+  | 408
+  | 409
+  | 410
+  | 411
+  | 412
+  | 413
+  | 414
+  | 415
+  | 416
+  | 417
+  | 418
+  | 421
+  | 422
+  | 423
+  | 424
+  | 425
+  | 426
+  | 428
+  | 429
+  | 431
+  | 451;
+export type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+
+export type UnofficialStatusCode = -1;
+export type StatusCode =
+  | InfoStatusCode
+  | SuccessStatusCode
+  | RedirectStatusCode
+  | ClientErrorStatusCode
+  | ServerErrorStatusCode
+  | UnofficialStatusCode;

package/src/index.ts

@@ -1,3 +1,5 @@
+import { Promises } from './asyncs/Promises';
+
 // arrays
 export {
   firstOfMaybeArray,
@@ -25,10 +27,10 @@ export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator';
 export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator';
 export { isIterator } from './asyncs/isIterator';
 
-export { sleep } from './asyncs/sleep';
+export { Promises } from './asyncs/Promises';
+export const sleep = Promises.sleep;
+export const isPromise = Promises.isPromise;
 export { timeout, TimeoutError } from './asyncs/timeout';
-export { isPromise } from './asyncs/isPromise';
-// export * from './async/promiseOfCallback';
 
 // langs
 export { shallowEqual } from './langs/shallowEqual';

package/src/io/ByteBuffer.test.ts

@@ -14,7 +14,22 @@ test('ByteBuffer', async () => {
     assert.equal(buf.readString(5), 'Hello');
   }
   {
+    // overflow max length
     let buf = new ByteBuffer();
     buf.writeBytes(new Uint8Array(1025));
   }
+  {
+    // overflow max length
+    let buf = new ByteBuffer();
+    buf.writeBytes(new Uint8Array([1, 2]));
+    buf.position = 0;
+    console.log('X', buf.position, buf.length, buf.remaining());
+
+    // truncate to size fill zero
+    buf.writeBytes(new Uint8Array(1), 10);
+    console.log('X', buf.position, buf.length, buf.remaining());
+
+    assert.equal(buf.view.getInt8(1), 2);
+    assert.equal(buf.length, 10);
+  }
 });

package/src/io/ByteBuffer.ts

@@ -1,4 +1,3 @@
-import { isDefined } from '../langs/isDefined';
 import { ArrayBuffers } from './ArrayBuffers';
 
 type AnyBuffer = BufferSource | ArrayBufferLike;
@@ -72,7 +71,7 @@ export class ByteBuffer {
 
   private willWrite(length: number) {
     if (this.remaining() < length) {
-      this.resize(this.length + length);
+      this.resize(this.position + length);
     }
   }
 
@@ -89,7 +88,7 @@ export class ByteBuffer {
     this.willWrite(len);
     if (len !== bytes.byteLength) bytes = bytes.slice(0, len);
     new Uint8Array(this.buffer).set(new Uint8Array(bytes), this.position);
-    this.position += bytes.byteLength;
+    this.position += len;
   }
 
   writeInt8(value: number) {
@@ -325,7 +324,7 @@ export class ByteBuffer {
   }
 
   remaining() {
-    return this.view.byteLength - this.position;
+    return this.length - this.position;
   }
 
   toUint8Array() {

package/src/langs/mixin.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from 'vitest';
+import { mixin } from './mixin';
+
+export type Constructor<T = {}> = new (...args: any[]) => T;
+
+test('mixin', () => {
+  class User extends mixin(BaseResource, createBarFields()) {}
+
+  let usr = new User();
+  // type not working
+  expect(usr.foo, 'foo');
+  expect(usr).toEqual({
+    foo: 'foo',
+    bar: 'bar',
+    id: '',
+  });
+});
+
+class BaseResource {
+  id?: string = '';
+}
+
+function createBarFields() {
+  return <TBase extends Constructor>(Base: TBase) => {
+    class HasBarMixin extends mixin(Base, withFooFields) {
+      bar?: string = 'bar';
+    }
+
+    return HasBarMixin;
+  };
+}
+
+function withFooFields<TBase extends Constructor>(Base: TBase) {
+  class HasFieldFooMixin extends Base {
+    foo?: string = 'foo';
+  }
+
+  return HasFieldFooMixin;
+}

package/src/maths/random.ts

@@ -1,6 +1,6 @@
 /// javascript pseudo random
 export function createRandom(o: { seed?: string | number } = {}) {
-  let seed = typeof o.seed === 'string' ? 0 : o.seed ?? 0;
+  let seed = typeof o.seed === 'string' ? 0 : (o.seed ?? 0);
   if (typeof o.seed === 'string') {
     let sum = 0;
     for (let i = 0; i < o.seed.length; i++) {

package/src/mitt/README.md

@@ -0,0 +1 @@
+- https://github.com/developit/mitt/blob/main/src/index.ts

package/src/mitt/index.ts

@@ -0,0 +1,114 @@
+export type EventType = string | symbol;
+
+type EventPayload<T = EventType, E = unknown> = { type: T; event: E };
+
+export type Handler<T = EventType, E = unknown> = (evt: { type: T; event: E }) => void;
+
+// An array of all currently registered event handlers for a type
+export type EventHandlerList<T = unknown> = Array<Handler<EventType, T>>;
+
+// A map of event types and their corresponding event handlers.
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
+  keyof Events | '*',
+  EventHandlerList<Events[keyof Events]>
+>;
+
+export interface Emitter<Events extends Record<EventType, unknown>> {
+  all: EventHandlerMap<Events>;
+
+  on<Key extends keyof Events>(type: Key, handler: Handler<Key, Events[Key]>): void;
+
+  on(type: '*', handler: Handler<Events>): void;
+
+  once<Key extends keyof Events>(type: Key, handler: Handler<Key, Events[Key]>): void;
+
+  once(type: '*', handler: Handler<Events>): void;
+
+  off<Key extends keyof Events>(type: Key, handler?: Handler<Key, Events[Key]>): void;
+
+  off(type: '*', handler: Handler<Events>): void;
+
+  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+
+  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name createEmitter
+ * @returns {Emitter}
+ */
+export default function createEmitter<Events extends Record<EventType, unknown>>(
+  all?: EventHandlerMap<Events>,
+): Emitter<Events> {
+  type GenericEventHandler = Handler<EventType, Events[keyof Events]>;
+  all = all || new Map();
+  let evt: Emitter<Events>;
+  return (evt = {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all,
+
+    on(type: EventType, handler: GenericEventHandler) {
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all!.set(type, [handler]);
+      }
+    },
+
+    once(type: EventType, handler: GenericEventHandler) {
+      let fn = handler;
+      handler = (...args) => {
+        evt.off(type, fn);
+        fn(...args);
+      };
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all!.set(type, [handler]);
+      }
+    },
+
+    off(type: EventType, handler?: GenericEventHandler) {
+      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+      if (handlers) {
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        } else {
+          all!.set(type, []);
+        }
+      }
+    },
+
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     * @memberOf createEmitter
+     */
+    emit(type: EventType, evt?: any) {
+      let handlers = all!.get(type);
+      let ctx: EventPayload = { type, event: evt };
+      if (handlers) {
+        (handlers as EventHandlerList).slice().map((handler) => {
+          handler(ctx);
+        });
+      }
+
+      handlers = all!.get('*');
+      if (handlers) {
+        (handlers as EventHandlerList).slice().map((handler) => {
+          handler(ctx);
+        });
+      }
+    },
+  } as Emitter<Events>);
+}

package/src/objects/computeIfAbsent.ts

@@ -1,7 +1,8 @@
+export function computeIfAbsent<K extends WeakKey, V>(map: WeakMap<K, V>, key: K, fn: () => V): V;
 export function computeIfAbsent<K, V>(map: Map<K, V>, key: K, fn: () => V): V;
 export function computeIfAbsent<K extends string | symbol | number, V>(map: Record<K, V>, key: K, fn: () => V): V;
-export function computeIfAbsent<K, V>(map: any, key: K, fn: () => V): V {
-  if (map instanceof Map) {
+export function computeIfAbsent(map: any, key: any, fn: () => any): any {
+  if (map instanceof Map || map instanceof WeakMap) {
     if (!map.has(key)) {
       map.set(key, fn());
     }

package/lib/asyncs/sleep.js

@@ -1,3 +0,0 @@
-export const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
-
-//# sourceMappingURL=sleep.js.map

package/lib/asyncs/sleep.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/asyncs/sleep.ts"],"sourcesContent":["export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));\n"],"names":["sleep","ms","Promise","resolve","setTimeout"],"rangeMappings":"","mappings":"AAAA,OAAO,MAAMA,QAAQ,CAACC,KAAe,IAAIC,QAAQ,CAACC,UAAYC,WAAWD,SAASF,KAAK"}

package/lib/cn/id/Mod11Checksum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/cn/id/Mod11Checksum.ts"],"sourcesContent":["/**\n * ISO 7064:1983, MOD 11-2.\n */\nexport class Mod11Checksum {\n  weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1];\n  private static instance: Mod11Checksum;\n\n  static get() {\n    return this.instance || (this.instance = new Mod11Checksum());\n  }\n\n  verify(s: string) {\n    return s.at(-1) === this.generate(s.slice(0, s.length - 1));\n  }\n\n  generate(s: string) {\n    const { weights } = this;\n    let sum = 0;\n    for (let i = 0; i < s.length; i++) {\n      sum += parseInt(s[i]) * weights[i];\n    }\n    const num = (12 - (sum % 11)) % 11;\n    if (num < 10) {\n      return num.toString();\n    } else {\n      return 'X';\n    }\n  }\n}\n"],"names":["Mod11Checksum","weights","instance","get","verify","s","at","generate","slice","length","sum","i","parseInt","num","toString"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;CAEC,GACD,OAAO,MAAMA;IACXC,UAAU;QAAC;QAAG;QAAG;QAAI;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAG;QAAI;QAAG;QAAG;QAAG;QAAG;KAAE,CAAC;IACnE,OAAeC,SAAwB;IAEvC,OAAOC,MAAM;QACX,OAAO,IAAI,CAACD,QAAQ,IAAK,CAAA,IAAI,CAACA,QAAQ,GAAG,IAAIF,eAAc;IAC7D;IAEAI,OAAOC,CAAS,EAAE;QAChB,OAAOA,EAAEC,EAAE,CAAC,CAAC,OAAO,IAAI,CAACC,QAAQ,CAACF,EAAEG,KAAK,CAAC,GAAGH,EAAEI,MAAM,GAAG;IAC1D;IAEAF,SAASF,CAAS,EAAE;QAClB,MAAM,EAAEJ,OAAO,EAAE,GAAG,IAAI;QACxB,IAAIS,MAAM;QACV,IAAK,IAAIC,IAAI,GAAGA,IAAIN,EAAEI,MAAM,EAAEE,IAAK;YACjCD,OAAOE,SAASP,CAAC,CAACM,EAAE,IAAIV,OAAO,CAACU,EAAE;QACpC;QACA,MAAME,MAAM,AAAC,CAAA,KAAMH,MAAM,EAAE,IAAK;QAChC,IAAIG,MAAM,IAAI;YACZ,OAAOA,IAAIC,QAAQ;QACrB,OAAO;YACL,OAAO;QACT;IACF;AACF"}

package/lib/cn/uscc/Mod31Checksum.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/cn/uscc/Mod31Checksum.ts"],"sourcesContent":["/**\n * GB/T 17710（采ISO 7064）的模31校验码\n *\n * Mod31-3\n */\nexport class Mod31Checksum {\n  weights = [1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28];\n  chars = '0123456789ABCDEFGHJKLMNPQRTUWXY';\n  numbers: Record<string, number> = this.chars.split('').reduce(\n    (acc, cur, i) => {\n      acc[cur] = i;\n      return acc;\n    },\n    {} as Record<string, number>,\n  );\n\n  private static instance: Mod31Checksum;\n\n  static get() {\n    return this.instance || (this.instance = new Mod31Checksum());\n  }\n\n  toChar(n: number) {\n    return this.chars[n];\n  }\n\n  toNumber(c: string) {\n    return this.numbers[c];\n  }\n\n  verify(s: string) {\n    return s.at(-1) === this.generate(s.slice(0, s.length - 1));\n  }\n\n  generate(s: string) {\n    let sum = 0;\n    for (let i = 0; i < s.length; i++) {\n      sum += this.numbers[s[i]] * this.weights[i];\n    }\n    return this.toChar(31 - (sum % 31));\n  }\n}\n"],"names":["Mod31Checksum","weights","chars","numbers","split","reduce","acc","cur","i","instance","get","toChar","n","toNumber","c","verify","s","at","generate","slice","length","sum"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA;;;;CAIC,GACD,OAAO,MAAMA;IACXC,UAAU;QAAC;QAAG;QAAG;QAAG;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAI;QAAG;QAAI;QAAI;QAAI;KAAG,CAAC;IAC3EC,QAAQ,kCAAkC;IAC1CC,UAAkC,IAAI,CAACD,KAAK,CAACE,KAAK,CAAC,IAAIC,MAAM,CAC3D,CAACC,KAAKC,KAAKC;QACTF,GAAG,CAACC,IAAI,GAAGC;QACX,OAAOF;IACT,GACA,CAAC,GACD;IAEF,OAAeG,SAAwB;IAEvC,OAAOC,MAAM;QACX,OAAO,IAAI,CAACD,QAAQ,IAAK,CAAA,IAAI,CAACA,QAAQ,GAAG,IAAIT,eAAc;IAC7D;IAEAW,OAAOC,CAAS,EAAE;QAChB,OAAO,IAAI,CAACV,KAAK,CAACU,EAAE;IACtB;IAEAC,SAASC,CAAS,EAAE;QAClB,OAAO,IAAI,CAACX,OAAO,CAACW,EAAE;IACxB;IAEAC,OAAOC,CAAS,EAAE;QAChB,OAAOA,EAAEC,EAAE,CAAC,CAAC,OAAO,IAAI,CAACC,QAAQ,CAACF,EAAEG,KAAK,CAAC,GAAGH,EAAEI,MAAM,GAAG;IAC1D;IAEAF,SAASF,CAAS,EAAE;QAClB,IAAIK,MAAM;QACV,IAAK,IAAIb,IAAI,GAAGA,IAAIQ,EAAEI,MAAM,EAAEZ,IAAK;YACjCa,OAAO,IAAI,CAAClB,OAAO,CAACa,CAAC,CAACR,EAAE,CAAC,GAAG,IAAI,CAACP,OAAO,CAACO,EAAE;QAC7C;QACA,OAAO,IAAI,CAACG,MAAM,CAAC,KAAMU,MAAM;IACjC;AACF"}

package/src/asyncs/sleep.ts

@@ -1 +0,0 @@
-export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));