@cloudcome/utils-core 1.1.1 → 1.2.0

package/dist/object.mjs

@@ -0,0 +1,130 @@
+import { o, a } from "./each.mjs";
+import { isUndefined, isArray, isObject } from "./type.mjs";
+import { o as o2, a as a2 } from "./merge.mjs";
+function pathToKeys(path) {
+  if (isArray(path)) return [...path];
+  let pathFinal = path.replace(/\[(\w+)\]/g, ".$1");
+  pathFinal = pathFinal.replace(/^\./, "");
+  return pathFinal.split(".");
+}
+function isObjectOrArray(v) {
+  return isObject(v) || isArray(v);
+}
+function objectGet(obj, path) {
+  const keys = pathToKeys(path);
+  const lastKey = keys.pop();
+  let parent = obj;
+  const keysFinal = [];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    keysFinal.push(key);
+    if (!isObjectOrArray(parent)) break;
+    parent = parent[key];
+  }
+  return {
+    parent,
+    keys: keysFinal,
+    key: lastKey,
+    // @ts-ignore
+    value: isObjectOrArray(parent) && lastKey ? parent[lastKey] : void 0
+  };
+}
+const defaultObjectSetOptions = {
+  beforeSet: () => true,
+  undefinedSet: () => ({})
+};
+function objectSet(obj, path, val, options) {
+  const { beforeSet, undefinedSet } = Object.assign({}, defaultObjectSetOptions, options);
+  const keys = pathToKeys(path);
+  const lastKey = keys.pop();
+  let parent = obj;
+  let stopped = false;
+  const keysFinal = [];
+  for (const key of keys) {
+    let val2 = parent[key];
+    keysFinal.push(key);
+    if (isUndefined(val2)) {
+      const seted = undefinedSet({
+        parent,
+        keys: keysFinal,
+        key,
+        value: val2
+      });
+      if (!seted) {
+        stopped = true;
+        break;
+      }
+      val2 = parent[key] = seted;
+    }
+    parent = val2;
+  }
+  if (!stopped && !isUndefined(lastKey)) {
+    keysFinal.push(lastKey);
+    if (beforeSet({
+      parent,
+      keys: keysFinal,
+      key: lastKey,
+      value: parent[lastKey]
+    })) {
+      parent[lastKey] = val;
+    }
+  }
+  return {
+    keys: keysFinal,
+    parent,
+    key: lastKey,
+    value: val
+  };
+}
+function isEmptyObject(obj) {
+  return Object.getOwnPropertyNames(obj).length === 0 && Object.getOwnPropertySymbols(obj).length === 0;
+}
+function isPlainObject(obj) {
+  const proto = Object.getPrototypeOf(obj);
+  if (!proto) return true;
+  return proto === Object.prototype;
+}
+function objectPick(object, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in object) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+}
+function objectOmit(object, keys) {
+  const result = {};
+  for (const key in object) {
+    if (!keys.includes(key)) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+}
+function objectMap(object, mapper) {
+  return Object.fromEntries(
+    Object.entries(object).map(([key, value]) => [
+      key,
+      mapper(
+        // @ts-expect-error
+        value,
+        key
+      )
+    ])
+  );
+}
+export {
+  isEmptyObject,
+  isPlainObject,
+  o2 as objectDefaults,
+  o as objectEach,
+  a as objectEachAsync,
+  objectGet,
+  objectMap,
+  a2 as objectMerge,
+  objectOmit,
+  objectPick,
+  objectSet
+};
+//# sourceMappingURL=object.mjs.map

package/dist/object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.mjs","sources":["../src/object/get-set.ts","../src/object/is.ts","../src/object/process.ts"],"sourcesContent":["import { isArray, isObject, isUndefined } from '@/type';\nimport type { AnyArray, AnyObject } from '@/types';\n\n// @ref https://stackoverflow.com/a/67609485\n\ntype Idx<T, K> = K extends keyof T\n  ? T[K]\n  : number extends keyof T\n    ? K extends `${number}`\n      ? T[number]\n      : never\n    : never;\n\ntype Join<K, P> = K extends string | number\n  ? P extends string | number\n    ? `${K}${'' extends P ? '' : '.'}${P}`\n    : never\n  : never;\n\ntype Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...0[]];\n\nexport type ObjectPath<O, D extends number = 4> = [D] extends [never]\n  ? never\n  : O extends object\n    ? {\n        [K in keyof O]-?: K extends string | number ? `${K}` | Join<K, ObjectPath<O[K], Prev[D]>> : never;\n      }[keyof O]\n    : '';\n\nexport type ObjectLeafPath<O, D extends number = 4> = [D] extends [never]\n  ? never\n  : O extends object\n    ? {\n        [K in keyof O]-?: K extends string | number\n          ? O[K] extends string | number\n            ? `${K}` | Join<K, ObjectLeafPath<O[K], Prev[D]>>\n            : Join<K, ObjectLeafPath<O[K], Prev[D]>>\n          : never;\n      }[keyof O]\n    : '';\n\nexport type ObjectPathValue<O, P extends ObjectPath<O, 4>> = P extends `${infer Key}.${infer Rest}`\n  ? Rest extends ObjectPath<Idx<O, Key>, 4>\n    ? ObjectPathValue<Idx<O, Key>, Rest>\n    : never\n  : Idx<O, P>;\n\nfunction pathToKeys(path: string | string[]) {\n  // 下文用到该数组时会进行修改操作，因此复制一份\n  if (isArray(path)) return [...path];\n\n  let pathFinal = path.replace(/\\[(\\w+)\\]/g, '.$1');\n  pathFinal = pathFinal.replace(/^\\./, '');\n  return pathFinal.split('.');\n}\n\nfunction isObjectOrArray(v: unknown) {\n  return isObject(v) || isArray(v);\n}\n\n/**\n * 表示对象节点的信息。\n *\n * @template V - 键值的类型。\n */\nexport type TObjectNode<V = unknown | undefined> = {\n  /**\n   * 当前节点的父级对象。\n   */\n  parent: unknown | undefined;\n\n  /**\n   * 当前节点的键名路径。\n   */\n  keys: string[];\n\n  /**\n   * 当前节点的键名。\n   */\n  key: string | undefined;\n\n  /**\n   * 当前节点的键值。\n   */\n  value: V;\n};\n\n/**\n * 根据属性路径获取属性值\n * @param {O} obj\n * @param {string | string[] | P} path\n * @returns {TObjectNode<O>}\n * 根据属性路径获取属性值。\n *\n * @template O - 目标对象的类型。\n * @template P - 属性路径的类型。\n * @param {O} obj - 要操作的目标对象。\n * @param {P | string | string[]} path - 属性路径，可以是字符串或字符串数组。支持点分隔符（如 \"a.b.c\"）或数组形式（如 [\"a\", \"b\", \"c\"]）。\n * @returns {TObjectNode<O>} 返回一个包含父级、键名路径、键名和键值的对象节点。\n *\n * @example\n * ```typescript\n * const obj = { a: { b: { c: 42 } } };\n * const result = objectGet(obj, 'a.b.c');\n * console.log(result.value); // 输出 42\n * ```\n */\nexport function objectGet<O extends AnyObject, P extends ObjectPath<O>>(\n  obj: O,\n  path: P | string | string[],\n): TObjectNode<O> {\n  const keys = pathToKeys(path);\n  const lastKey = keys.pop();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n  let parent: any = obj;\n  const keysFinal: string[] = [];\n\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n\n    keysFinal.push(key);\n    if (!isObjectOrArray(parent)) break;\n\n    // @ts-ignore\n    parent = parent[key];\n  }\n\n  return {\n    parent: parent,\n    keys: keysFinal,\n    key: lastKey,\n    // @ts-ignore\n    value: isObjectOrArray(parent) && lastKey ? parent[lastKey] : undefined,\n  };\n}\n\n// /**\n//  * 根据路径获取对象叶子节点值\n//  * @param {O} obj\n//  * @param {P} path\n//  * @returns {ObjectNode<O>}\n//  */\n// export function objectLeaf<O extends AnyObject, P extends ObjectLeafPath<O>>(obj: O, path: P) {\n//   return objectGet(obj, path);\n// }\n\n/**\n * 配置选项，用于控制 `objectSet` 的行为。\n *\n * @template O - 目标对象的类型。\n */\nexport type TObjectSetOptions<O extends AnyObject> = {\n  /**\n   * 在设置值之前调用的钩子函数。\n   * 如果返回 `false`，则阻止设置值。\n   *\n   * @param {TObjectNode<O> & { key: string }} node - 当前节点信息。\n   * @returns {boolean | undefined | void} 返回 `false` 时阻止设置值。\n   */\n  // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\n  beforeSet(node: TObjectNode<O> & { key: string }): boolean | undefined | void;\n\n  /**\n   * 当遇到未定义的中间节点时调用的钩子函数。\n   * 返回值将用于创建中间节点。\n   *\n   * @param {TObjectNode<O>} node - 当前节点信息。\n   * @returns {AnyObject | AnyArray | undefined | void} 返回值将用于创建中间节点。\n   */\n  // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\n  undefinedSet(node: TObjectNode<O>): AnyObject | AnyArray | undefined | void;\n};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\nconst defaultObjectSetOptions: TObjectSetOptions<any> = {\n  beforeSet: () => true,\n  undefinedSet: () => ({}),\n};\n\n/**\n * 根据属性路径设置属性值\n * @param {AnyObject} obj\n * @param {string} path\n * @param {V} val\n * @param {Partial<TObjectSetOptions<O>>} options\n * @returns {TObjectNode<O, V>}\n * 根据属性路径设置属性值。\n *\n * @template O - 目标对象的类型。\n * @template V - 要设置的值的类型。\n * @param {O} obj - 要操作的目标对象。\n * @param {string | string[]} path - 属性路径，可以是字符串或字符串数组。支持点分隔符（如 \"a.b.c\"）或数组形式（如 [\"a\", \"b\", \"c\"]）。\n * @param {V} val - 要设置的值。\n * @param {Partial<TObjectSetOptions<O>>} [options] - 可选配置项，用于控制设置行为。\n * @returns {TObjectNode<V>} 返回一个包含父级、键名路径、键名和键值的对象节点。\n *\n * @example\n * ```typescript\n * const obj = {};\n * objectSet(obj, 'a.b.c', 42);\n * console.log(obj); // 输出 { a: { b: { c: 42 } } }\n *\n * objectSet(obj, 'a.b.c', 100, {\n *   beforeSet: (node) => node.key === 'c',\n * });\n * console.log(obj); // 输出 { a: { b: { c: 100 } } }\n * ```\n */\nexport function objectSet<O extends AnyObject, V>(\n  obj: O,\n  path: string | string[],\n  val: V,\n  options?: Partial<TObjectSetOptions<O>>,\n): TObjectNode<V> {\n  const { beforeSet, undefinedSet } = Object.assign({}, defaultObjectSetOptions, options);\n  const keys = pathToKeys(path);\n  const lastKey = keys.pop();\n  let parent = obj;\n  let stopped = false;\n  const keysFinal: string[] = [];\n\n  for (const key of keys) {\n    let val = parent[key];\n    keysFinal.push(key);\n\n    if (isUndefined(val)) {\n      const seted = undefinedSet({\n        parent: parent,\n        keys: keysFinal,\n        key: key,\n        value: val,\n      });\n\n      if (!seted) {\n        stopped = true;\n        break;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      val = parent[key] = seted;\n    }\n\n    // @ts-ignore\n    parent = val;\n  }\n\n  if (!stopped && !isUndefined(lastKey)) {\n    keysFinal.push(lastKey);\n\n    if (\n      beforeSet({\n        parent: parent,\n        keys: keysFinal,\n        key: lastKey,\n        value: parent[lastKey],\n      })\n    ) {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      parent[lastKey] = val;\n    }\n  }\n\n  return {\n    keys: keysFinal,\n    parent: parent,\n    key: lastKey,\n    value: val,\n  };\n}\n","import { isArray, isObject, isString, typeIs } from '@/type';\nimport type { AnyArray, AnyFunction, AnyObject } from '@/types';\n\n/**\n * 检查一个对象是否为空对象（不包含任何自有属性，包括符号属性）。\n *\n * @param obj - 要检查的对象\n * @returns 如果对象没有自有属性（包括符号属性）则返回 true，否则返回 false\n *\n * @example\n * ```typescript\n * isEmptyObject({}); // true\n * isEmptyObject({ a: 1 }); // false\n * isEmptyObject(Object.create(null)); // true\n * isEmptyObject({ [Symbol('key')]: 'value' }); // false\n * ```\n */\nexport function isEmptyObject(obj: AnyObject): boolean {\n  return Object.getOwnPropertyNames(obj).length === 0 && Object.getOwnPropertySymbols(obj).length === 0;\n}\n\n/**\n * 检查一个对象是否为纯对象（通过对象字面量或Object构造函数创建，而非其他构造函数的实例）。\n *\n * @param obj - 要检查的对象\n * @returns 如果是纯对象则返回 true，否则返回 false\n *\n * @example\n * ```typescript\n * isPlainObject({}); // true\n * isPlainObject(Object.create(null)); // true\n * isPlainObject(new Date()); // false\n * isPlainObject([]); // false\n * isPlainObject(() => {}); // false\n * ```\n */\nexport function isPlainObject(obj: AnyObject): boolean {\n  const proto: unknown = Object.getPrototypeOf(obj);\n\n  // 对象无原型\n  if (!proto) return true;\n\n  // 是否对象直接实例\n  return proto === Object.prototype;\n}\n\n// 移除，原因是，定义对象尽可能的使用 type 关键字即可避开此问题\n// /**\n//  * 精确对象，常用于联合类型判断\n//  * 相关 bug：https://l.ydr.me/Zp88vFKc\n//  */\n// // biome-ignore lint/suspicious/noExplicitAny: <explanation>\n// export type ExactObject<T = any> = T extends AnyFunction\n//   ? never\n//   : T extends AnyArray\n//     ? never\n//     : T extends object\n//       ? T\n//       : never;\n//\n// /**\n//  * 检查值是否为精确接口对象\n//  * @param object - 传入对象，必须是一个对象与其他类型的联合\n//  * @returns 如果值为对象则返回 true，否则返回 false\n//  * @example\n//  * ```typescript\n//  * type Id = string | string[] | (() => string);\n//  *\n//  * interface Cache {\n//  *   id?: Id;\n//  * }\n//  *\n//  * type Share = {\n//  *   id?: Id;\n//  * }\n//  *\n//  * interface Options {\n//  *   cache?: Id | Cache;\n//  *   share?: Id | Share;\n//  * }\n//  *\n//  * function test(options: Options) {\n//  *   // string | string[] | (() => string) | Cache | undefined\n//  *   const cache = options.cache;\n//  *\n//  *   // Cache\n//  *   // 需要使用\n//  *   if (isExactObject(cache)) {\n//  *     cache.id;\n//  *   }\n//  *   // string[]\n//  *   else if (isArray(cache)) {\n//  *     cache.push();\n//  *   }\n//  *   // string\n//  *   else if (isString(cache)) {\n//  *     cache.charCodeAt(0);\n//  *   }\n//  *   // (() => string) | undefined\n//  *   else {\n//  *     cache?.();\n//  *   }\n//  *\n//  *   // string | string[] | (() => string) | Share | undefined\n//  *   const share = options.share;\n//  *\n//  *   // Share\n//  *   if (isObject(share)) {\n//  *     share.id;\n//  *   }\n//  *   // string[]\n//  *   else if (isArray(share)) {\n//  *     share.push();\n//  *   }\n//  *   // string\n//  *   else if (isString(share)) {\n//  *     share.charCodeAt(0);\n//  *   }\n//  *   // (() => string) | undefined\n//  *   else {\n//  *     share?.();\n//  *   }\n//  * }\n//  * ```\n//  */\n// export function isExactObject<T>(object: T): object is ExactObject<T> {\n//   return typeIs(object) === 'object';\n// }\n","import type { AnyObject } from '@/types';\n\n/**\n * 从对象中选择指定键的属性，返回一个新的对象。\n *\n * @param object - 要从中选择属性的对象。\n * @param keys - 要选择的键数组。\n * @returns 包含指定键属性的新对象。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const result = objectPick(obj, ['a', 'c']);\n * console.log(result); // { a: 1, c: 3 }\n * ```\n */\nexport function objectPick<T extends AnyObject, K extends keyof T>(object: T, keys: K[]): Pick<T, K> {\n  const result = {} as Pick<T, K>;\n  for (const key of keys) {\n    if (key in object) {\n      result[key] = object[key];\n    }\n  }\n  return result;\n}\n\n/**\n * 从对象中排除指定键的属性，返回一个新的对象。\n *\n * @param object - 要从中排除属性的对象。\n * @param keys - 要排除的键数组。\n * @returns 排除指定键属性后的新对象。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3, d: 4 };\n * const result = objectOmit(obj, ['a', 'd']);\n * console.log(result); // { b: 2, c: 3 }\n * ```\n */\nexport function objectOmit<T extends AnyObject, K extends keyof T>(object: T, keys: K[]): Omit<T, K> {\n  const result = {} as Omit<T, K>;\n  for (const key in object) {\n    if (!keys.includes(key as unknown as K)) {\n      // @ts-expect-error\n      result[key] = object[key];\n    }\n  }\n  return result;\n}\n\n/**\n * 遍历对象的每个键值对，并对每个键值对执行提供的映射函数，返回一个新的对象。\n *\n * @param object - 要遍历的对象。\n * @param mapper - 对每个键值对执行的映射函数。\n * @returns 返回一个新的对象，其中每个值都是通过映射函数处理后的结果。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const result = objectMap(obj, (val, key) => String(val * 2));\n * console.log(result); // { a: '2', b: '4', c: '6' }\n * ```\n */\nexport function objectMap<T extends AnyObject, V>(\n  object: T,\n  mapper: (value: T[keyof T], key: keyof T) => V,\n): Record<keyof T, V> {\n  return Object.fromEntries(\n    Object.entries(object).map(([key, value]) => [\n      key,\n      mapper(\n        // @ts-expect-error\n        value,\n        key as keyof T,\n      ),\n    ]),\n  ) as Record<keyof T, V>;\n}\n"],"names":["val"],"mappings":"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"}

package/dist/path.cjs

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const array = require("./array.cjs");
+function _isCurrentSlice(slice) {
+  return slice === ".";
+}
+function _isParentSlice(slice) {
+  return slice === "..";
+}
+function isAbsolutePath(path) {
+  return path.startsWith("/");
+}
+function isRelativePath(path) {
+  return !isAbsolutePath(path);
+}
+function pathNormalize(path) {
+  const slices = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/\.{3,}/g, "..").replace(/\/\.\//g, "/").split("/").map((point) => point.trim());
+  const points = [];
+  const isAbs = slices[0] === "";
+  const push = (point) => {
+    points.push(point);
+  };
+  const back = () => {
+    if (points.length === 1 && isAbs) return;
+    if (points.length === 0 || points.at(-1) === "..") {
+      points.push("..");
+    } else {
+      points.pop();
+    }
+  };
+  for (const slice of slices) {
+    const isCurrent = _isCurrentSlice(slice);
+    const isParent = _isParentSlice(slice);
+    if (isCurrent) {
+      continue;
+    }
+    if (isParent) {
+      back();
+      continue;
+    }
+    push(slice);
+  }
+  return points.join("/");
+}
+function pathJoin(from, ...to) {
+  return pathNormalize([from, ...to].join("/"));
+}
+function pathResolve(from, ...to) {
+  const paths = [from, ...to].map(pathNormalize);
+  let lastStartPath = from;
+  let lastStartIndex = 0;
+  array.arrayEach(
+    paths,
+    (path, index) => {
+      if (isAbsolutePath(path)) {
+        lastStartPath = path;
+        lastStartIndex = index;
+        return false;
+      }
+    },
+    true
+  );
+  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));
+}
+function pathRelativize(path) {
+  if (isAbsolutePath(path)) return path;
+  if (path.startsWith("./")) return path;
+  if (path.startsWith("../")) return path;
+  return `./${path}`;
+}
+exports.isAbsolutePath = isAbsolutePath;
+exports.isRelativePath = isRelativePath;
+exports.pathJoin = pathJoin;
+exports.pathNormalize = pathNormalize;
+exports.pathRelativize = pathRelativize;
+exports.pathResolve = pathResolve;
+//# sourceMappingURL=path.cjs.map

