@wener/utils 1.1.50 → 1.1.53

package/lib/{runtime → web}/structuredClone.js

@@ -1,4 +1,8 @@
-/* eslint no-proto:0 */ import { classOf } from '../langs/classOf.js';
+/* eslint no-proto:0 */ function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { classOf } from "../langs/classOf.js";
 /**
  * Clone an object using structured cloning algorithm
  *
@@ -6,73 +10,76 @@
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/structuredClone structuredClone}
  * @see {@link https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/web.structured-clone.js core-js}
- */ export const structuredClone = globalThis.structuredClone || _clone;
+ */ export var structuredClone = globalThis.structuredClone || _clone;
 function set(obj, key, val) {
-    if (typeof val.value === 'object') val.value = _clone(val.value);
-    if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === '__proto__') {
+    if (_type_of(val.value) === "object")
+        val.value = _clone(val.value);
+    if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") {
         Object.defineProperty(obj, key, val);
-    } else obj[key] = val.value;
+    }
+    else
+        obj[key] = val.value;
 }
 /**
  * @see {@link https://github.com/lukeed/klona/blob/master/src/full.js klona}
  */ export function _clone(x) {
     // too complex
     // https://github.com/zloirock/core-js/blob/master/packages/core-js/modules/web.structured-clone.js
-    if (typeof x !== 'object') return x;
-    let i = 0;
-    let k;
-    let list;
-    let tmp;
-    const str = classOf(x);
-    switch(str){
-        case 'Array':
+    if ((typeof x === "undefined" ? "undefined" : _type_of(x)) !== "object")
+        return x;
+    var i = 0;
+    var k;
+    var list;
+    var tmp;
+    var str = classOf(x);
+    switch (str) {
+        case "Array":
             tmp = Array(x.length);
             break;
-        case 'Object':
+        case "Object":
             tmp = Object.create(x.__proto__ || null);
             break;
-        case 'Set':
+        case "Set":
             tmp = new Set();
-            x.forEach(function(val) {
+            x.forEach(function (val) {
                 tmp.add(_clone(val));
             });
             break;
-        case 'Map':
+        case "Map":
             tmp = new Map();
-            x.forEach(function(val, key) {
+            x.forEach(function (val, key) {
                 tmp.set(_clone(key), _clone(val));
             });
             break;
-        case 'Date':
+        case "Date":
             tmp = new Date(+x);
             break;
-        case 'RegExp':
+        case "RegExp":
             tmp = new RegExp(x.source, x.flags);
             break;
-        case 'DataView':
+        case "DataView":
             tmp = new x.constructor(_clone(x.buffer));
             break;
-        case 'ArrayBuffer':
+        case "ArrayBuffer":
             tmp = x.slice(0);
             break;
         default:
             // typed arrays
-            if (str.endsWith('Array')) {
+            if (str.endsWith("Array")) {
                 // ArrayBuffer.isView(x)
                 // ~> `new` bcuz `Buffer.slice` => ref
                 tmp = new x.constructor(x);
             }
     }
     if (tmp) {
-        for(list = Object.getOwnPropertySymbols(x); i < list.length; i++){
+        for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) {
             set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
         }
-        for(i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++){
-            if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k]) continue;
+        for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
+            if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k])
+                continue;
             set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
         }
     }
     return tmp || x;
 }
-
-//# sourceMappingURL=structuredClone.js.map

package/lib/web/structuredClone.test.js

@@ -0,0 +1,81 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { expect, test } from "vitest";
+import { classOf } from "../langs/classOf.js";
+import { _clone } from "./structuredClone.js";
+test("structuredClone", function () {
+    for (var _i = 0, _iter = [
+        [
+            "",
+            ""
+        ],
+        [
+            Number(1),
+            1
+        ]
+    ]; _i < _iter.length; _i++) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), k = _iter__i[0], v = _iter__i[1];
+        var c = _clone(k);
+        expect(c).toEqual(v);
+        expect(classOf(c)).toBe(classOf(v));
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/utils",
-  "version": "1.1.50",
+  "version": "1.1.53",
   "type": "module",
   "description": "Utils for daily use",
   "repository": {
@@ -15,14 +15,9 @@
       "types": "./src/index.ts",
       "default": "./lib/index.js"
     },
-    "./cn": {
-      "types": "./src/cn/index.ts",
-      "default": "./lib/cn/index.js"
-    },
-    "./cn/pinyin/data.json": "./src/cn/pinyin/data.json",
-    "./cn/pinyin/preload": {
-      "types": "./src/cn/pinyin/preload.ts",
-      "default": "./lib/cn/pinyin/preload.js"
+    "./logger": {
+      "types": "./src/logger/index.ts",
+      "default": "./lib/logger/index.js"
     },
     "./schema/typebox": {
       "types": "./src/schema/typebox/index.ts",
@@ -70,15 +65,12 @@
     "lodash"
   ],
   "devDependencies": {
-    "@sinclair/typebox": "^0.33.15",
-    "@types/lodash": "^4.17.10",
-    "@types/ws": "^8.5.12",
-    "@wener/utils": "link:",
-    "https-proxy-agent": "^7.0.5",
-    "lodash": "^4.17.21",
+    "@sinclair/typebox": "^0.34.41",
+    "@types/ws": "^8.18.1",
+    "https-proxy-agent": "^7.0.6",
     "node-fetch": "^3.3.2",
-    "undici": "^6.20.0",
-    "zod": "^3.23.8"
+    "undici": "^7.16.0",
+    "zod": "^4.1.9"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
@@ -86,7 +78,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "make prepublish",
+    "build": "make build",
     "clean": "make clean",
     "dev": "make dev",
     "test": "make test"

package/src/arrays/MaybeArray.ts

@@ -7,36 +7,36 @@ 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,
+	o: Record<string, MaybeArray<T>>,
+	keys: string[] | null = null,
+	picker = firstOfMaybeArray,
 ): Record<string, T> {
-  if (keys === null) {
-    return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, picker(v)]));
-  }
-  return Object.fromEntries(keys.map((v) => [v, picker(v)])) as any;
+	if (keys === null) {
+		return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, picker(v)]));
+	}
+	return Object.fromEntries(keys.map((v) => [v, picker(v)])) as any;
 }
 
 export function firstOfMaybeArray<T>(v: MaybeArray<T>): T {
-  if (Array.isArray(v)) {
-    return v[0];
-  }
-  return v;
+	if (Array.isArray(v)) {
+		return v[0];
+	}
+	return v;
 }
 
 export function lastOfMaybeArray<T>(v: MaybeArray<T>): T {
-  if (Array.isArray(v)) {
-    return v[v.length - 1];
-  }
-  return v;
+	if (Array.isArray(v)) {
+		return v[v.length - 1];
+	}
+	return v;
 }
 
 export function arrayOfMaybeArray<T>(v: MaybeArray<T> | null | undefined): T[] {
-  if (Array.isArray(v)) {
-    return v;
-  }
-  if (v === null || v === undefined) {
-    return [];
-  }
-  return [v];
+	if (Array.isArray(v)) {
+		return v;
+	}
+	if (v === null || v === undefined) {
+		return [];
+	}
+	return [v];
 }

