@wener/utils 1.1.20 → 1.1.22

package/lib/index.js

@@ -8,6 +8,7 @@ export { createLazyPromise } from './asyncs/createLazyPromise.js';
 export { clearAsyncInterval, setAsyncInterval } from './asyncs/AsyncInterval.js';
 export { createAsyncIterator } from './asyncs/createAsyncIterator.js';
 export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator.js';
+export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator.js';
 export { isIterator } from './asyncs/isIterator.js';
 export { sleep } from './asyncs/sleep.js';
 export { TimeoutError, timeout } from './asyncs/timeout.js';
@@ -47,6 +48,7 @@ export { structuredClone } from './isomorphics/structuredClone.js';
 export { randomUUID } from './crypto/randomUUID.js';
 export { getRandomValues } from './crypto/getRandomValues.js';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing.js';
+export { md5 } from './crypto/md5.js';
 export { hex } from './crypto/base.js';
 export { createULID, isULID, parseULID, ulid } from './crypto/ulid.js';
 export { PEM } from './crypto/pem/pem.js';
@@ -56,5 +58,6 @@ export { createFetchWithLogging } from './fetch/createFetchWithLogging.js';
 export { dumpRequest } from './fetch/dumpRequest.js';
 export { dumpResponse } from './fetch/dumpResponse.js';
 export { default as ms } from './libs/ms.js';