package/dist/path.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.cjs","sources":["../src/path.ts"],"sourcesContent":["import { arrayEach } from './array';\n\n/**\n * 判断是否是当前目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false\n */\nfunction _isCurrentSlice(slice: string): boolean {\n  return slice === '.';\n}\n\n/**\n * 判断是否是上级目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false\n */\nfunction _isParentSlice(slice: string): boolean {\n  return slice === '..';\n}\n\n/**\n * 判断是否是绝对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是绝对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isAbs = isAbsolutePath('/path/to/file');\n * console.log(isAbs); // 输出: true\n * ```\n */\nexport function isAbsolutePath(path: string): boolean {\n  return path.startsWith('/');\n}\n\n/**\n * 判断是否是相对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是相对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isRel = isRelativePath('path/to/file');\n * console.log(isRel); // 输出: true\n * ```\n */\nexport function isRelativePath(path: string): boolean {\n  return !isAbsolutePath(path);\n}\n\n/**\n * 标准化路径\n * @param {string} path - 要标准化的路径字符串。\n * @returns {string} - 标准化后的路径字符串。\n * @example\n * ```typescript\n * const normalizedPath = pathNormalize('/path///to///file');\n * console.log(normalizedPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathNormalize(path: string): string {\n  const slices = path\n    .replace(/\\\\/g, '/')\n    .replace(/\\/{2,}/g, '/')\n    .replace(/\\.{3,}/g, '..')\n    .replace(/\\/\\.\\//g, '/')\n    .split('/')\n    .map((point) => point.trim());\n  const points: string[] = [];\n  const isAbs = slices[0] === '';\n\n  const push = (point: string) => {\n    points.push(point);\n  };\n\n  const back = () => {\n    // 绝对路径不能退到根目录\n    if (points.length === 1 && isAbs) return;\n\n    //\n    if (points.length === 0 || points.at(-1) === '..') {\n      points.push('..');\n    } else {\n      points.pop();\n    }\n  };\n\n  for (const slice of slices) {\n    const isCurrent = _isCurrentSlice(slice);\n    const isParent = _isParentSlice(slice);\n\n    // // 未进入实际路径\n    // if (!inPoints) {\n    //   push(slice);\n    //   inPoints = !isCurrent && !isParent;\n    //   continue;\n    // }\n\n    if (isCurrent) {\n      continue;\n    }\n\n    if (isParent) {\n      back();\n      continue;\n    }\n\n    push(slice);\n  }\n\n  return points.join('/');\n}\n\n/**\n * 路径合并\n * @param {string} from - 起始路径。\n * @param {...string[]} to - 要合并的路径片段。\n * @returns {string} - 合并后的路径字符串。\n * @example\n * ```typescript\n * const fullPath = pathJoin('/path', '/to', 'file');\n * console.log(fullPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathJoin(from: string, ...to: string[]): string {\n  return pathNormalize([from, ...to].join('/'));\n}\n\n/**\n * 解析路径\n * @param {string} from - 起始路径\n * @param {...string[]} to - 要解析的路径片段\n * @returns {string} - 解析后的绝对路径\n * @example\n * ```typescript\n * const resolvedPath = pathResolve('/path', '/to', 'file');\n * console.log(resolvedPath); // 输出: '/to/file'\n * ```\n */\nexport function pathResolve(from: string, ...to: string[]): string {\n  const paths = [from, ...to].map(pathNormalize);\n\n  let lastStartPath = from;\n  let lastStartIndex = 0;\n\n  arrayEach(\n    paths,\n    (path, index) => {\n      if (isAbsolutePath(path)) {\n        lastStartPath = path;\n        lastStartIndex = index;\n        return false;\n      }\n    },\n    true,\n  );\n\n  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));\n}\n\n/**\n * 将相对路径转换为标准的相对路径格式(添加'./'前缀)\n *\n * @param {string} path - 要处理的路径字符串\n * @returns {string} 处理后的路径字符串\n *\n * @example <caption>处理绝对路径</caption>\n * ```typescript\n * const result = pathRelativize('/path/to/file');\n * console.log(result); // 输出: '/path/to/file'\n * ```\n *\n * @example <caption>处理已带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('./path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n *\n * @example <caption>处理不带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n */\nexport function pathRelativize(path: string): string {\n  if (isAbsolutePath(path)) return path;\n  if (path.startsWith('./')) return path;\n  if (path.startsWith('../')) return path;\n  return `./${path}`;\n}\n"],"names":["arrayEach"],"mappings":";;;AAOA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,UAAU;AACnB;AAOA,SAAS,eAAe,OAAwB;AAC9C,SAAO,UAAU;AACnB;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,KAAK,WAAW,GAAG;AAC5B;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,CAAC,eAAe,IAAI;AAC7B;AAYO,SAAS,cAAc,MAAsB;AAC5C,QAAA,SAAS,KACZ,QAAQ,OAAO,GAAG,EAClB,QAAQ,WAAW,GAAG,EACtB,QAAQ,WAAW,IAAI,EACvB,QAAQ,WAAW,GAAG,EACtB,MAAM,GAAG,EACT,IAAI,CAAC,UAAU,MAAM,KAAA,CAAM;AAC9B,QAAM,SAAmB,CAAC;AACpB,QAAA,QAAQ,OAAO,CAAC,MAAM;AAEtB,QAAA,OAAO,CAAC,UAAkB;AAC9B,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,QAAM,OAAO,MAAM;AAEb,QAAA,OAAO,WAAW,KAAK,MAAO;AAGlC,QAAI,OAAO,WAAW,KAAK,OAAO,GAAG,EAAE,MAAM,MAAM;AACjD,aAAO,KAAK,IAAI;AAAA,IAAA,OACX;AACL,aAAO,IAAI;AAAA,IAAA;AAAA,EAEf;AAEA,aAAW,SAAS,QAAQ;AACpB,UAAA,YAAY,gBAAgB,KAAK;AACjC,UAAA,WAAW,eAAe,KAAK;AASrC,QAAI,WAAW;AACb;AAAA,IAAA;AAGF,QAAI,UAAU;AACP,WAAA;AACL;AAAA,IAAA;AAGF,SAAK,KAAK;AAAA,EAAA;AAGL,SAAA,OAAO,KAAK,GAAG;AACxB;AAagB,SAAA,SAAS,SAAiB,IAAsB;AACvD,SAAA,cAAc,CAAC,MAAM,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC;AAC9C;AAagB,SAAA,YAAY,SAAiB,IAAsB;AACjE,QAAM,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,IAAI,aAAa;AAE7C,MAAI,gBAAgB;AACpB,MAAI,iBAAiB;AAErBA,QAAA;AAAA,IACE;AAAA,IACA,CAAC,MAAM,UAAU;AACX,UAAA,eAAe,IAAI,GAAG;AACR,wBAAA;AACC,yBAAA;AACV,eAAA;AAAA,MAAA;AAAA,IAEX;AAAA,IACA;AAAA,EACF;AAEA,SAAO,SAAS,eAAe,GAAG,MAAM,MAAM,iBAAiB,CAAC,CAAC;AACnE;AA0BO,SAAS,eAAe,MAAsB;AAC/C,MAAA,eAAe,IAAI,EAAU,QAAA;AACjC,MAAI,KAAK,WAAW,IAAI,EAAU,QAAA;AAClC,MAAI,KAAK,WAAW,KAAK,EAAU,QAAA;AACnC,SAAO,KAAK,IAAI;AAClB;;;;;;;"}

