@wener/utils 1.1.31 → 1.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.31",
+  "version": "1.1.33",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {
@@ -10,16 +10,44 @@
   "homepage": "https://github.com/wenerme/wode#readme",
   "author": "wener",
   "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./lib/index.js"
+    },
+    "./types": "./src/types.d.ts",
+    "./server": {
+      "types": "./src/server/index.ts",
+      "default": "./lib/server/index.js"
+    },
+    "./server/node-fetch": {
+      "types": "./src/server/node-fetch.ts",
+      "default": "./lib/server/node-fetch.js"
+    },
+    "./server/jsdom": {
+      "types": "./src/server/jsdom.ts",
+      "default": "./lib/server/jsdom.js"
+    },
+    "./server/ws": {
+      "types": "./src/server/ws.ts",
+      "default": "./lib/server/ws.js"
+    },
+    "./schema/typebox": {
+      "types": "./src/schema/typebox/index.ts",
+      "default": "./lib/schema/typebox/index.js"
+    },
+    "./schema/typebox/gen": {
+      "types": "./src/schema/typebox/gen/index.ts",
+      "default": "./lib/schema/typebox/gen/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "index.ts",
     "lib",
-    "server",
-    "schema",
-    "server.ts",
     "src",
-    "tsconfig.json",
-    "types.d.ts"
+    "tsconfig.json"
   ],
   "keywords": [
     "utils",
@@ -40,13 +68,13 @@
     }
   },
   "devDependencies": {
-    "@sinclair/typebox": "^0.32.8",
+    "@sinclair/typebox": "^0.32.15",
     "@types/lodash": "^4.14.202",
     "@types/ws": "^8.5.10",
-    "https-proxy-agent": "^7.0.2",
+    "https-proxy-agent": "^7.0.4",
     "lodash": "^4.17.21",
     "node-fetch": "^3.3.2",
-    "undici": "^6.3.0",
+    "undici": "^6.7.0",
     "zod": "^3.22.4"
   },
   "publishConfig": {
@@ -54,70 +82,10 @@
     "access": "public"
   },
   "sideEffects": false,
-  "rollup": {
-    "input": [
-      "./src/index.ts",
-      "./src/server.ts",
-      "./src/servers/ws.ts",
-      "./src/servers/jsdom.ts",
-      "./src/servers/node-fetch.ts",
-      "./src/schema/typebox/index.ts",
-      "./src/schema/typebox/gen/index.ts"
-    ],
-    "external": [
-      "crypto",
-      "jsdom",
-      "node-fetch",
-      "ws",
-      "https-proxy-agent",
-      "undici",
-      "zod",
-      "typescript",
-      "@sinclair/typebox"
-    ]
-  },
   "scripts": {
     "build": "make prepublish",
     "clean": "make clean",
     "dev": "make dev",
     "test": "make test"
-  },
-  "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "typescript": "./src/index.ts",
-      "system": "./dist/system/index.js",
-      "import": "./lib/index.js"
-    },
-    "./types": {
-      "types": "./types.d.ts"
-    },
-    "./server": {
-      "types": "./src/server.ts",
-      "typescript": "./src/server.ts",
-      "system": "./dist/system/server.js",
-      "import": "./lib/server.js"
-    },
-    "./server/node-fetch": {
-      "types": "./server/node-fetch.ts",
-      "default": "./lib/servers/node-fetch.js"
-    },
-    "./server/jsdom": {
-      "types": "./server/jsdom.ts",
-      "default": "./lib/servers/jsdom.js"
-    },
-    "./server/ws": {
-      "types": "./server/ws.ts",
-      "default": "./lib/servers/ws.js"
-    },
-    "./schema/typebox": {
-      "types": "./schema/typebox/index.ts",
-      "default": "./lib/schema/typebox/index.js"
-    },
-    "./schema/typebox/gen": {
-      "types": "./schema/typebox/gen/index.ts",
-      "default": "./lib/schema/typebox/gen/index.js"
-    },
-    "./package.json": "./package.json"
   }
 }