-export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator.js';
+export { DetailError, Errors } from './errors/Errors.js';
+export { getHttpStatusText, isRetryableHttpStatus } from './http/HttpStatus.js';
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/logging/createLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"createLogger.js","sources":["../../src/logging/createLogger.ts"],"sourcesContent":["import type { LoggerWithChild, LogLevel } from './Logger';\n\nexport function createLogger(\n  write: (o: { level: LogLevel; values: any[] } & Record<string | symbol, any>) => void = ({\n    level,\n    values,\n    ...ctx\n  }) => {\n    ({ values, ...ctx } = merge(ctx, values));\n    console[level]?.(...values, ctx);\n  },\n  context: object = {},\n): LoggerWithChild {\n  return {\n    trace: (...values) => {\n      write({ ...context, level: 'trace', values });\n    },\n    debug: (...values) => {\n      write({ ...context, level: 'debug', values });\n    },\n    info: (...values) => {\n      write({ ...context, level: 'info', values });\n    },\n    warn: (...values) => {\n      write({ ...context, level: 'warn', values });\n    },\n    error: (...values) => {\n      write({ ...context, level: 'error', values });\n    },\n    child: (ctx) => createLogger(write, { ...context, ...ctx }),\n  };\n}\n\n// logger.info({name:'wener'},'message')\n// merge initial context with message object\nfunction merge(ctx: any, values: any[]) {\n  if (values[0] && typeof values[0] === 'object') {\n    return { ...ctx, ...values[0], values: values.slice(1) };\n  }\n  return { ...ctx, values };\n}\n"],"names":[],"mappings":"AAEgB,SAAA,YAAA,CACd,QAAwF,CAAC;AAAA,EACvF,KAAA;AAAA,EACA,MAAA;AAAA,EACA,GAAG,GAAA;AACL,CAAM,KAAA;AAPR,EAAA,IAAA,EAAA,CAAA;AAQI,EAAA,CAAC,EAAE,MAAQ,EAAA,GAAG,KAAQ,GAAA,KAAA,CAAM,KAAK,MAAM,CAAA,EAAA;AACvC,EAAQ,CAAA,EAAA,GAAA,OAAA,CAAA,KAAA,CAAA,KAAR,IAAiB,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA,OAAA,EAAA,GAAG,MAAQ,EAAA,GAAA,CAAA,CAAA;AAC9B,CACA,EAAA,OAAA,GAAkB,EACD,EAAA;AACjB,EAAO,OAAA;AAAA,IACL,KAAA,EAAO,IAAI,MAAW,KAAA;AACpB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,OAAA,EAAS,QAAQ,CAAA,CAAA;AAAA,KAC9C;AAAA,IACA,KAAA,EAAO,IAAI,MAAW,KAAA;AACpB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,OAAA,EAAS,QAAQ,CAAA,CAAA;AAAA,KAC9C;AAAA,IACA,IAAA,EAAM,IAAI,MAAW,KAAA;AACnB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,MAAA,EAAQ,QAAQ,CAAA,CAAA;AAAA,KAC7C;AAAA,IACA,IAAA,EAAM,IAAI,MAAW,KAAA;AACnB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,MAAA,EAAQ,QAAQ,CAAA,CAAA;AAAA,KAC7C;AAAA,IACA,KAAA,EAAO,IAAI,MAAW,KAAA;AACpB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,OAAA,EAAS,QAAQ,CAAA,CAAA;AAAA,KAC9C;AAAA,IACA,KAAA,EAAO,CAAC,GAAA,KAAQ,YAAa,CAAA,KAAA,EAAO,EAAE,GAAG,OAAA,EAAS,GAAG,GAAA,EAAK,CAAA;AAAA,GAC5D,CAAA;AACF,CAAA;AAIA,SAAS,KAAA,CAAM,KAAU,MAAe,EAAA;AACtC,EAAA,IAAI,OAAO,CAAC,CAAA,IAAK,OAAO,MAAO,CAAA,CAAC,MAAM,QAAU,EAAA;AAC9C,IAAO,OAAA,EAAE,GAAG,GAAA,EAAK,GAAG,MAAA,CAAO,CAAC,CAAA,EAAG,MAAQ,EAAA,MAAA,CAAO,KAAM,CAAA,CAAC,CAAE,EAAA,CAAA;AAAA,GACzD;AACA,EAAO,OAAA,EAAE,GAAG,GAAA,EAAK,MAAO,EAAA,CAAA;AAC1B;;;;"}
+{"version":3,"file":"createLogger.js","sources":["../../src/logging/createLogger.ts"],"sourcesContent":["import type { LoggerWithChild, LogLevel } from './Logger';\n\nexport interface CreateLoggerOptions {\n  name?: string;\n  handler?: (o: { level: LogLevel; values: any[] } & Record<string | symbol, any>) => void;\n  context?: Record<string, any>;\n  levels?: LogLevel[];\n}\n\nexport function createLogger(\n  write: (o: { level: LogLevel; values: any[] } & Record<string | symbol, any>) => void = ({\n    level,\n    values,\n    ...ctx\n  }) => {\n    ({ values, ...ctx } = merge(ctx, values));\n    console[level]?.(...values, ctx);\n  },\n  context: object = {},\n): LoggerWithChild {\n  return {\n    trace: (...values) => {\n      write({ ...context, level: 'trace', values });\n    },\n    debug: (...values) => {\n      write({ ...context, level: 'debug', values });\n    },\n    info: (...values) => {\n      write({ ...context, level: 'info', values });\n    },\n    warn: (...values) => {\n      write({ ...context, level: 'warn', values });\n    },\n    error: (...values) => {\n      write({ ...context, level: 'error', values });\n    },\n    child: (ctx) => createLogger(write, { ...context, ...ctx }),\n  };\n}\n\n// logger.info({name:'wener'},'message')\n// merge initial context with message object\nfunction merge(ctx: any, values: any[]) {\n  if (values[0] && typeof values[0] === 'object') {\n    return { ...ctx, ...values[0], values: values.slice(1) };\n  }\n  return { ...ctx, values };\n}\n\n// https://github.com/nestjs/nest/blob/master/packages/common/services/console-logger.service.ts\n"],"names":[],"mappings":"AASgB,SAAA,YAAA,CACd,QAAwF,CAAC;AAAA,EACvF,KAAA;AAAA,EACA,MAAA;AAAA,EACA,GAAG,GAAA;AACL,CAAM,KAAA;AAdR,EAAA,IAAA,EAAA,CAAA;AAeI,EAAA,CAAC,EAAE,MAAQ,EAAA,GAAG,KAAQ,GAAA,KAAA,CAAM,KAAK,MAAM,CAAA,EAAA;AACvC,EAAQ,CAAA,EAAA,GAAA,OAAA,CAAA,KAAA,CAAA,KAAR,IAAiB,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAA,CAAA,OAAA,EAAA,GAAG,MAAQ,EAAA,GAAA,CAAA,CAAA;AAC9B,CACA,EAAA,OAAA,GAAkB,EACD,EAAA;AACjB,EAAO,OAAA;AAAA,IACL,KAAA,EAAO,IAAI,MAAW,KAAA;AACpB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,OAAA,EAAS,QAAQ,CAAA,CAAA;AAAA,KAC9C;AAAA,IACA,KAAA,EAAO,IAAI,MAAW,KAAA;AACpB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,OAAA,EAAS,QAAQ,CAAA,CAAA;AAAA,KAC9C;AAAA,IACA,IAAA,EAAM,IAAI,MAAW,KAAA;AACnB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,MAAA,EAAQ,QAAQ,CAAA,CAAA;AAAA,KAC7C;AAAA,IACA,IAAA,EAAM,IAAI,MAAW,KAAA;AACnB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,MAAA,EAAQ,QAAQ,CAAA,CAAA;AAAA,KAC7C;AAAA,IACA,KAAA,EAAO,IAAI,MAAW,KAAA;AACpB,MAAA,KAAA,CAAM,EAAE,GAAG,OAAA,EAAS,KAAO,EAAA,OAAA,EAAS,QAAQ,CAAA,CAAA;AAAA,KAC9C;AAAA,IACA,KAAA,EAAO,CAAC,GAAA,KAAQ,YAAa,CAAA,KAAA,EAAO,EAAE,GAAG,OAAA,EAAS,GAAG,GAAA,EAAK,CAAA;AAAA,GAC5D,CAAA;AACF,CAAA;AAIA,SAAS,KAAA,CAAM,KAAU,MAAe,EAAA;AACtC,EAAA,IAAI,OAAO,CAAC,CAAA,IAAK,OAAO,MAAO,CAAA,CAAC,MAAM,QAAU,EAAA;AAC9C,IAAO,OAAA,EAAE,GAAG,GAAA,EAAK,GAAG,MAAA,CAAO,CAAC,CAAA,EAAG,MAAQ,EAAA,MAAA,CAAO,KAAM,CAAA,CAAC,CAAE,EAAA,CAAA;AAAA,GACzD;AACA,EAAO,OAAA,EAAE,GAAG,GAAA,EAAK,MAAO,EAAA,CAAA;AAC1B;;;;"}