package/dist/path.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 判断是否是绝对路径
+ * @param {string} path - 路径字符串
+ * @returns {boolean} - 如果是绝对路径则返回true，否则返回false
+ * @example
+ * ```typescript
+ * const isAbs = isAbsolutePath('/path/to/file');
+ * console.log(isAbs); // 输出: true
+ * ```
+ */
+export declare function isAbsolutePath(path: string): boolean;
+/**
+ * 判断是否是相对路径
+ * @param {string} path - 路径字符串
+ * @returns {boolean} - 如果是相对路径则返回true，否则返回false
+ * @example
+ * ```typescript
+ * const isRel = isRelativePath('path/to/file');
+ * console.log(isRel); // 输出: true
+ * ```
+ */
+export declare function isRelativePath(path: string): boolean;
+/**
+ * 标准化路径
+ * @param {string} path - 要标准化的路径字符串。
+ * @returns {string} - 标准化后的路径字符串。
+ * @example
+ * ```typescript
+ * const normalizedPath = pathNormalize('/path///to///file');
+ * console.log(normalizedPath); // 输出: '/path/to/file'
+ * ```
+ */
+export declare function pathNormalize(path: string): string;
+/**
+ * 路径合并
+ * @param {string} from - 起始路径。
+ * @param {...string[]} to - 要合并的路径片段。
+ * @returns {string} - 合并后的路径字符串。
+ * @example
+ * ```typescript
+ * const fullPath = pathJoin('/path', '/to', 'file');
+ * console.log(fullPath); // 输出: '/path/to/file'
+ * ```
+ */
+export declare function pathJoin(from: string, ...to: string[]): string;
+/**
+ * 解析路径
+ * @param {string} from - 起始路径
+ * @param {...string[]} to - 要解析的路径片段
+ * @returns {string} - 解析后的绝对路径
+ * @example
+ * ```typescript
+ * const resolvedPath = pathResolve('/path', '/to', 'file');
+ * console.log(resolvedPath); // 输出: '/to/file'
+ * ```
+ */
+export declare function pathResolve(from: string, ...to: string[]): string;
+/**
+ * 将相对路径转换为标准的相对路径格式(添加'./'前缀)
+ *
+ * @param {string} path - 要处理的路径字符串
+ * @returns {string} 处理后的路径字符串
+ *
+ * @example <caption>处理绝对路径</caption>
+ * ```typescript
+ * const result = pathRelativize('/path/to/file');
+ * console.log(result); // 输出: '/path/to/file'
+ * ```
+ *
+ * @example <caption>处理已带'./'前缀的相对路径</caption>
+ * ```typescript
+ * const result = pathRelativize('./path/to/file');
+ * console.log(result); // 输出: './path/to/file'
+ * ```
+ *
+ * @example <caption>处理不带'./'前缀的相对路径</caption>
+ * ```typescript
+ * const result = pathRelativize('path/to/file');
+ * console.log(result); // 输出: './path/to/file'
+ * ```
+ */
+export declare function pathRelativize(path: string): string;