package/src/arrays/arrayFromAsync.ts

@@ -1,5 +1,5 @@
 export async function arrayFromAsync<T>(asyncIterable: AsyncIterable<T>): Promise<T[]> {
-  const array = [];
-  for await (const i of asyncIterable) array.push(i);
-  return array;
+	const array = [];
+	for await (const i of asyncIterable) array.push(i);
+	return array;
 }

package/src/asyncs/AsyncInterval.ts

@@ -1,15 +1,15 @@
 export type AsyncIntervalIdentifier = any;
 
 export function setAsyncInterval(cb: () => void, interval: number, initial = interval): AsyncIntervalIdentifier {
-  let id: any;
-  const handler = async () => {
-    await cb();
-    id = setTimeout(handler, interval);
-  };
-  id = setTimeout(handler, initial);
-  return () => id;
+	let id: any;
+	const handler = async () => {
+		await cb();
+		id = setTimeout(handler, interval);
+	};
+	id = setTimeout(handler, initial);
+	return () => id;
 }
 
 export function clearAsyncInterval(v: AsyncIntervalIdentifier) {
-  clearTimeout(v?.());
+	clearTimeout(v?.());
 }

package/src/asyncs/Promises.ts

@@ -2,61 +2,61 @@
  * A collection of utility functions for working with Promises.
  */
 export class Promises {
-  /**
-   * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
-   * @returns An object with the properties `promise`, `resolve`, and `reject`.
-   *
-   * ```ts
-   * const { promise, resolve, reject } = Promise.withResolvers<T>();
-   * ```
-   *
-   * - Chrome 119, Safari 17.4
-   *
-   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
-   */
-  static withResolvers<T>(): PromiseWithResolvers<T> {
-    if ('withResolvers' in Promise) {
-      return Promise['withResolvers']() as any;
-    }
-    let resolve: (value: T | PromiseLike<T>) => void;
-    let reject: (reason?: any) => void;
-    // @ts-ignore
-    const promise = new Promise<T>((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    return { promise, resolve: resolve!, reject: reject! };
-  }
+	/**
+	 * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
+	 * @returns An object with the properties `promise`, `resolve`, and `reject`.
+	 *
+	 * ```ts
+	 * const { promise, resolve, reject } = Promise.withResolvers<T>();
+	 * ```
+	 *
+	 * - Chrome 119, Safari 17.4
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+	 */
+	static withResolvers<T>(): PromiseWithResolvers<T> {
+		if ('withResolvers' in Promise) {
+			return Promise['withResolvers']() as any;
+		}
+		let resolve: (value: T | PromiseLike<T>) => void;
+		let reject: (reason?: any) => void;
+		// @ts-ignore
+		const promise = new Promise<T>((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		return { promise, resolve: resolve!, reject: reject! };
+	}
 
-  /**
-   * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
-   * @param ms The number of milliseconds to wait before rejecting the promise.
-   */
-  static sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
+	/**
+	 * Creates a new Promise and returns it in an object, along with its resolve and reject functions.
+	 * @param ms The number of milliseconds to wait before rejecting the promise.
+	 */
+	static sleep(ms: number): Promise<void> {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
 
-  /**
-   * Returns `true` if the given value is a Promise.
-   * @param v The value to check.
-   */
-  static isPromise<T>(v: any): v is PromiseLike<T> {
-    return v && (v instanceof Promise || typeof v.then === 'function');
-  }
+	/**
+	 * Returns `true` if the given value is a Promise.
+	 * @param v The value to check.
+	 */
+	static isPromise<T>(v: any): v is PromiseLike<T> {
+		return v && (v instanceof Promise || typeof v.then === 'function');
+	}
 
-  /**
-   * Returns a Promise that resolves when the given signal is aborted.
-   */
-  static aborted(signal: AbortSignal): Promise<void> {
-    // https://nodejs.org/api/util.html#utilabortedsignal-resource
-    return new Promise((_, reject) => {
-      signal.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')));
-    });
-  }
+	/**
+	 * Returns a Promise that resolves when the given signal is aborted.
+	 */
+	static aborted(signal: AbortSignal): Promise<void> {
+		// https://nodejs.org/api/util.html#utilabortedsignal-resource
+		return new Promise((_, reject) => {
+			signal.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')));
+		});
+	}
 }
 
 interface PromiseWithResolvers<T> {
-  promise: Promise<T>;
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason?: any) => void;
+	promise: Promise<T>;
+	resolve: (value: T | PromiseLike<T>) => void;
+	reject: (reason?: any) => void;
 }

package/src/asyncs/createAsyncIterator.ts

@@ -1,43 +1,43 @@
 import { createLazyPromise, type LazyPromise } from './createLazyPromise';
-import { type MaybePromise } from './MaybePromise';
+import type { MaybePromise } from './MaybePromise';
 
 type Val<T> = [val: MaybePromise<T> | undefined, done: boolean, err?: any];
 
 export function createAsyncIterator<T>(
-  fn: (next: (val: [MaybePromise<T> | undefined, boolean] | undefined, err?: any) => void) => 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>>;
-    values.push((next = createLazyPromise()));
-    recv = (val, err) => {
-      if (err !== undefined) {
-        next.resolve([undefined, true, err]);
-      } else if (val !== undefined) {
-        next.resolve(val);
-      } else {
-        return;
-      }
-      values.push((next = createLazyPromise()));
-    };
-  }
+	const values: Array<Promise<Val<T>>> = [];
+	let recv: (val: [MaybePromise<T> | undefined, boolean] | undefined, err?: any) => void;
+	{
+		let next: LazyPromise<Val<T>>;
+		values.push((next = createLazyPromise()));
+		recv = (val, err) => {
+			if (err !== undefined) {
+				next.resolve([undefined, true, err]);
+			} else if (val !== undefined) {
+				next.resolve(val);
+			} else {
+				return;
+			}
+			values.push((next = createLazyPromise()));
+		};
+	}
 
-  fn(recv);
+	fn(recv);
 
-  return (async function* () {
-    let value: Val<T>[0];
-    let err: any;
-    for (let i = 0, done = false; !done; i++) {
-      let result = await values[i];
-      delete values[i];
-      [value, done, err] = result;
-      if (err) {
-        throw err;
-      }
-      if (value !== undefined) {
-        yield value;
-      }
-    }
-  })();
+	return (async function* () {
+		let value: Val<T>[0];
+		let err: any;
+		for (let i = 0, done = false; !done; i++) {
+			let result = await values[i];
+			delete values[i];
+			[value, done, err] = result;
+			if (err) {
+				throw err;
+			}
+			if (value !== undefined) {
+				yield value;
+			}
+		}
+	})();
 }