package/lib/server.js

@@ -1,7 +1,4 @@
 export { polyfillCrypto } from './servers/polyfill/polyfillCrypto.js';
-export { polyfillJsDom } from './servers/polyfill/polyfillJsDom.js';
-export { polyfillBrowser } from './servers/polyfill/polyfillBrowser.js';
-export { polyfillWebSocket } from './servers/polyfill/polyfillWebSocket.js';
 export { createFetchWithProxyByUndici } from './servers/fetch/createFetchWithProxyByUndici.js';
 export { createFetchWithProxy } from './servers/fetch/createFetchWithProxy.js';
 export { createFetchWithRetry } from './servers/fetch/createFetchWithRetry.js';

package/lib/server.js.map

@@ -1 +1 @@
-{"version":3,"file":"server.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}
+{"version":3,"file":"server.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {
@@ -14,9 +14,11 @@
     "dist",
     "index.ts",
     "lib",
+    "server",
     "server.ts",
     "src",
-    "tsconfig.json"
+    "tsconfig.json",
+    "types.d.ts"
   ],
   "keywords": [
     "utils",
@@ -37,12 +39,12 @@
     }
   },
   "devDependencies": {
-    "@types/lodash": "^4.14.196",
-    "@types/ws": "^8.5.5",
-    "https-proxy-agent": "^7.0.1",
+    "@types/lodash": "^4.14.199",
+    "@types/ws": "^8.5.7",
+    "https-proxy-agent": "^7.0.2",
     "lodash": "^4.17.21",
     "node-fetch": "^3.3.2",
-    "undici": "^5.23.0"
+    "undici": "^5.25.4"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -58,6 +60,7 @@
       "crypto",
       "jsdom",
       "node-fetch",
+      "ws",
       "undici"
     ]
   },