package/dist/path.mjs

@@ -0,0 +1,77 @@
+import { arrayEach } from "./array.mjs";
+function _isCurrentSlice(slice) {
+  return slice === ".";
+}
+function _isParentSlice(slice) {
+  return slice === "..";
+}
+function isAbsolutePath(path) {
+  return path.startsWith("/");
+}
+function isRelativePath(path) {
+  return !isAbsolutePath(path);
+}
+function pathNormalize(path) {
+  const slices = path.replace(/\\/g, "/").replace(/\/{2,}/g, "/").replace(/\.{3,}/g, "..").replace(/\/\.\//g, "/").split("/").map((point) => point.trim());
+  const points = [];
+  const isAbs = slices[0] === "";
+  const push = (point) => {
+    points.push(point);
+  };
+  const back = () => {
+    if (points.length === 1 && isAbs) return;
+    if (points.length === 0 || points.at(-1) === "..") {
+      points.push("..");
+    } else {
+      points.pop();
+    }
+  };
+  for (const slice of slices) {
+    const isCurrent = _isCurrentSlice(slice);
+    const isParent = _isParentSlice(slice);
+    if (isCurrent) {
+      continue;
+    }
+    if (isParent) {
+      back();
+      continue;
+    }
+    push(slice);
+  }
+  return points.join("/");
+}
+function pathJoin(from, ...to) {
+  return pathNormalize([from, ...to].join("/"));
+}
+function pathResolve(from, ...to) {
+  const paths = [from, ...to].map(pathNormalize);
+  let lastStartPath = from;
+  let lastStartIndex = 0;
+  arrayEach(
+    paths,
+    (path, index) => {
+      if (isAbsolutePath(path)) {
+        lastStartPath = path;
+        lastStartIndex = index;
+        return false;
+      }
+    },
+    true
+  );
+  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));
+}
+function pathRelativize(path) {
+  if (isAbsolutePath(path)) return path;
+  if (path.startsWith("./")) return path;
+  if (path.startsWith("../")) return path;
+  return `./${path}`;
+}
+export {
+  isAbsolutePath,
+  isRelativePath,
+  pathJoin,
+  pathNormalize,
+  pathRelativize,
+  pathResolve
+};
+//# sourceMappingURL=path.mjs.map