package/src/asyncs/nextOfAsyncIterator.ts

@@ -2,12 +2,16 @@ import { MaybePromise } from './MaybePromise';
 import { isIterator } from './isIterator';
 import { isPromise } from './isPromise';
 
+type IteratorLike<T> = Iterable<T> | Iterator<T>;
+type AsyncIteratorLike<T> = AsyncIterable<T> | AsyncIterator<T> | AsyncIterableIterator<T> | IteratorLike<T>;
+
 export function nextOfAsyncIterator<T>(
-  it: MaybePromise<AsyncIterator<T> | Iterator<T> | T>,
+  it: MaybePromise<AsyncIterable<T> | Iterable<T> | AsyncIterator<T> | Iterator<T> | T>,
 ): MaybePromise<[value: T, done?: boolean]> {
   if (isPromise(it)) {
     return it.then((v) => nextOfAsyncIterator(v));
   }
+
   if (isIterator(it)) {
     let next = it.next();
     if (isPromise(next)) {
@@ -15,5 +19,13 @@ export function nextOfAsyncIterator<T>(
     }
     return [next.value, next.done];
   }
+  if (it && typeof it === 'object') {
+    if (Symbol.iterator in it) {
+      return nextOfAsyncIterator(it[Symbol.iterator]());
+    }
+    if (Symbol.asyncIterator in it) {
+      return nextOfAsyncIterator(it[Symbol.asyncIterator]());
+    }
+  }
   return [it];
 }

package/src/asyncs/timeout.ts

@@ -1,23 +1,26 @@
-export function timeout<T = any>(v: Promise<T>, ms: number): Promise<T> {
+export function timeout<T = any>(
+  v: Promise<T> | ((args: { signal: AbortSignal }) => Promise<T>),
+  ms: number,
+): Promise<T> {
   const error = new TimeoutError();
   let timeout: any;
-  return Promise.race([
+  let ac: AbortController | undefined;
+  if (typeof v === 'function') {
+    ac = new AbortController();
+    v = v({ signal: ac.signal });
+  }
+
+  return Promise.race<T>([
     v,
     new Promise((_resolve, reject) => {
       timeout = setTimeout(() => {
+        ac?.abort(error);
         reject(error);
       }, ms);
     }),
-  ]).then(
-    (v) => {
-      clearTimeout(timeout);
-      return v;
-    },
-    (e) => {
-      clearTimeout(timeout);
-      throw e;
-    },
-  ) as Promise<T>;
+  ]).finally(() => {
+    clearTimeout(timeout);
+  });
 }
 
 export class TimeoutError extends Error {

package/src/cn/index.ts

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

package/src/cn/parseChineseNumber.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from 'vitest';
+import { parseChineseNumber } from './parseChineseNumber';
+
+test('parseChineseNumber', () => {
+  for (const [a, b] of [
+    ['0', 0],
+    ['10000', 10_000],
+    ['123', 123],
+    ['一万', 10_000],
+    ['一万一', 10_001],
+    ['一万一百一', 10_101],
+    ['一万零一百零一', 10_101],
+    ['一千零一十', 1010],
+    ['一千零一十一', 1011],
+    ['一捌玖', 189],
+    ['一百一', 101],
+    ['一百九十二', 192],
+    ['捌玖', 89],
+    ['捌玖零', 890],
+    ['零捌玖', 89],
+  ] as const) {
+    expect(parseChineseNumber(a)).toBe(b);
+  }
+});

package/src/cn/parseChineseNumber.ts

@@ -0,0 +1,97 @@
+const ToNumber: Record<string, number> = {
+  〇: 0,
+  一: 1,
+  二: 2,
+  三: 3,
+  四: 4,
+  五: 5,
+  六: 6,
+  七: 7,
+  八: 8,
+  九: 9,
+  十: 10,
+  百: 100,
+  千: 1000,
+  万: 10_000,
+  零: 0,
+  壹: 1,
+  贰: 2,
+  叁: 3,
+  肆: 4,
+  伍: 5,
+  陆: 6,
+  柒: 7,
+  捌: 8,
+  玖: 9,
+  拾: 10,
+  佰: 100,
+  仟: 1000,
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  8: 8,
+  9: 9,
+};
+
+// 一万一 -> 10001
+// 一万一百一 -> 10101
+// 一万 -> 10000
+// 10000 -> 10000
+export function parseChineseNumber(s: string | number) {
+  if (typeof s === 'number') {
+    return s;
+  }
+
+  let n = 0;
+  let c = 0;
+  let base = 0;
+  let shouldAddLast = false;
+  for (const char of s.split('').reverse()) {
+    c = ToNumber[char];
+    if (c === undefined) {
+      throw new Error(`无法解析的数字: ${char}`);
+    }
+
+    switch (c) {
+      case 10: {
+        base = 1;
+        break;
+      }
+
+      case 100: {
+        base = 2;
+        break;
+      }
+
+      case 1000: {
+        base = 3;
+        break;
+      }
+
+      case 10_000: {
+        base = 4;
+        break;
+      }
+    }
+
+    //
+    if (c < 10) {
+      n += c * 10 ** base;
+      base++;
+      shouldAddLast = false;
+    } else {
+      shouldAddLast = true;
+    }
+  }
+
+  if (shouldAddLast) {
+    n += c;
+  }
+
+  return n;
+}

package/src/crypto/getRandomValues.ts

@@ -11,9 +11,11 @@ export let getRandomValues: <T extends Exclude<TypedArray, Float32Array | Float6
 
 function _getRandomValues<T extends Exclude<TypedArray, Float32Array | Float64Array>>(buf: T) {
   const nodeCrypto = getNodeCrypto();
-  if (nodeCrypto?.webcrypto?.getRandomValues) {
-    getRandomValues = nodeCrypto?.webcrypto?.getRandomValues?.bind(nodeCrypto?.webcrypto);
-    return nodeCrypto.webcrypto.getRandomValues(buf);
+  // avoid type error
+  let wc = nodeCrypto?.webcrypto as any;
+  if (wc?.getRandomValues) {
+    getRandomValues = wc.getRandomValues?.bind(nodeCrypto?.webcrypto);
+    return wc.getRandomValues(buf);
   }
   if (nodeCrypto?.randomBytes) {
     if (!(buf instanceof Uint8Array)) {

package/src/crypto/hashing.test.ts

@@ -1,6 +1,6 @@
 import { assert, beforeAll, expect, test } from 'vitest';
 import { ArrayBuffers } from '../io/ArrayBuffers';
-import { polyfillCrypto } from '../servers/polyfill/polyfillCrypto';
+import { polyfillCrypto } from '../server/polyfill/polyfillCrypto';
 import { isUUID } from '../validations/isUUID';
 import { hex } from './base';
 import { hmac, sha1, sha256, sha384, sha512 } from './hashing';

package/src/errors/Errors.test.ts

@@ -0,0 +1,22 @@
+import { test } from 'vitest';
+import { Errors } from './Errors';
+
+test('Errors', () => {
+  {
+    let a: string | undefined = '';
+    Errors.NotFound.check(a);
+    let b: string = a;
+    hole(b);
+  }
+  if (false) {
+    // 不能同时 asserts 且返回
+    // https://stackoverflow.com/a/73252858/1870054
+    // https://github.com/microsoft/TypeScript/issues/34636
+    let a: string | undefined;
+    Errors.NotFound.require(a);
+    // let c: string = a;
+    // hole(c);
+  }
+});
+
+function hole(..._: any[]) {}

package/src/errors/Errors.ts

@@ -147,9 +147,6 @@ export interface ErrorDetail {
 
   require<T>(v: T | undefined, o?: Partial<ErrorDetailInit> | string): NonNullable<T>;
 
-  // 不支持 return value
-  // https://stackoverflow.com/a/73252858/1870054
-
   check(condition: boolean, o?: Partial<ErrorDetailInit> | string): asserts condition;
 
   check<T>(v: T | undefined | null, o?: Partial<ErrorDetailInit> | string): asserts v is NonNullable<T>;
@@ -160,7 +157,7 @@ export class Errors {
   static Unauthorized: ErrorDetail = this.with({ status: 403 });
   static Forbidden: ErrorDetail = this.with({ status: 403 });
   static NotFound: ErrorDetail = this.with({ status: 404 });
-  static InternalServerError: ErrorDetail = this.with({ status: 501 });
+  static InternalServerError: ErrorDetail = this.with({ status: 500 });
   static NotImplemented: ErrorDetail = this.with({ status: 501 });
   static ServiceUnavailable: ErrorDetail = this.with({ status: 503 });
 

package/src/index.ts

@@ -42,6 +42,8 @@ export { isPlainObject } from './langs/isPlainObject';
 export { parseBoolean } from './langs/parseBoolean';
 export { maybeFunction, type MaybeFunction } from './langs/MaybeFunction';
 export { memoize } from './langs/memoize';
+export { AsyncCloser } from './langs/AsyncCloser';
+export { Closer } from './langs/Closer';
 
 export { isUUID } from './validations/isUUID';
 export { parseTimestamp } from './validations/parseTimestamp';

package/src/io/Bytes.ts

@@ -0,0 +1,64 @@
+const objectToString = Object.prototype.toString;
+const uint8ArrayStringified = '[object Uint8Array]';
+
+/**
+ * Utils for UInt8Array
+ *
+ * @see https://github.com/sindresorhus/uint8array-extras/blob/main/index.js
+ */
+export class Bytes {
+  static #decoder = new globalThis.TextDecoder();
+
+  static isUint8Array(value: any): value is Uint8Array {
+    if (!value) {
+      return false;
+    }
+
+    if (value.constructor === Uint8Array) {
+      return true;
+    }
+
+    return objectToString.call(value) === uint8ArrayStringified;
+  }
+
+  static require(value: any): Uint8Array {
+    if (!this.isUint8Array(value)) {
+      throw new TypeError(`Expected \`Uint8Array\`, got \`${typeof value}\``);
+    }
+    return value;
+  }
+
+  static toUint8Array(value: ArrayBuffer | ArrayBufferView): Uint8Array {
+    if (value instanceof ArrayBuffer) {
+      return new Uint8Array(value);
+    }
+
+    if (ArrayBuffer.isView(value)) {
+      return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+
+    throw new TypeError(`Unsupported value, got \`${typeof value}\`.`);
+  }
+
+  static concat(arrays: Uint8Array[], totalLength: number): Uint8Array {
+    if (arrays.length === 0) {
+      return new Uint8Array(0);
+    }
+
+    totalLength ??= arrays.reduce((accumulator, currentValue) => accumulator + currentValue.length, 0);
+
+    const returnValue = new Uint8Array(totalLength);
+
+    let offset = 0;
+    for (const array of arrays) {
+      returnValue.set(this.require(array), offset);
+      offset += array.length;
+    }
+
+    return returnValue;
+  }
+
+  static toString(value: Uint8Array) {
+    return this.#decoder.decode(value);
+  }
+}

package/src/isomorphics/structuredClone.ts

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

package/src/langs/AsyncCloser.ts

@@ -0,0 +1,45 @@
+type AsyncClosable = { close(): void | Promise<void> } | (() => void | Promise<void>) | AsyncDisposable | Disposable;
+
+/**
+ * @see AsyncDisposableStack
+ */
+export class AsyncCloser implements AsyncDisposable {
+  closers: Array<AsyncClosable> = [];
+
+  defer(closer: AsyncClosable | null | undefined) {
+    if (!closer) {
+      return;
+    }
+    this.closers.push(closer);
+  }
+
+  add<T extends AsyncClosable | null | undefined>(closer: T): T {
+    if (!closer) {
+      return closer;
+    }
+    this.closers.push(closer);
+    return closer;
+  }
+
+  async [Symbol.asyncDispose]() {
+    for (let closer of this.closers) {
+      let o;
+      if (typeof closer === 'function') {
+        o = closer();
+      } else if (Symbol.asyncDispose in closer) {
+        o = closer[Symbol.asyncDispose]();
+      } else if (Symbol.dispose in closer) {
+        closer[Symbol.dispose]();
+      } else {
+        o = closer.close();
+      }
+      if (o && typeof o.then === 'function') {
+        await o;
+      }
+    }
+  }
+
+  close() {
+    return this[Symbol.asyncDispose]();
+  }
+}

package/src/langs/Closer.ts

@@ -0,0 +1,39 @@
+type Closable = { close(): void } | (() => void) | Disposable;
+
+/**
+ * @see DisposableStack
+ */
+export class Closer implements Disposable {
+  closers: Array<Closable> = [];
+
+  defer(closer: Closable | null | undefined) {
+    if (!closer) {
+      return;
+    }
+    this.closers.push(closer);
+  }
+
+  add<T extends Closable | null | undefined>(closer: T): T {
+    if (!closer) {
+      return closer;
+    }
+    this.closers.push(closer);
+    return closer;
+  }
+
+  [Symbol.dispose]() {
+    for (let closer of this.closers) {
+      if (typeof closer === 'function') {
+        closer();
+      } else if (Symbol.dispose in closer) {
+        closer[Symbol.dispose]();
+      } else {
+        closer.close();
+      }
+    }
+  }
+
+  close() {
+    this[Symbol.dispose]();
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,6 @@
+export { polyfillCrypto } from './polyfill/polyfillCrypto';
+export { createFetchWithProxyByUndici } from './fetch/createFetchWithProxyByUndici';
+export { createFetchWithProxy } from './fetch/createFetchWithProxy';
+
+export { md5 } from './crypto/md5';
+export { getPackageDir } from './getPackageDir';

package/src/{servers → server}/polyfill/polyfillWebSocket.ts

@@ -8,6 +8,11 @@ export function polyfillWebSocket(ws?: any): MaybePromise<boolean> {
   if ('WebSocket' in globalThis) {
     return false;
   }
+  if ('then' in ws) {
+    return ws.then((v: any) => {
+      return polyfillWebSocket(v?.default || v);
+    });
+  }
   if (ws) {
     const { WebSocket } = ws;
     Object.assign(globalThis, { WebSocket });

package/src/{types/index.d.ts → types.d.ts}

@@ -1,3 +1,15 @@
+declare var __DEV__: boolean;
+
+namespace NodeJS {
+  interface Process {
+    // webpack check
+    readonly browser?: boolean;
+  }
+  interface ProcessEnv {
+    readonly NODE_ENV: 'development' | 'production' | 'test';
+  }
+}
+
 export type AbstractConstructor<T = unknown> = abstract new (...args: any[]) => T;
 export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "moduleResolution": "node",
+    "moduleResolution": "bundler",
     "target": "ESNext",
     "module": "ESNext",
     "lib": [
@@ -15,17 +15,19 @@
     "allowSyntheticDefaultImports": true,
     "noImplicitAny": true,
     "noImplicitReturns": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
     "pretty": true,
     "removeComments": false,
-    "stripInternal": true
+    "stripInternal": true,
+    "isolatedModules": true,
+    "outDir": "lib"
   },
   "exclude": [
     "node_modules"
   ],
   "include": [
-    "types.d.ts",
+    "src/types.d.ts",
     "src"
   ]
 }

package/index.ts

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