@@ -83,7 +86,18 @@
       "system": "./dist/system/server.js",
       "import": "./lib/server.js"
     },
-    "./src/*": "./src/*",
+    "./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"
+    },
     "./package.json": "./package.json"
   }
 }

package/server/jsdom.ts

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

package/server/node-fetch.ts

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

package/server/ws.ts

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

package/src/asyncs/createAsyncIterator.ts

@@ -1,12 +1,15 @@
-import { createLazyPromise, LazyPromise } from './createLazyPromise';
+import { type MaybePromise } from './MaybePromise';
+import { createLazyPromise, type LazyPromise } from './createLazyPromise';
+
+type Val<T> = [val: MaybePromise<T> | undefined, done: boolean, err?: any];
 
 export function createAsyncIterator<T>(
-  fn: (next: (val: [T | undefined, boolean] | undefined, err?: any) => void) => void,
-) {
-  const values: Array<Promise<[val: T | undefined, done: boolean, err?: any]>> = [];
-  let recv: (val: [T | undefined, boolean] | undefined, err?: any) => void;
+  fn: (next: (val: [MaybePromise<T> | undefined, boolean] | undefined, err?: any) => void) => void,
+): AsyncGenerator<T, void, unknown> {
+  const values: Array<Promise<Val<T>>> = [];
+  let recv: (val: [MaybePromise<T> | undefined, boolean] | undefined, err?: any) => void;
   {
-    let next: LazyPromise<[val: T | undefined, done: boolean, err?: any]>;
+    let next: LazyPromise<Val<T>>;
     values.push((next = createLazyPromise()));
     recv = (val, err) => {
       if (err !== undefined) {
@@ -23,7 +26,7 @@ export function createAsyncIterator<T>(
   fn(recv);
 
   return (async function* () {
-    let value: T | undefined;
+    let value: Val<T>[0];
     let err: any;
     for (let i = 0, done = false; !done; i++) {
       let result = await values[i];

package/src/asyncs/createLazyPromise.test.ts

@@ -1,6 +1,5 @@
-import { test, expect } from 'vitest';
+import { expect, test } from 'vitest';
 import { createLazyPromise } from './createLazyPromise';
-import { sleep } from './sleep';
 
 test('basic', async () => {
   const promise = createLazyPromise();
@@ -18,36 +17,38 @@ test('basic', async () => {
 
 test('manual resolve skip exec', async () => {
   const promise = createLazyPromise<number>(() => {
-    expect.fail();
+    expect.fail('should not exec');
   });
   promise.resolve(-1);
   expect(await promise).toBe(-1);
 });
 
-test('exec', async () => {
+test('lazy exec resolve by manual', async () => {
   let r = 0;
   const promise = createLazyPromise((resolve) => {
     r++;
     resolve(10);
   });
-  await sleep(10);
+  await Promise.resolve();
   expect(r).toBe(0);
   expect(await promise).toBe(10);
   expect(r).toBe(1);
   promise.resolve(20);
   expect(await promise).toBe(10);
+  expect(r).toBe(1);
 });
 
-test('exec auto', async () => {
+test('lazy exec resolve by return', async () => {
   let r = 0;
   const promise = createLazyPromise(() => {
     r++;
     return 10;
   });
-  await sleep(10);
+  await Promise.resolve();
   expect(r).toBe(0);
   void promise.then(() => undefined);
-  expect(await promise).toBe(10);
+  await Promise.resolve();
+  // already resolved
   expect(r).toBe(1);
   expect(await promise).toBe(10);
   expect(r).toBe(1);

package/src/asyncs/createLazyPromise.ts

@@ -3,7 +3,7 @@ import { isPromise } from './isPromise';
 
 export type LazyPromise<T> = Promise<T> & {
   reject(reason?: any): void;
-  resolve(v?: T | PromiseLike<T>): void;
+  resolve(v?: MaybePromise<T>): void;
 };
 
 /**

package/src/crypto/md5.bench.ts

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto';
+import { bench, describe } from 'vitest';
+import { md5 } from './md5';
+
+describe('md5', () => {
+  const dataset = new Array(10000).fill(0).map((_, i) => String(Math.random() * i));
+  let iterations = 0;
+  bench(
+    'js',
+    function () {
+      iterations++;
+      md5(dataset[iterations % dataset.length]);
+    },
+    {
+      iterations: 10000,
+    },
+  );
+
+  bench(
+    'native',
+    function () {
+      iterations++;
+      createHash('md5')
+        .update(dataset[iterations % dataset.length])
+        .digest('hex');
+    },
+    {
+      iterations: 10000,
+    },
+  );
+});

package/src/crypto/md5.test.ts

@@ -0,0 +1,8 @@
+import { assert, describe, test } from 'vitest';
+import { md5 } from './md5';
+
+describe('md5', () => {
+  test('js', () => {
+    assert.equal(md5(''), 'd41d8cd98f00b204e9800998ecf8427e');
+  });
+});

package/src/errors/Errors.ts

@@ -0,0 +1,199 @@
+import { getHttpStatusText } from '../http/HttpStatus';
+
+export interface ErrorDetailInit {
+  message?: string;
+  status: number;
+  description?: string;
+  code?: number | string;
+  metadata?: Record<string, any>;
+  cause?: any;
+}
+
+export class DetailError extends Error {
+  readonly status: number;
+  readonly description?: string;
+
+  constructor(readonly detail: ErrorDetail) {
+    super(detail.message, {
+      cause: detail.cause,
+    });
+    this.status = detail.status;
+    this.description = detail.description;
+  }
+
+  toJSON() {
+    return {
+      code: this.detail.code,
+      message: this.message,
+      status: this.status,
+      description: this.description,
+      cause: this.cause,
+    };
+  }
+}
+
+class DetailHolder implements ErrorDetail {
+  readonly message: string;
+  readonly status: number;
+  readonly code: number | string;
+  readonly metadata?: Record<string, any>;
+  readonly description?: string;
+  readonly cause?: any;
+
+  constructor({
+    status,
+    message = getHttpStatusText(status),
+    code = status,
+    metadata,
+    description,
+    cause,
+  }: ErrorDetailInit) {
+    this.message = message ?? String(status);
+    this.status = status;
+    this.code = code;
+    this.description = description;
+    this.metadata = metadata;
+    this.cause = cause;
+  }
+
+  with(o?: Partial<ErrorDetailInit> | string): DetailHolder {
+    if (typeof o === 'string') {
+      o = { message: o };
+    }
+
+    if (o === undefined) {
+      return new DetailHolder(this);
+    }
+
+    return new DetailHolder({
+      status: this.status,
+      code: this.code,
+      message: this.message,
+      metadata: this.metadata,
+      cause: this.cause,
+      ...o,
+    });
+  }
+
+  asError(o?: Partial<ErrorDetailInit> | string): Error {
+    if (typeof o === 'string') {
+      o = { message: o };
+    }
+
+    return new DetailError(this.with(o));
+  }
+
+  require(v: any, o?: Partial<ErrorDetailInit> | string): any {
+    if (v === undefined || v === null) {
+      throw this.asError(o);
+    }
+
+    return v;
+  }
+
+  check(cond: any, o?: Partial<ErrorDetailInit> | string) {
+    switch (cond) {
+      case false:
+      case undefined:
+      case null: {
+        throw this.asError(o);
+      }
+    }
+  }
+
+  throw(o?: Partial<ErrorDetailInit>): never {
+    throw this.asError(o);
+  }
+}
+
+export interface ErrorDetail {
+  readonly message: string;
+  readonly status: number;
+  readonly code?: number | string;
+  readonly metadata?: Record<string, any>;
+  readonly description?: string;
+  readonly cause?: any;
+
+  with(message: string): ErrorDetail;
+
+  with(o?: Partial<ErrorDetailInit>): ErrorDetail;
+
+  asError(o?: Partial<ErrorDetailInit>): Error;
+
+  asError(message: string): Error;
+
+  throw(o?: Partial<ErrorDetailInit>): never;
+
+  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>;
+}
+
+export class Errors {
+  static BadRequest: ErrorDetail = this.with({ status: 400 });
+  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 NotImplemented: ErrorDetail = this.with({ status: 501 });
+  static ServiceUnavailable: ErrorDetail = this.with({ status: 503 });
+
+  static with(init: ErrorDetailInit): ErrorDetail {
+    return new DetailHolder(init);
+  }
+
+  static ok(res: Response, o?: Partial<ErrorDetailInit>) {
+    if (res.ok) {
+      return res;
+    }
+    throw this.with({
+      description: res.statusText,
+      status: res.status,
+      ...o,
+      metadata: {
+        ...o?.metadata,
+        response: res,
+      },
+    }).asError();
+  }
+
+  static resolve(e: any): ErrorDetail {
+    if (e instanceof DetailHolder) {
+      return e;
+    }
+
+    if (e instanceof DetailError) {
+      return e.detail;
+    }
+
+    if (e instanceof Error) {
+      const { message, code, status } = e as any;
+      // can get status from NestJS HttpException
+      return new DetailHolder({
+        message,
+        status: parseInt(status) || 500,
+        code,
+        cause: e,
+      });
+    }
+
+    return new DetailHolder({
+      message: e.message,
+      status: 500,
+      cause: e,
+    });
+  }
+}
+
+// interface ZodError {
+//   path: Array<string | number>;
+//   message: string;
+//   code: string;
+//   expected?: any;
+//   received?: any;
+// }

package/src/fetch/dumpResponse.ts

@@ -10,9 +10,9 @@ export async function dumpResponse({
   log?: (s: string) => void;
 }) {
   let out = `<- ${res.status} ${res.statusText} ${req.method} ${url}
-  ${Array.from(res.headers.entries())
-    .map(([k, v]) => `${k}: ${v}`)
-    .join('\n')}
+${Array.from(res.headers.entries())
+  .map(([k, v]) => `${k}: ${v}`)
+  .join('\n')}
    `;
   let contentType = res.headers.get('content-type');
   // TODO text/event-stream

package/src/http/HttpStatus.ts

@@ -0,0 +1,96 @@
+// http://httpstat.us/
+// https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+const HttpStatus: Record<string, string> = {
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  103: 'Early Hints',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  208: 'Already Reported',
+  226: 'IM Used',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Found',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  306: 'Unused',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Required',
+  413: 'Request Entry Too Large',
+  414: 'Request-URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Requested Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a teapot",
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  425: 'Too Early',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  506: 'Variant Also Negotiates',
+  507: 'Insufficient Storage',
+  508: 'Loop Detected',
+  509: 'Bandwidth Limit Exceeded',
+  510: 'Not Extended',
+  511: 'Network Authentication Required',
+};
+
+export function getHttpStatusText(status: number | string): string | undefined {
+  return HttpStatus[status];
+}
+
+export function isRetryableHttpStatus(status: number) {
+  switch (status) {
+    /*
+408 Request Timeout
+425 Too Early
+429 Too Many Requests
+500 Internal Server Error
+502 Bad Gateway
+503 Service Unavailable
+504 Gateway Timeout
+     */
+    case 408:
+    case 425:
+    case 429:
+    case 502:
+    case 503:
+    case 504:
+      return true;
+    default:
+      return false;
+  }
+}

package/src/index.ts

@@ -18,8 +18,10 @@ export { merge, type MergeOptions } from './objects/merge';
 export { createLazyPromise, type LazyPromise } from './asyncs/createLazyPromise';
 export { setAsyncInterval, clearAsyncInterval } from './asyncs/AsyncInterval';
 export { type MaybePromise } from './asyncs/MaybePromise';
+// async - iterator
 export { createAsyncIterator } from './asyncs/createAsyncIterator';
 export { firstOfAsyncIterator } from './asyncs/firstOfAsyncIterator';
+export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator';
 export { isIterator } from './asyncs/isIterator';
 
 export { sleep } from './asyncs/sleep';
@@ -84,6 +86,7 @@ export { structuredClone } from './isomorphics/structuredClone';
 export { randomUUID } from './crypto/randomUUID';
 export { getRandomValues } from './crypto/getRandomValues';
 export { sha1, sha256, sha384, sha512 } from './crypto/hashing';
+export { md5 } from './crypto/md5';
 export { hex } from './crypto/base';
 export { isULID, createULID, ulid, parseULID } from './crypto/ulid';
 export { PEM } from './crypto/pem/pem';
@@ -96,4 +99,10 @@ export { type FetchLike, createFetchWith, createFetchWithLogging, dumpResponse,
 
 // bundled
 export { default as ms } from './libs/ms';
-export { nextOfAsyncIterator } from './asyncs/nextOfAsyncIterator';
+
+// error
+export { Errors, DetailError, type ErrorDetail, type ErrorDetailInit } from './errors/Errors';
+// http
+export { getHttpStatusText, isRetryableHttpStatus } from './http/HttpStatus';
+
+export type * from './types';

package/src/logging/createLogger.ts

@@ -1,5 +1,12 @@
 import type { LoggerWithChild, LogLevel } from './Logger';
 
+export interface CreateLoggerOptions {
+  name?: string;
+  handler?: (o: { level: LogLevel; values: any[] } & Record<string | symbol, any>) => void;
+  context?: Record<string, any>;
+  levels?: LogLevel[];
+}
+
 export function createLogger(
   write: (o: { level: LogLevel; values: any[] } & Record<string | symbol, any>) => void = ({
     level,
@@ -39,3 +46,5 @@ function merge(ctx: any, values: any[]) {
   }
   return { ...ctx, values };
 }
+
+// https://github.com/nestjs/nest/blob/master/packages/common/services/console-logger.service.ts

package/src/server.ts

@@ -1,7 +1,4 @@
 export { polyfillCrypto } from './servers/polyfill/polyfillCrypto';
-export { polyfillJsDom } from './servers/polyfill/polyfillJsDom';
-export { polyfillBrowser } from './servers/polyfill/polyfillBrowser';
-export { polyfillWebSocket } from './servers/polyfill/polyfillWebSocket';
 export { createFetchWithProxyByUndici } from './servers/fetch/createFetchWithProxyByUndici';
 export { createFetchWithProxy } from './servers/fetch/createFetchWithProxy';
 export { createFetchWithRetry, type FetchWithRetryOptions } from './servers/fetch/createFetchWithRetry';

package/src/servers/jsdom.ts

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

package/src/servers/node-fetch.ts

@@ -0,0 +1,2 @@
+export * from './polyfill/polyfillFetch';
+export * from './fetch/createFetchWithProxyByNodeFetch';

package/src/servers/ws.ts

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

package/src/types/global.d.ts

@@ -0,0 +1,11 @@
+declare var __DEV__: boolean;
+
+namespace NodeJS {
+  interface Process {
+    // webpack check
+    readonly browser?: boolean;
+  }
+  interface ProcessEnv {
+    readonly NODE_ENV: 'development' | 'production' | 'test';
+  }
+}

package/src/types/index.d.ts

@@ -0,0 +1,8 @@
+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>>;
+export type PartialRequired<T, K extends keyof T> = Partial<Omit<T, K>> & Required<Pick<T, K>>;
+
+/*
+https://github.com/total-typescript/ts-reset/blob/main/src/entrypoints/filter-boolean.d.ts
+ */