package/dist/path.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.mjs","sources":["../src/path.ts"],"sourcesContent":["import { arrayEach } from './array';\n\n/**\n * 判断是否是当前目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是当前目录标记'.'则返回true，否则返回false\n */\nfunction _isCurrentSlice(slice: string): boolean {\n  return slice === '.';\n}\n\n/**\n * 判断是否是上级目录标记\n * @param {string} slice - 路径片段\n * @returns {boolean} - 如果是上级目录标记'..'则返回true，否则返回false\n */\nfunction _isParentSlice(slice: string): boolean {\n  return slice === '..';\n}\n\n/**\n * 判断是否是绝对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是绝对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isAbs = isAbsolutePath('/path/to/file');\n * console.log(isAbs); // 输出: true\n * ```\n */\nexport function isAbsolutePath(path: string): boolean {\n  return path.startsWith('/');\n}\n\n/**\n * 判断是否是相对路径\n * @param {string} path - 路径字符串\n * @returns {boolean} - 如果是相对路径则返回true，否则返回false\n * @example\n * ```typescript\n * const isRel = isRelativePath('path/to/file');\n * console.log(isRel); // 输出: true\n * ```\n */\nexport function isRelativePath(path: string): boolean {\n  return !isAbsolutePath(path);\n}\n\n/**\n * 标准化路径\n * @param {string} path - 要标准化的路径字符串。\n * @returns {string} - 标准化后的路径字符串。\n * @example\n * ```typescript\n * const normalizedPath = pathNormalize('/path///to///file');\n * console.log(normalizedPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathNormalize(path: string): string {\n  const slices = path\n    .replace(/\\\\/g, '/')\n    .replace(/\\/{2,}/g, '/')\n    .replace(/\\.{3,}/g, '..')\n    .replace(/\\/\\.\\//g, '/')\n    .split('/')\n    .map((point) => point.trim());\n  const points: string[] = [];\n  const isAbs = slices[0] === '';\n\n  const push = (point: string) => {\n    points.push(point);\n  };\n\n  const back = () => {\n    // 绝对路径不能退到根目录\n    if (points.length === 1 && isAbs) return;\n\n    //\n    if (points.length === 0 || points.at(-1) === '..') {\n      points.push('..');\n    } else {\n      points.pop();\n    }\n  };\n\n  for (const slice of slices) {\n    const isCurrent = _isCurrentSlice(slice);\n    const isParent = _isParentSlice(slice);\n\n    // // 未进入实际路径\n    // if (!inPoints) {\n    //   push(slice);\n    //   inPoints = !isCurrent && !isParent;\n    //   continue;\n    // }\n\n    if (isCurrent) {\n      continue;\n    }\n\n    if (isParent) {\n      back();\n      continue;\n    }\n\n    push(slice);\n  }\n\n  return points.join('/');\n}\n\n/**\n * 路径合并\n * @param {string} from - 起始路径。\n * @param {...string[]} to - 要合并的路径片段。\n * @returns {string} - 合并后的路径字符串。\n * @example\n * ```typescript\n * const fullPath = pathJoin('/path', '/to', 'file');\n * console.log(fullPath); // 输出: '/path/to/file'\n * ```\n */\nexport function pathJoin(from: string, ...to: string[]): string {\n  return pathNormalize([from, ...to].join('/'));\n}\n\n/**\n * 解析路径\n * @param {string} from - 起始路径\n * @param {...string[]} to - 要解析的路径片段\n * @returns {string} - 解析后的绝对路径\n * @example\n * ```typescript\n * const resolvedPath = pathResolve('/path', '/to', 'file');\n * console.log(resolvedPath); // 输出: '/to/file'\n * ```\n */\nexport function pathResolve(from: string, ...to: string[]): string {\n  const paths = [from, ...to].map(pathNormalize);\n\n  let lastStartPath = from;\n  let lastStartIndex = 0;\n\n  arrayEach(\n    paths,\n    (path, index) => {\n      if (isAbsolutePath(path)) {\n        lastStartPath = path;\n        lastStartIndex = index;\n        return false;\n      }\n    },\n    true,\n  );\n\n  return pathJoin(lastStartPath, ...paths.slice(lastStartIndex + 1));\n}\n\n/**\n * 将相对路径转换为标准的相对路径格式(添加'./'前缀)\n *\n * @param {string} path - 要处理的路径字符串\n * @returns {string} 处理后的路径字符串\n *\n * @example <caption>处理绝对路径</caption>\n * ```typescript\n * const result = pathRelativize('/path/to/file');\n * console.log(result); // 输出: '/path/to/file'\n * ```\n *\n * @example <caption>处理已带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('./path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n *\n * @example <caption>处理不带'./'前缀的相对路径</caption>\n * ```typescript\n * const result = pathRelativize('path/to/file');\n * console.log(result); // 输出: './path/to/file'\n * ```\n */\nexport function pathRelativize(path: string): string {\n  if (isAbsolutePath(path)) return path;\n  if (path.startsWith('./')) return path;\n  if (path.startsWith('../')) return path;\n  return `./${path}`;\n}\n"],"names":[],"mappings":";AAOA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,UAAU;AACnB;AAOA,SAAS,eAAe,OAAwB;AAC9C,SAAO,UAAU;AACnB;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,KAAK,WAAW,GAAG;AAC5B;AAYO,SAAS,eAAe,MAAuB;AAC7C,SAAA,CAAC,eAAe,IAAI;AAC7B;AAYO,SAAS,cAAc,MAAsB;AAC5C,QAAA,SAAS,KACZ,QAAQ,OAAO,GAAG,EAClB,QAAQ,WAAW,GAAG,EACtB,QAAQ,WAAW,IAAI,EACvB,QAAQ,WAAW,GAAG,EACtB,MAAM,GAAG,EACT,IAAI,CAAC,UAAU,MAAM,KAAA,CAAM;AAC9B,QAAM,SAAmB,CAAC;AACpB,QAAA,QAAQ,OAAO,CAAC,MAAM;AAEtB,QAAA,OAAO,CAAC,UAAkB;AAC9B,WAAO,KAAK,KAAK;AAAA,EACnB;AAEA,QAAM,OAAO,MAAM;AAEb,QAAA,OAAO,WAAW,KAAK,MAAO;AAGlC,QAAI,OAAO,WAAW,KAAK,OAAO,GAAG,EAAE,MAAM,MAAM;AACjD,aAAO,KAAK,IAAI;AAAA,IAAA,OACX;AACL,aAAO,IAAI;AAAA,IAAA;AAAA,EAEf;AAEA,aAAW,SAAS,QAAQ;AACpB,UAAA,YAAY,gBAAgB,KAAK;AACjC,UAAA,WAAW,eAAe,KAAK;AASrC,QAAI,WAAW;AACb;AAAA,IAAA;AAGF,QAAI,UAAU;AACP,WAAA;AACL;AAAA,IAAA;AAGF,SAAK,KAAK;AAAA,EAAA;AAGL,SAAA,OAAO,KAAK,GAAG;AACxB;AAagB,SAAA,SAAS,SAAiB,IAAsB;AACvD,SAAA,cAAc,CAAC,MAAM,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC;AAC9C;AAagB,SAAA,YAAY,SAAiB,IAAsB;AACjE,QAAM,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,IAAI,aAAa;AAE7C,MAAI,gBAAgB;AACpB,MAAI,iBAAiB;AAErB;AAAA,IACE;AAAA,IACA,CAAC,MAAM,UAAU;AACX,UAAA,eAAe,IAAI,GAAG;AACR,wBAAA;AACC,yBAAA;AACV,eAAA;AAAA,MAAA;AAAA,IAEX;AAAA,IACA;AAAA,EACF;AAEA,SAAO,SAAS,eAAe,GAAG,MAAM,MAAM,iBAAiB,CAAC,CAAC;AACnE;AA0BO,SAAS,eAAe,MAAsB;AAC/C,MAAA,eAAe,IAAI,EAAU,QAAA;AACjC,MAAI,KAAK,WAAW,IAAI,EAAU,QAAA;AAClC,MAAI,KAAK,WAAW,KAAK,EAAU,QAAA;AACnC,SAAO,KAAK,IAAI;AAClB;"}

package/dist/promise.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("./type.cjs");
+function isPromiseLike(unknown) {
+  return type.isPromise(unknown) || type.isObject(unknown) && typeof unknown.then === "function";
+}
+async function promiseDelay(ms = 0, ctrl) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    if (ctrl) {
+      ctrl.signal.addEventListener("abort", () => {
+        clearTimeout(t);
+        resolve();
+      });
+    }
+  });
+}
+async function promiseTimeout(promise, ms) {
+  const ctrl = new AbortController();
+  const result = await Promise.race([
+    promise,
+    promiseDelay(ms, ctrl).then(() => {
+      throw new Error("timeout");
+    })
+  ]);
+  ctrl.abort();
+  return result;
+}
+function promiseWhen(condition, ms = 10) {
+  return new Promise((resolve, reject) => {
+    const check = () => {
+      if (condition()) {
+        resolve();
+      } else {
+        setTimeout(check, ms);
+      }
+    };
+    check();
+  });
+}
+function promiseShared(promise) {
+  return new Promise((resolve, reject) => {
+    promise.then(resolve, reject);
+  });
+}
+function createMinDelayPromise(ms) {
+  const startTime = Date.now();
+  return async function end() {
+    const endTime = Date.now();
+    const waitTime = ms - (endTime - startTime);
+    if (waitTime > 0) {
+      await promiseDelay(waitTime);
+    }
+  };
+}
+exports.createMinDelayPromise = createMinDelayPromise;
+exports.isPromiseLike = isPromiseLike;
+exports.promiseDelay = promiseDelay;
+exports.promiseShared = promiseShared;
+exports.promiseTimeout = promiseTimeout;
+exports.promiseWhen = promiseWhen;
+//# sourceMappingURL=promise.cjs.map

package/dist/promise.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise.cjs","sources":["../src/promise.ts"],"sourcesContent":["import { isObject, isPromise } from './type';\n\n/**\n * 检查给定的值是否为 Promise 类似对象。\n * @param unknown - 要检查的值。\n * @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。\n */\nexport function isPromiseLike<T>(unknown: unknown): unknown is Promise<T> {\n  return isPromise(unknown) || (isObject(unknown) && typeof (unknown as unknown as Promise<T>).then === 'function');\n}\n\n/**\n * 等待一定时间后解决 Promise\n * @param ms - 等待的毫秒数，默认为 0\n * @param ctrl - 可选的 AbortController，用于提前终止等待\n * @returns 一个 Promise，等待指定时间后解决\n */\nexport async function promiseDelay(ms = 0, ctrl?: AbortController) {\n  return new Promise<void>((resolve) => {\n    const t = setTimeout(resolve, ms);\n\n    if (ctrl) {\n      ctrl.signal.addEventListener('abort', () => {\n        clearTimeout(t);\n        resolve();\n      });\n    }\n  });\n}\n\n/**\n * 使 Promise 在指定时间内执行，超时则拒绝\n * @param promise - 要执行的 Promise\n * @param ms - 超时的毫秒数\n * @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 \"timeout\" 错误\n * @throws {Error} 如果 Promise 超时，抛出 \"timeout\" 错误\n */\nexport async function promiseTimeout<T>(promise: Promise<T>, ms: number) {\n  const ctrl = new AbortController();\n  const result = await Promise.race([\n    promise,\n    promiseDelay(ms, ctrl).then(() => {\n      throw new Error('timeout');\n    }),\n  ]);\n  ctrl.abort();\n  return result;\n}\n\n/**\n * 在指定条件满足时解决 Promise\n * @param condition - 一个返回布尔值的函数，用于检查条件是否满足\n * @param ms - 检查条件的时间间隔（毫秒），默认为 10\n * @returns 一个 Promise，在条件满足时解决\n */\nexport function promiseWhen(condition: () => boolean, ms = 10) {\n  return new Promise<void>((resolve, reject) => {\n    const check = () => {\n      if (condition()) {\n        resolve();\n      } else {\n        setTimeout(check, ms);\n      }\n    };\n\n    check();\n  });\n}\n\n/**\n * 创建一个与给定 Promise 共享状态的新 Promise。\n * 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。\n * @param promise - 要共享状态的原始 Promise。\n * @returns 一个新的 Promise，其状态与给定的 Promise 完全相同。\n * @example\n * const { promise: p1 } = Promise.withResolvers();\n * const sp1 = sharedPromise(p1);\n * const sp2 = sharedPromise(p1);\n * // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力\n */\nexport function promiseShared<T>(promise: Promise<T>) {\n  return new Promise<T>((resolve, reject) => {\n    promise.then(resolve, reject);\n  });\n}\n\n/**\n * 创建一个最小等待时间的函数\n * @param {number} ms - 最小等待时间（毫秒）\n * @returns {function} 返回一个异步函数，该函数会确保从 createMinDelayPromise 调用到其执行的时间至少为 ms 毫秒\n * @example\n * const end = createMinDelayPromise(1000);\n * // 执行一些操作\n * await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒\n */\nexport function createMinDelayPromise(ms: number) {\n  const startTime = Date.now();\n  /**\n   * 确保最小等待时间的结束函数\n   * @async\n   * @function end\n   * @returns {Promise<void>} 在达到最小等待时间后解决\n   */\n  return async function end() {\n    const endTime = Date.now();\n    const waitTime = ms - (endTime - startTime);\n    if (waitTime > 0) {\n      await promiseDelay(waitTime);\n    }\n  };\n}\n"],"names":["isPromise","isObject"],"mappings":";;;AAOO,SAAS,cAAiB,SAAyC;AACjE,SAAAA,KAAA,UAAU,OAAO,KAAMC,KAAA,SAAS,OAAO,KAAK,OAAQ,QAAkC,SAAS;AACxG;AAQsB,eAAA,aAAa,KAAK,GAAG,MAAwB;AAC1D,SAAA,IAAI,QAAc,CAAC,YAAY;AAC9B,UAAA,IAAI,WAAW,SAAS,EAAE;AAEhC,QAAI,MAAM;AACH,WAAA,OAAO,iBAAiB,SAAS,MAAM;AAC1C,qBAAa,CAAC;AACN,gBAAA;AAAA,MAAA,CACT;AAAA,IAAA;AAAA,EACH,CACD;AACH;AASsB,eAAA,eAAkB,SAAqB,IAAY;AACjE,QAAA,OAAO,IAAI,gBAAgB;AAC3B,QAAA,SAAS,MAAM,QAAQ,KAAK;AAAA,IAChC;AAAA,IACA,aAAa,IAAI,IAAI,EAAE,KAAK,MAAM;AAC1B,YAAA,IAAI,MAAM,SAAS;AAAA,IAC1B,CAAA;AAAA,EAAA,CACF;AACD,OAAK,MAAM;AACJ,SAAA;AACT;AAQgB,SAAA,YAAY,WAA0B,KAAK,IAAI;AAC7D,SAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC5C,UAAM,QAAQ,MAAM;AAClB,UAAI,aAAa;AACP,gBAAA;AAAA,MAAA,OACH;AACL,mBAAW,OAAO,EAAE;AAAA,MAAA;AAAA,IAExB;AAEM,UAAA;AAAA,EAAA,CACP;AACH;AAaO,SAAS,cAAiB,SAAqB;AACpD,SAAO,IAAI,QAAW,CAAC,SAAS,WAAW;AACjC,YAAA,KAAK,SAAS,MAAM;AAAA,EAAA,CAC7B;AACH;AAWO,SAAS,sBAAsB,IAAY;AAC1C,QAAA,YAAY,KAAK,IAAI;AAO3B,SAAO,eAAe,MAAM;AACpB,UAAA,UAAU,KAAK,IAAI;AACnB,UAAA,WAAW,MAAM,UAAU;AACjC,QAAI,WAAW,GAAG;AAChB,YAAM,aAAa,QAAQ;AAAA,IAAA;AAAA,EAE/B;AACF;;;;;;;"}

package/{src/promise.ts → dist/promise.d.ts}

@@ -1,33 +1,16 @@
-import { isObject, isPromise } from './type';
-
 /**
  * 检查给定的值是否为 Promise 类似对象。
  * @param unknown - 要检查的值。
  * @returns 如果值是 Promise 类似对象，则返回 `true`，否则返回 `false`。
  */
-export function isPromiseLike<T>(unknown: unknown): unknown is Promise<T> {
-  return isPromise(unknown) || (isObject(unknown) && typeof (unknown as unknown as Promise<T>).then === 'function');
-}
-
+export declare function isPromiseLike<T>(unknown: unknown): unknown is Promise<T>;
 /**
  * 等待一定时间后解决 Promise
  * @param ms - 等待的毫秒数，默认为 0
  * @param ctrl - 可选的 AbortController，用于提前终止等待
  * @returns 一个 Promise，等待指定时间后解决
  */
-export async function promiseDelay(ms = 0, ctrl?: AbortController) {
-  return new Promise<void>((resolve) => {
-    const t = setTimeout(resolve, ms);
-
-    if (ctrl) {
-      ctrl.signal.addEventListener('abort', () => {
-        clearTimeout(t);
-        resolve();
-      });
-    }
-  });
-}
-
+export declare function promiseDelay(ms?: number, ctrl?: AbortController): Promise<void>;
 /**
  * 使 Promise 在指定时间内执行，超时则拒绝
  * @param promise - 要执行的 Promise
@@ -35,38 +18,14 @@ export async function promiseDelay(ms = 0, ctrl?: AbortController) {
  * @returns 如果 Promise 在指定时间内解决，则返回其结果；否则抛出 "timeout" 错误
  * @throws {Error} 如果 Promise 超时，抛出 "timeout" 错误
  */
-export async function promiseTimeout<T>(promise: Promise<T>, ms: number) {
-  const ctrl = new AbortController();
-  const result = await Promise.race([
-    promise,
-    promiseDelay(ms, ctrl).then(() => {
-      throw new Error('timeout');
-    }),
-  ]);
-  ctrl.abort();
-  return result;
-}
-
+export declare function promiseTimeout<T>(promise: Promise<T>, ms: number): Promise<T>;
 /**
  * 在指定条件满足时解决 Promise
  * @param condition - 一个返回布尔值的函数，用于检查条件是否满足
  * @param ms - 检查条件的时间间隔（毫秒），默认为 10
  * @returns 一个 Promise，在条件满足时解决
  */
-export function promiseWhen(condition: () => boolean, ms = 10) {
-  return new Promise<void>((resolve, reject) => {
-    const check = () => {
-      if (condition()) {
-        resolve();
-      } else {
-        setTimeout(check, ms);
-      }
-    };
-
-    check();
-  });
-}
-
+export declare function promiseWhen(condition: () => boolean, ms?: number): Promise<void>;
 /**
  * 创建一个与给定 Promise 共享状态的新 Promise。
  * 新的 Promise 不具备 resolve 或 reject 的能力，它仅反映原始 Promise 的状态。
@@ -78,12 +37,7 @@ export function promiseWhen(condition: () => boolean, ms = 10) {
  * const sp2 = sharedPromise(p1);
  * // 此时 sp1、sp2 完全共享 p1 的状态，自身并不具备 resolve 或 reject 的能力
  */
-export function promiseShared<T>(promise: Promise<T>) {
-  return new Promise<T>((resolve, reject) => {
-    promise.then(resolve, reject);
-  });
-}
-
+export declare function promiseShared<T>(promise: Promise<T>): Promise<T>;
 /**
  * 创建一个最小等待时间的函数
  * @param {number} ms - 最小等待时间（毫秒）
@@ -93,19 +47,4 @@ export function promiseShared<T>(promise: Promise<T>) {
  * // 执行一些操作
  * await end(); // 确保从 createMinDelayPromise 调用到这里的总时间至少为 1000 毫秒
  */
-export function createMinDelayPromise(ms: number) {
-  const startTime = Date.now();
-  /**
-   * 确保最小等待时间的结束函数
-   * @async
-   * @function end
-   * @returns {Promise<void>} 在达到最小等待时间后解决
-   */
-  return async function end() {
-    const endTime = Date.now();
-    const waitTime = ms - (endTime - startTime);
-    if (waitTime > 0) {
-      await promiseDelay(waitTime);
-    }
-  };
-}
+export declare function createMinDelayPromise(ms: number): () => Promise<void>;