@cloudcome/utils-core 1.20.0 → 1.21.0

package/dist/error.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"error.cjs","names":[],"sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(\n  throwError: E,\n) {\n  return (\n    isError(throwError)\n      ? throwError\n      : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(\n  error: Error,\n  source: E,\n): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,eACd,YACA;CACA,OACE,aAAA,QAAQ,WAAW,GACf,aACA,IAAI,MAAM,OAAO,aAAA,UAAU,WAAW,GAAG,KAAK,WAAW,CAAC;;;;;;;;;;;;;AAelE,SAAgB,YACd,OACA,QACW;CACX,OAAO,OAAO,OAAO,OAAO,OAAO"}
+{"version":3,"file":"error.cjs","names":[],"sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,eAAoD,YAAe;CACjF,OACE,aAAA,QAAQ,WAAW,GAAG,aAAa,IAAI,MAAM,OAAO,aAAA,UAAU,WAAW,GAAG,KAAK,WAAW,CAAC;;;;;;;;;;;;;AAejG,SAAgB,YAAiC,OAAc,QAAsB;CACnF,OAAO,OAAO,OAAO,OAAO,OAAO"}

package/dist/error.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"error.mjs","names":[],"sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(\n  throwError: E,\n) {\n  return (\n    isError(throwError)\n      ? throwError\n      : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(\n  error: Error,\n  source: E,\n): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,eACd,YACA;CACA,OACE,QAAQ,WAAW,GACf,aACA,IAAI,MAAM,OAAO,UAAU,WAAW,GAAG,KAAK,WAAW,CAAC;;;;;;;;;;;;;AAelE,SAAgB,YACd,OACA,QACW;CACX,OAAO,OAAO,OAAO,OAAO,OAAO"}
+{"version":3,"file":"error.mjs","names":[],"sources":["../src/error.ts"],"sourcesContent":["import { isError, isNullish } from './type';\nimport type { AnyObject } from './types';\n\n/**\n * 标准化处理 Error 对象，适用于 try-catch\n * @param throwError 接收抛出的错误字符串或者 Error 对象或字符串\n * @returns {Error}\n * @example\n * const error = errorNormalize('这是一个错误');\n * console.log(error.message); // 输出: 这是一个错误\n */\nexport function errorNormalize<E extends Error | unknown = unknown>(throwError: E) {\n  return (\n    isError(throwError) ? throwError : new Error(String(isNullish(throwError) ? '' : throwError))\n  ) as E extends Error ? E : Error;\n}\n\n/**\n * 分配对象到 Error 对象上，适用于扩展 Error 实例，不影响原型和构造函数\n * @param {Error} error\n * @param {E} source\n * @returns {Error & E}\n * @example\n * const error = new Error('原始错误');\n * const extendedError = errorAssign(error, { code: 404, message: '未找到资源' });\n * console.log(extendedError.code); // 输出: 404\n * console.log(extendedError.message); // 输出: 未找到资源\n */\nexport function errorAssign<E extends AnyObject>(error: Error, source: E): Error & E {\n  return Object.assign(error, source) as Error & E;\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,eAAoD,YAAe;CACjF,OACE,QAAQ,WAAW,GAAG,aAAa,IAAI,MAAM,OAAO,UAAU,WAAW,GAAG,KAAK,WAAW,CAAC;;;;;;;;;;;;;AAejG,SAAgB,YAAiC,OAAc,QAAsB;CACnF,OAAO,OAAO,OAAO,OAAO,OAAO"}

package/dist/exception.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"exception.cjs","names":[],"sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\n\n/**\n * 构建异常选项\n */\nexport type DefineExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: DefineExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = defineException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = defineException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function defineException<T = void>(\n  name: string,\n  options?: DefineExceptionOptions,\n) {\n  const { format } = objectDefaults(\n    options || {},\n    defaults,\n  ) as Required<DefineExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = defineException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = defineException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"mappings":";;;;;;AAoBA,IAAM,WAAmC;;;;;AAKvC,SAAS,MAAM,YAAY,IAAI,KAAK,IAAI,WACzC;;;;;;;;;;;;;;;AAgBD,SAAgB,gBACd,MACA,SACA;CACA,MAAM,EAAE,WAAW,eAAA,eACjB,WAAW,EAAE,EACb,SACD;CAED,OAAO,cAAc,MAAM;EACzB,YAAY,SAAiB,OAAU;GACrC,MAAM,OAAO,MAAM,QAAQ,CAAC;GAC5B,KAAK,OAAO;GACZ,OAAO,OAAO,MAAM,MAAM"}
+{"version":3,"file":"exception.cjs","names":[],"sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\n\n/**\n * 构建异常选项\n */\nexport type DefineExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: DefineExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = defineException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = defineException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function defineException<T = void>(name: string, options?: DefineExceptionOptions) {\n  const { format } = objectDefaults(options || {}, defaults) as Required<DefineExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = defineException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = defineException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"mappings":";;;;;;AAoBA,IAAM,WAAmC;;;;;AAKvC,SAAS,MAAM,YAAY,IAAI,KAAK,IAAI,WACzC;;;;;;;;;;;;;;;AAgBD,SAAgB,gBAA0B,MAAc,SAAkC;CACxF,MAAM,EAAE,WAAW,eAAA,eAAe,WAAW,EAAE,EAAE,SAAS;CAE1D,OAAO,cAAc,MAAM;EACzB,YAAY,SAAiB,OAAU;GACrC,MAAM,OAAO,MAAM,QAAQ,CAAC;GAC5B,KAAK,OAAO;GACZ,OAAO,OAAO,MAAM,MAAM"}

package/dist/exception.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"exception.mjs","names":[],"sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\n\n/**\n * 构建异常选项\n */\nexport type DefineExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: DefineExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = defineException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = defineException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function defineException<T = void>(\n  name: string,\n  options?: DefineExceptionOptions,\n) {\n  const { format } = objectDefaults(\n    options || {},\n    defaults,\n  ) as Required<DefineExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = defineException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = defineException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"mappings":";;;;;AAoBA,IAAM,WAAmC;;;;;AAKvC,SAAS,MAAM,YAAY,IAAI,KAAK,IAAI,WACzC;;;;;;;;;;;;;;;AAgBD,SAAgB,gBACd,MACA,SACA;CACA,MAAM,EAAE,WAAW,eACjB,WAAW,EAAE,EACb,SACD;CAED,OAAO,cAAc,MAAM;EACzB,YAAY,SAAiB,OAAU;GACrC,MAAM,OAAO,MAAM,QAAQ,CAAC;GAC5B,KAAK,OAAO;GACZ,OAAO,OAAO,MAAM,MAAM"}
+{"version":3,"file":"exception.mjs","names":[],"sources":["../src/exception.ts"],"sourcesContent":["import { objectDefaults } from './object';\n\n/**\n * 构建异常选项\n */\nexport type DefineExceptionOptions = {\n  /**\n   * 自定义错误消息格式函数\n   * @param name 错误名称\n   * @param message 原始错误消息\n   * @returns 格式化后的错误消息\n   * @example\n   * (name, message) => `${name}::${message}`\n   */\n  format?: (name: string, message: string) => string;\n};\n\n/**\n * 默认的异常构建选项\n */\nconst defaults: DefineExceptionOptions = {\n  /**\n   * 默认消息格式函数\n   * @default (name, message) => `[${name}] ${message}`\n   */\n  format: (name, message) => `[${name}] ${message}`,\n};\n\n/**\n * 自定义异常类\n * @template T 额外属性的类型\n * @param name 异常类名称\n * @param options 构建选项\n * @returns 自定义异常类\n * @example\n * const MyException = defineException<{ code: number }>('MyException');\n * const err = new MyException('error', { code: 404 });\n *\n * @example\n * const SimpleException = defineException('SimpleException');\n * const err = new SimpleException('error', undefined);\n */\nexport function defineException<T = void>(name: string, options?: DefineExceptionOptions) {\n  const { format } = objectDefaults(options || {}, defaults) as Required<DefineExceptionOptions>;\n\n  return class extends Error {\n    constructor(message: string, extra: T) {\n      super(format(name, message));\n      this.name = name;\n      Object.assign(this, extra);\n    }\n  } as unknown as {\n    new (message: string, extra: T): Error & T;\n  };\n}\n\n// const MyException = defineException<{ foo: string; bar: number }>('MyException: ');\n// const myException = new MyException('bar', { foo: '1', bar: 1 });\n// myException.foo;\n// myException.bar;\n// myException.name;\n// myException.message;\n// myException.stack;\n// myException.cause;\n\n// const MyException2 = defineException('MyException2: ');\n// const myException2 = new MyException2('bar');\n"],"mappings":";;;;;AAoBA,IAAM,WAAmC;;;;;AAKvC,SAAS,MAAM,YAAY,IAAI,KAAK,IAAI,WACzC;;;;;;;;;;;;;;;AAgBD,SAAgB,gBAA0B,MAAc,SAAkC;CACxF,MAAM,EAAE,WAAW,eAAe,WAAW,EAAE,EAAE,SAAS;CAE1D,OAAO,cAAc,MAAM;EACzB,YAAY,SAAiB,OAAU;GACrC,MAAM,OAAO,MAAM,QAAQ,CAAC;GAC5B,KAAK,OAAO;GACZ,OAAO,OAAO,MAAM,MAAM"}

package/dist/function.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_type = require("./type.cjs");
+const require_promise = require("./promise.cjs");
 //#region src/function.ts
 /**
 * 一个空操作函数，不执行任何操作。
@@ -130,10 +131,42 @@ function fnOnce(fn) {
 		return result;
 	};
 }
+/**
+* 创建一个带重试能力的函数，失败时自动重试直到成功或耗尽次数。
+*
+* @param fn - 需要重试的函数。
+* @param options - 重试配置选项。
+* @returns 返回一个带重试能力的函数。
+*
+* @example
+* ```typescript
+* const fetchData = fnRetry(async () => {
+*   return await api.request('/data');
+* }, { maxAttempts: 3, delay: 1000 });
+*
+* // 第1次失败 → 等待1s → 第2次失败 → 等待1s → 第3次成功 → 返回结果
+* const result = await fetchData();
+* ```
+*/
+function fnRetry(fn, options = {}) {
+	const { maxAttempts = 3, delay = 0, retryWhen } = options;
+	return async function(...args) {
+		let lastError;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+			return await fn.apply(this, args);
+		} catch (error) {
+			lastError = error;
+			if (retryWhen && !retryWhen(error)) break;
+			if (attempt < maxAttempts && delay > 0) await require_promise.promiseDelay(delay);
+		}
+		throw lastError;
+	};
+}
 //#endregion
 exports.fnDebounce = fnDebounce;
 exports.fnNoop = fnNoop;
 exports.fnOnce = fnOnce;
+exports.fnRetry = fnRetry;
 exports.fnThrottle = fnThrottle;
 
 //# sourceMappingURL=function.cjs.map

package/dist/function.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"function.cjs","names":[],"sources":["../src/function.ts"],"sourcesContent":["import { isNumber } from './type';\nimport type { AnyFunction } from './types';\n\n/**\n * 一个空操作函数，不执行任何操作。\n *\n * @example\n * ```typescript\n * fnNoop(); // 不执行任何操作\n * ```\n */\nexport function fnNoop() {\n  //\n}\n\n/**\n * 防抖函数的配置选项。\n */\nexport type DebounceOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n  /**\n   * 是否在等待开始时立即执行一次\n   * @default false\n   */\n  leading?: boolean;\n};\n\n/**\n * 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。\n *\n * @param fn - 需要防抖的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。\n * @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。\n *\n * @example\n * ```typescript\n * const debouncedFn = fnDebounce(() => {\n *   console.log('Debounced!');\n * }, 100);\n *\n * debouncedFn(); // 不会立即执行\n * debouncedFn(); // 重新计时\n * debouncedFn.cancel(); // 取消防抖操作\n * ```\n */\nexport function fnDebounce<F extends AnyFunction>(\n  fn: F,\n  wait: number | DebounceOptions,\n) {\n  const options: DebounceOptions = isNumber(wait) ? { wait } : wait;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n  let leading = false;\n\n  const debounced = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    // 第一次执行\n    if (options.leading && !leading) {\n      leading = true;\n      fn.apply(this, args);\n      return;\n    }\n\n    // 最后一次执行\n    clearTimeout(timer);\n    timer = setTimeout(() => {\n      if (canceled) return;\n\n      fn.apply(this, args);\n    }, options.wait);\n  };\n\n  debounced.cancel = () => {\n    clearTimeout(timer);\n    canceled = true;\n  };\n\n  return debounced;\n}\n\nexport type ThrottleOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n\n  /**\n   * 是否在第一次调用时立即执行\n   * @default false\n   */\n  leading?: boolean;\n\n  /**\n   * 是否在调用结束后等待一段时间再执行\n   * @default false\n   */\n  trailing?: boolean;\n};\n\n/**\n * 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。\n *\n * @param fn - 需要节流的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。\n * @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。\n *\n * @example\n * ```typescript\n * const throttledFn = fnThrottle(() => {\n *   console.log('Throttled!');\n * }, 100);\n *\n * throttledFn(); // 立即执行\n * throttledFn(); // 忽略\n * throttledFn.cancel(); // 取消节流操作\n * ```\n */\nexport function fnThrottle<F extends AnyFunction>(\n  fn: F,\n  wait: number | ThrottleOptions,\n) {\n  const options = isNumber(wait) ? { wait } : wait;\n  const waitFinal = options.wait;\n  let lastTime = 0;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n\n  const throttled = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    const now = Date.now();\n    let executed = false;\n\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行，仅在本次未执行时才设置 trailing\n    if (options.trailing && !executed) {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        fn.apply(this, args);\n      }, waitFinal);\n    }\n  };\n\n  throttled.cancel = () => {\n    canceled = true;\n    clearTimeout(timer);\n  };\n\n  return throttled;\n}\n\n/**\n * 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。\n *\n * @param fn - 需要只执行一次的函数。\n * @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。\n *\n * @example\n * ```typescript\n * const onceFn = fnOnce(() => {\n *   console.log('This will be logged only once.');\n *   return 42;\n * });\n *\n * console.log(onceFn()); // 输出: This will be logged only once. 42\n * console.log(onceFn()); // 输出: 42\n * ```\n */\nexport function fnOnce<F extends AnyFunction>(fn: F) {\n  let called = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let result: any;\n\n  return function (this: unknown, ...args: Parameters<F>) {\n    if (!called) {\n      called = true;\n      result = fn.apply(this, args);\n    }\n\n    return result;\n  };\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,SAAS;;;;;;;;;;;;;;;;;;;AAqCzB,SAAgB,WACd,IACA,MACA;CACA,MAAM,UAA2B,aAAA,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC7D,IAAI,WAAW;CAEf,IAAI;CACJ,IAAI,UAAU;CAEd,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAGd,IAAI,QAAQ,WAAW,CAAC,SAAS;GAC/B,UAAU;GACV,GAAG,MAAM,MAAM,KAAK;GACpB;;EAIF,aAAa,MAAM;EACnB,QAAQ,iBAAiB;GACvB,IAAI,UAAU;GAEd,GAAG,MAAM,MAAM,KAAK;KACnB,QAAQ,KAAK;;CAGlB,UAAU,eAAe;EACvB,aAAa,MAAM;EACnB,WAAW;;CAGb,OAAO;;;;;;;;;;;;;;;;;;;;AAwCT,SAAgB,WACd,IACA,MACA;CACA,MAAM,UAAU,aAAA,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC5C,MAAM,YAAY,QAAQ;CAC1B,IAAI,WAAW;CACf,IAAI,WAAW;CAEf,IAAI;CAEJ,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAEd,MAAM,MAAM,KAAK,KAAK;EACtB,IAAI,WAAW;EAGf,IAAI,QAAQ,WAAW,aAAa,GAAG;GACrC,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,WAAW,KAAK,MAAM,YAAY,WAAW;GACpD,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,aAAa,GACpB,WAAW;EAIb,IAAI,QAAQ,YAAY,CAAC,UAAU;GACjC,aAAa,MAAM;GACnB,QAAQ,iBAAiB;IACvB,GAAG,MAAM,MAAM,KAAK;MACnB,UAAU;;;CAIjB,UAAU,eAAe;EACvB,WAAW;EACX,aAAa,MAAM;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;AAoBT,SAAgB,OAA8B,IAAO;CACnD,IAAI,SAAS;CAEb,IAAI;CAEJ,OAAO,SAAyB,GAAG,MAAqB;EACtD,IAAI,CAAC,QAAQ;GACX,SAAS;GACT,SAAS,GAAG,MAAM,MAAM,KAAK;;EAG/B,OAAO"}
+{"version":3,"file":"function.cjs","names":[],"sources":["../src/function.ts"],"sourcesContent":["import { promiseDelay } from './promise';\nimport { isNumber } from './type';\nimport type { AnyFunction } from './types';\n\n/**\n * 一个空操作函数，不执行任何操作。\n *\n * @example\n * ```typescript\n * fnNoop(); // 不执行任何操作\n * ```\n */\nexport function fnNoop() {\n  //\n}\n\n/**\n * 防抖函数的配置选项。\n */\nexport type DebounceOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n  /**\n   * 是否在等待开始时立即执行一次\n   * @default false\n   */\n  leading?: boolean;\n};\n\n/**\n * 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。\n *\n * @param fn - 需要防抖的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。\n * @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。\n *\n * @example\n * ```typescript\n * const debouncedFn = fnDebounce(() => {\n *   console.log('Debounced!');\n * }, 100);\n *\n * debouncedFn(); // 不会立即执行\n * debouncedFn(); // 重新计时\n * debouncedFn.cancel(); // 取消防抖操作\n * ```\n */\nexport function fnDebounce<F extends AnyFunction>(fn: F, wait: number | DebounceOptions) {\n  const options: DebounceOptions = isNumber(wait) ? { wait } : wait;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n  let leading = false;\n\n  const debounced = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    // 第一次执行\n    if (options.leading && !leading) {\n      leading = true;\n      fn.apply(this, args);\n      return;\n    }\n\n    // 最后一次执行\n    clearTimeout(timer);\n    timer = setTimeout(() => {\n      if (canceled) return;\n\n      fn.apply(this, args);\n    }, options.wait);\n  };\n\n  debounced.cancel = () => {\n    clearTimeout(timer);\n    canceled = true;\n  };\n\n  return debounced;\n}\n\nexport type ThrottleOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n\n  /**\n   * 是否在第一次调用时立即执行\n   * @default false\n   */\n  leading?: boolean;\n\n  /**\n   * 是否在调用结束后等待一段时间再执行\n   * @default false\n   */\n  trailing?: boolean;\n};\n\n/**\n * 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。\n *\n * @param fn - 需要节流的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。\n * @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。\n *\n * @example\n * ```typescript\n * const throttledFn = fnThrottle(() => {\n *   console.log('Throttled!');\n * }, 100);\n *\n * throttledFn(); // 立即执行\n * throttledFn(); // 忽略\n * throttledFn.cancel(); // 取消节流操作\n * ```\n */\nexport function fnThrottle<F extends AnyFunction>(fn: F, wait: number | ThrottleOptions) {\n  const options = isNumber(wait) ? { wait } : wait;\n  const waitFinal = options.wait;\n  let lastTime = 0;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n\n  const throttled = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    const now = Date.now();\n    let executed = false;\n\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行，仅在本次未执行时才设置 trailing\n    if (options.trailing && !executed) {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        fn.apply(this, args);\n      }, waitFinal);\n    }\n  };\n\n  throttled.cancel = () => {\n    canceled = true;\n    clearTimeout(timer);\n  };\n\n  return throttled;\n}\n\n/**\n * 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。\n *\n * @param fn - 需要只执行一次的函数。\n * @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。\n *\n * @example\n * ```typescript\n * const onceFn = fnOnce(() => {\n *   console.log('This will be logged only once.');\n *   return 42;\n * });\n *\n * console.log(onceFn()); // 输出: This will be logged only once. 42\n * console.log(onceFn()); // 输出: 42\n * ```\n */\nexport function fnOnce<F extends AnyFunction>(fn: F) {\n  let called = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let result: any;\n\n  return function (this: unknown, ...args: Parameters<F>) {\n    if (!called) {\n      called = true;\n      result = fn.apply(this, args);\n    }\n\n    return result;\n  };\n}\n\nexport type FnRetryOptions = {\n  /**\n   * 最大尝试次数\n   */\n  maxAttempts?: number;\n  /**\n   * 每次重试之间的延迟时间（毫秒）\n   * @default 0\n   */\n  delay?: number;\n  /**\n   * 自定义重试条件，返回 true 时触发重试\n   * @default 仅在抛出错误时重试\n   */\n  retryWhen?: (error: unknown) => boolean;\n};\n\n/**\n * 创建一个带重试能力的函数，失败时自动重试直到成功或耗尽次数。\n *\n * @param fn - 需要重试的函数。\n * @param options - 重试配置选项。\n * @returns 返回一个带重试能力的函数。\n *\n * @example\n * ```typescript\n * const fetchData = fnRetry(async () => {\n *   return await api.request('/data');\n * }, { maxAttempts: 3, delay: 1000 });\n *\n * // 第1次失败 → 等待1s → 第2次失败 → 等待1s → 第3次成功 → 返回结果\n * const result = await fetchData();\n * ```\n */\nexport function fnRetry<F extends AnyFunction>(fn: F, options: FnRetryOptions = {}) {\n  const { maxAttempts = 3, delay = 0, retryWhen } = options;\n\n  return async function (this: unknown, ...args: Parameters<F>): Promise<Awaited<ReturnType<F>>> {\n    let lastError: unknown;\n\n    for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n      try {\n        return (await fn.apply(this, args)) as Awaited<ReturnType<F>>;\n      } catch (error) {\n        lastError = error;\n\n        if (retryWhen && !retryWhen(error)) break;\n\n        if (attempt < maxAttempts && delay > 0) {\n          await promiseDelay(delay);\n        }\n      }\n    }\n\n    throw lastError;\n  };\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,SAAS;;;;;;;;;;;;;;;;;;;AAqCzB,SAAgB,WAAkC,IAAO,MAAgC;CACvF,MAAM,UAA2B,aAAA,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC7D,IAAI,WAAW;CAEf,IAAI;CACJ,IAAI,UAAU;CAEd,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAGd,IAAI,QAAQ,WAAW,CAAC,SAAS;GAC/B,UAAU;GACV,GAAG,MAAM,MAAM,KAAK;GACpB;;EAIF,aAAa,MAAM;EACnB,QAAQ,iBAAiB;GACvB,IAAI,UAAU;GAEd,GAAG,MAAM,MAAM,KAAK;KACnB,QAAQ,KAAK;;CAGlB,UAAU,eAAe;EACvB,aAAa,MAAM;EACnB,WAAW;;CAGb,OAAO;;;;;;;;;;;;;;;;;;;;AAwCT,SAAgB,WAAkC,IAAO,MAAgC;CACvF,MAAM,UAAU,aAAA,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC5C,MAAM,YAAY,QAAQ;CAC1B,IAAI,WAAW;CACf,IAAI,WAAW;CAEf,IAAI;CAEJ,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAEd,MAAM,MAAM,KAAK,KAAK;EACtB,IAAI,WAAW;EAGf,IAAI,QAAQ,WAAW,aAAa,GAAG;GACrC,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,WAAW,KAAK,MAAM,YAAY,WAAW;GACpD,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,aAAa,GACpB,WAAW;EAIb,IAAI,QAAQ,YAAY,CAAC,UAAU;GACjC,aAAa,MAAM;GACnB,QAAQ,iBAAiB;IACvB,GAAG,MAAM,MAAM,KAAK;MACnB,UAAU;;;CAIjB,UAAU,eAAe;EACvB,WAAW;EACX,aAAa,MAAM;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;AAoBT,SAAgB,OAA8B,IAAO;CACnD,IAAI,SAAS;CAEb,IAAI;CAEJ,OAAO,SAAyB,GAAG,MAAqB;EACtD,IAAI,CAAC,QAAQ;GACX,SAAS;GACT,SAAS,GAAG,MAAM,MAAM,KAAK;;EAG/B,OAAO;;;;;;;;;;;;;;;;;;;;AAsCX,SAAgB,QAA+B,IAAO,UAA0B,EAAE,EAAE;CAClF,MAAM,EAAE,cAAc,GAAG,QAAQ,GAAG,cAAc;CAElD,OAAO,eAA+B,GAAG,MAAsD;EAC7F,IAAI;EAEJ,KAAK,IAAI,UAAU,GAAG,WAAW,aAAa,WAC5C,IAAI;GACF,OAAQ,MAAM,GAAG,MAAM,MAAM,KAAK;WAC3B,OAAO;GACd,YAAY;GAEZ,IAAI,aAAa,CAAC,UAAU,MAAM,EAAE;GAEpC,IAAI,UAAU,eAAe,QAAQ,GACnC,MAAM,gBAAA,aAAa,MAAM;;EAK/B,MAAM"}

package/dist/function.d.ts

@@ -100,3 +100,37 @@ export declare function fnThrottle<F extends AnyFunction>(fn: F, wait: number |
  * ```
  */
 export declare function fnOnce<F extends AnyFunction>(fn: F): (this: unknown, ...args: Parameters<F>) => any;
+export type FnRetryOptions = {
+    /**
+     * 最大尝试次数
+     */
+    maxAttempts?: number;
+    /**
+     * 每次重试之间的延迟时间（毫秒）
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * 自定义重试条件，返回 true 时触发重试
+     * @default 仅在抛出错误时重试
+     */
+    retryWhen?: (error: unknown) => boolean;
+};
+/**
+ * 创建一个带重试能力的函数，失败时自动重试直到成功或耗尽次数。
+ *
+ * @param fn - 需要重试的函数。
+ * @param options - 重试配置选项。
+ * @returns 返回一个带重试能力的函数。
+ *
+ * @example
+ * ```typescript
+ * const fetchData = fnRetry(async () => {
+ *   return await api.request('/data');
+ * }, { maxAttempts: 3, delay: 1000 });
+ *
+ * // 第1次失败 → 等待1s → 第2次失败 → 等待1s → 第3次成功 → 返回结果
+ * const result = await fetchData();
+ * ```
+ */
+export declare function fnRetry<F extends AnyFunction>(fn: F, options?: FnRetryOptions): (this: unknown, ...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;

package/dist/function.mjs

@@ -1,4 +1,5 @@
 import { isNumber } from "./type.mjs";
+import { promiseDelay } from "./promise.mjs";
 //#region src/function.ts
 /**
 * 一个空操作函数，不执行任何操作。
@@ -129,7 +130,38 @@ function fnOnce(fn) {
 		return result;
 	};
 }
+/**
+* 创建一个带重试能力的函数，失败时自动重试直到成功或耗尽次数。
+*
+* @param fn - 需要重试的函数。
+* @param options - 重试配置选项。
+* @returns 返回一个带重试能力的函数。
+*
+* @example
+* ```typescript
+* const fetchData = fnRetry(async () => {
+*   return await api.request('/data');
+* }, { maxAttempts: 3, delay: 1000 });
+*
+* // 第1次失败 → 等待1s → 第2次失败 → 等待1s → 第3次成功 → 返回结果
+* const result = await fetchData();
+* ```
+*/
+function fnRetry(fn, options = {}) {
+	const { maxAttempts = 3, delay = 0, retryWhen } = options;
+	return async function(...args) {
+		let lastError;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+			return await fn.apply(this, args);
+		} catch (error) {
+			lastError = error;
+			if (retryWhen && !retryWhen(error)) break;
+			if (attempt < maxAttempts && delay > 0) await promiseDelay(delay);
+		}
+		throw lastError;
+	};
+}
 //#endregion
-export { fnDebounce, fnNoop, fnOnce, fnThrottle };
+export { fnDebounce, fnNoop, fnOnce, fnRetry, fnThrottle };
 
 //# sourceMappingURL=function.mjs.map

package/dist/function.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"function.mjs","names":[],"sources":["../src/function.ts"],"sourcesContent":["import { isNumber } from './type';\nimport type { AnyFunction } from './types';\n\n/**\n * 一个空操作函数，不执行任何操作。\n *\n * @example\n * ```typescript\n * fnNoop(); // 不执行任何操作\n * ```\n */\nexport function fnNoop() {\n  //\n}\n\n/**\n * 防抖函数的配置选项。\n */\nexport type DebounceOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n  /**\n   * 是否在等待开始时立即执行一次\n   * @default false\n   */\n  leading?: boolean;\n};\n\n/**\n * 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。\n *\n * @param fn - 需要防抖的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。\n * @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。\n *\n * @example\n * ```typescript\n * const debouncedFn = fnDebounce(() => {\n *   console.log('Debounced!');\n * }, 100);\n *\n * debouncedFn(); // 不会立即执行\n * debouncedFn(); // 重新计时\n * debouncedFn.cancel(); // 取消防抖操作\n * ```\n */\nexport function fnDebounce<F extends AnyFunction>(\n  fn: F,\n  wait: number | DebounceOptions,\n) {\n  const options: DebounceOptions = isNumber(wait) ? { wait } : wait;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n  let leading = false;\n\n  const debounced = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    // 第一次执行\n    if (options.leading && !leading) {\n      leading = true;\n      fn.apply(this, args);\n      return;\n    }\n\n    // 最后一次执行\n    clearTimeout(timer);\n    timer = setTimeout(() => {\n      if (canceled) return;\n\n      fn.apply(this, args);\n    }, options.wait);\n  };\n\n  debounced.cancel = () => {\n    clearTimeout(timer);\n    canceled = true;\n  };\n\n  return debounced;\n}\n\nexport type ThrottleOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n\n  /**\n   * 是否在第一次调用时立即执行\n   * @default false\n   */\n  leading?: boolean;\n\n  /**\n   * 是否在调用结束后等待一段时间再执行\n   * @default false\n   */\n  trailing?: boolean;\n};\n\n/**\n * 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。\n *\n * @param fn - 需要节流的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。\n * @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。\n *\n * @example\n * ```typescript\n * const throttledFn = fnThrottle(() => {\n *   console.log('Throttled!');\n * }, 100);\n *\n * throttledFn(); // 立即执行\n * throttledFn(); // 忽略\n * throttledFn.cancel(); // 取消节流操作\n * ```\n */\nexport function fnThrottle<F extends AnyFunction>(\n  fn: F,\n  wait: number | ThrottleOptions,\n) {\n  const options = isNumber(wait) ? { wait } : wait;\n  const waitFinal = options.wait;\n  let lastTime = 0;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n\n  const throttled = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    const now = Date.now();\n    let executed = false;\n\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行，仅在本次未执行时才设置 trailing\n    if (options.trailing && !executed) {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        fn.apply(this, args);\n      }, waitFinal);\n    }\n  };\n\n  throttled.cancel = () => {\n    canceled = true;\n    clearTimeout(timer);\n  };\n\n  return throttled;\n}\n\n/**\n * 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。\n *\n * @param fn - 需要只执行一次的函数。\n * @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。\n *\n * @example\n * ```typescript\n * const onceFn = fnOnce(() => {\n *   console.log('This will be logged only once.');\n *   return 42;\n * });\n *\n * console.log(onceFn()); // 输出: This will be logged only once. 42\n * console.log(onceFn()); // 输出: 42\n * ```\n */\nexport function fnOnce<F extends AnyFunction>(fn: F) {\n  let called = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let result: any;\n\n  return function (this: unknown, ...args: Parameters<F>) {\n    if (!called) {\n      called = true;\n      result = fn.apply(this, args);\n    }\n\n    return result;\n  };\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,SAAS;;;;;;;;;;;;;;;;;;;AAqCzB,SAAgB,WACd,IACA,MACA;CACA,MAAM,UAA2B,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC7D,IAAI,WAAW;CAEf,IAAI;CACJ,IAAI,UAAU;CAEd,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAGd,IAAI,QAAQ,WAAW,CAAC,SAAS;GAC/B,UAAU;GACV,GAAG,MAAM,MAAM,KAAK;GACpB;;EAIF,aAAa,MAAM;EACnB,QAAQ,iBAAiB;GACvB,IAAI,UAAU;GAEd,GAAG,MAAM,MAAM,KAAK;KACnB,QAAQ,KAAK;;CAGlB,UAAU,eAAe;EACvB,aAAa,MAAM;EACnB,WAAW;;CAGb,OAAO;;;;;;;;;;;;;;;;;;;;AAwCT,SAAgB,WACd,IACA,MACA;CACA,MAAM,UAAU,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC5C,MAAM,YAAY,QAAQ;CAC1B,IAAI,WAAW;CACf,IAAI,WAAW;CAEf,IAAI;CAEJ,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAEd,MAAM,MAAM,KAAK,KAAK;EACtB,IAAI,WAAW;EAGf,IAAI,QAAQ,WAAW,aAAa,GAAG;GACrC,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,WAAW,KAAK,MAAM,YAAY,WAAW;GACpD,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,aAAa,GACpB,WAAW;EAIb,IAAI,QAAQ,YAAY,CAAC,UAAU;GACjC,aAAa,MAAM;GACnB,QAAQ,iBAAiB;IACvB,GAAG,MAAM,MAAM,KAAK;MACnB,UAAU;;;CAIjB,UAAU,eAAe;EACvB,WAAW;EACX,aAAa,MAAM;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;AAoBT,SAAgB,OAA8B,IAAO;CACnD,IAAI,SAAS;CAEb,IAAI;CAEJ,OAAO,SAAyB,GAAG,MAAqB;EACtD,IAAI,CAAC,QAAQ;GACX,SAAS;GACT,SAAS,GAAG,MAAM,MAAM,KAAK;;EAG/B,OAAO"}
+{"version":3,"file":"function.mjs","names":[],"sources":["../src/function.ts"],"sourcesContent":["import { promiseDelay } from './promise';\nimport { isNumber } from './type';\nimport type { AnyFunction } from './types';\n\n/**\n * 一个空操作函数，不执行任何操作。\n *\n * @example\n * ```typescript\n * fnNoop(); // 不执行任何操作\n * ```\n */\nexport function fnNoop() {\n  //\n}\n\n/**\n * 防抖函数的配置选项。\n */\nexport type DebounceOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n  /**\n   * 是否在等待开始时立即执行一次\n   * @default false\n   */\n  leading?: boolean;\n};\n\n/**\n * 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。\n *\n * @param fn - 需要防抖的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。\n * @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。\n *\n * @example\n * ```typescript\n * const debouncedFn = fnDebounce(() => {\n *   console.log('Debounced!');\n * }, 100);\n *\n * debouncedFn(); // 不会立即执行\n * debouncedFn(); // 重新计时\n * debouncedFn.cancel(); // 取消防抖操作\n * ```\n */\nexport function fnDebounce<F extends AnyFunction>(fn: F, wait: number | DebounceOptions) {\n  const options: DebounceOptions = isNumber(wait) ? { wait } : wait;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n  let leading = false;\n\n  const debounced = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    // 第一次执行\n    if (options.leading && !leading) {\n      leading = true;\n      fn.apply(this, args);\n      return;\n    }\n\n    // 最后一次执行\n    clearTimeout(timer);\n    timer = setTimeout(() => {\n      if (canceled) return;\n\n      fn.apply(this, args);\n    }, options.wait);\n  };\n\n  debounced.cancel = () => {\n    clearTimeout(timer);\n    canceled = true;\n  };\n\n  return debounced;\n}\n\nexport type ThrottleOptions = {\n  /**\n   * 等待时间（毫秒）。\n   */\n  wait: number;\n\n  /**\n   * 是否在第一次调用时立即执行\n   * @default false\n   */\n  leading?: boolean;\n\n  /**\n   * 是否在调用结束后等待一段时间再执行\n   * @default false\n   */\n  trailing?: boolean;\n};\n\n/**\n * 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。\n *\n * @param fn - 需要节流的函数。\n * @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。\n * @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。\n *\n * @example\n * ```typescript\n * const throttledFn = fnThrottle(() => {\n *   console.log('Throttled!');\n * }, 100);\n *\n * throttledFn(); // 立即执行\n * throttledFn(); // 忽略\n * throttledFn.cancel(); // 取消节流操作\n * ```\n */\nexport function fnThrottle<F extends AnyFunction>(fn: F, wait: number | ThrottleOptions) {\n  const options = isNumber(wait) ? { wait } : wait;\n  const waitFinal = options.wait;\n  let lastTime = 0;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let timer: any;\n\n  const throttled = function (this: unknown, ...args: Parameters<F>) {\n    if (canceled) return;\n\n    const now = Date.now();\n    let executed = false;\n\n    // 第一次执行\n    if (options.leading && lastTime === 0) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 中间控频执行\n    else if (lastTime > 0 && now - lastTime >= waitFinal) {\n      lastTime = now;\n      fn.apply(this, args);\n      executed = true;\n    }\n\n    // 首次计时\n    else if (lastTime === 0) {\n      lastTime = now;\n    }\n\n    // 最后一次执行，仅在本次未执行时才设置 trailing\n    if (options.trailing && !executed) {\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        fn.apply(this, args);\n      }, waitFinal);\n    }\n  };\n\n  throttled.cancel = () => {\n    canceled = true;\n    clearTimeout(timer);\n  };\n\n  return throttled;\n}\n\n/**\n * 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。\n *\n * @param fn - 需要只执行一次的函数。\n * @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。\n *\n * @example\n * ```typescript\n * const onceFn = fnOnce(() => {\n *   console.log('This will be logged only once.');\n *   return 42;\n * });\n *\n * console.log(onceFn()); // 输出: This will be logged only once. 42\n * console.log(onceFn()); // 输出: 42\n * ```\n */\nexport function fnOnce<F extends AnyFunction>(fn: F) {\n  let called = false;\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\n  let result: any;\n\n  return function (this: unknown, ...args: Parameters<F>) {\n    if (!called) {\n      called = true;\n      result = fn.apply(this, args);\n    }\n\n    return result;\n  };\n}\n\nexport type FnRetryOptions = {\n  /**\n   * 最大尝试次数\n   */\n  maxAttempts?: number;\n  /**\n   * 每次重试之间的延迟时间（毫秒）\n   * @default 0\n   */\n  delay?: number;\n  /**\n   * 自定义重试条件，返回 true 时触发重试\n   * @default 仅在抛出错误时重试\n   */\n  retryWhen?: (error: unknown) => boolean;\n};\n\n/**\n * 创建一个带重试能力的函数，失败时自动重试直到成功或耗尽次数。\n *\n * @param fn - 需要重试的函数。\n * @param options - 重试配置选项。\n * @returns 返回一个带重试能力的函数。\n *\n * @example\n * ```typescript\n * const fetchData = fnRetry(async () => {\n *   return await api.request('/data');\n * }, { maxAttempts: 3, delay: 1000 });\n *\n * // 第1次失败 → 等待1s → 第2次失败 → 等待1s → 第3次成功 → 返回结果\n * const result = await fetchData();\n * ```\n */\nexport function fnRetry<F extends AnyFunction>(fn: F, options: FnRetryOptions = {}) {\n  const { maxAttempts = 3, delay = 0, retryWhen } = options;\n\n  return async function (this: unknown, ...args: Parameters<F>): Promise<Awaited<ReturnType<F>>> {\n    let lastError: unknown;\n\n    for (let attempt = 1; attempt <= maxAttempts; attempt++) {\n      try {\n        return (await fn.apply(this, args)) as Awaited<ReturnType<F>>;\n      } catch (error) {\n        lastError = error;\n\n        if (retryWhen && !retryWhen(error)) break;\n\n        if (attempt < maxAttempts && delay > 0) {\n          await promiseDelay(delay);\n        }\n      }\n    }\n\n    throw lastError;\n  };\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,SAAS;;;;;;;;;;;;;;;;;;;AAqCzB,SAAgB,WAAkC,IAAO,MAAgC;CACvF,MAAM,UAA2B,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC7D,IAAI,WAAW;CAEf,IAAI;CACJ,IAAI,UAAU;CAEd,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAGd,IAAI,QAAQ,WAAW,CAAC,SAAS;GAC/B,UAAU;GACV,GAAG,MAAM,MAAM,KAAK;GACpB;;EAIF,aAAa,MAAM;EACnB,QAAQ,iBAAiB;GACvB,IAAI,UAAU;GAEd,GAAG,MAAM,MAAM,KAAK;KACnB,QAAQ,KAAK;;CAGlB,UAAU,eAAe;EACvB,aAAa,MAAM;EACnB,WAAW;;CAGb,OAAO;;;;;;;;;;;;;;;;;;;;AAwCT,SAAgB,WAAkC,IAAO,MAAgC;CACvF,MAAM,UAAU,SAAS,KAAK,GAAG,EAAE,MAAM,GAAG;CAC5C,MAAM,YAAY,QAAQ;CAC1B,IAAI,WAAW;CACf,IAAI,WAAW;CAEf,IAAI;CAEJ,MAAM,YAAY,SAAyB,GAAG,MAAqB;EACjE,IAAI,UAAU;EAEd,MAAM,MAAM,KAAK,KAAK;EACtB,IAAI,WAAW;EAGf,IAAI,QAAQ,WAAW,aAAa,GAAG;GACrC,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,WAAW,KAAK,MAAM,YAAY,WAAW;GACpD,WAAW;GACX,GAAG,MAAM,MAAM,KAAK;GACpB,WAAW;SAIR,IAAI,aAAa,GACpB,WAAW;EAIb,IAAI,QAAQ,YAAY,CAAC,UAAU;GACjC,aAAa,MAAM;GACnB,QAAQ,iBAAiB;IACvB,GAAG,MAAM,MAAM,KAAK;MACnB,UAAU;;;CAIjB,UAAU,eAAe;EACvB,WAAW;EACX,aAAa,MAAM;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;AAoBT,SAAgB,OAA8B,IAAO;CACnD,IAAI,SAAS;CAEb,IAAI;CAEJ,OAAO,SAAyB,GAAG,MAAqB;EACtD,IAAI,CAAC,QAAQ;GACX,SAAS;GACT,SAAS,GAAG,MAAM,MAAM,KAAK;;EAG/B,OAAO;;;;;;;;;;;;;;;;;;;;AAsCX,SAAgB,QAA+B,IAAO,UAA0B,EAAE,EAAE;CAClF,MAAM,EAAE,cAAc,GAAG,QAAQ,GAAG,cAAc;CAElD,OAAO,eAA+B,GAAG,MAAsD;EAC7F,IAAI;EAEJ,KAAK,IAAI,UAAU,GAAG,WAAW,aAAa,WAC5C,IAAI;GACF,OAAQ,MAAM,GAAG,MAAM,MAAM,KAAK;WAC3B,OAAO;GACd,YAAY;GAEZ,IAAI,aAAa,CAAC,UAAU,MAAM,EAAE;GAEpC,IAAI,UAAU,eAAe,QAAQ,GACnC,MAAM,aAAa,MAAM;;EAK/B,MAAM"}

package/dist/index.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 /**
 * `@cloudcome/utils-core` 版本号
 */
-var VERSION = "1.20.0";
+var VERSION = "1.21.0";
 //#endregion
 exports.VERSION = VERSION;
 

package/dist/index.mjs

@@ -2,7 +2,7 @@
 /**
 * `@cloudcome/utils-core` 版本号
 */
-var VERSION = "1.20.0";
+var VERSION = "1.21.0";
 //#endregion
 export { VERSION };
 

package/dist/object/get-set.d.ts

@@ -1,31 +1,7 @@
 import { AnyArray, AnyObject } from '../types';
 type Idx<T, K> = K extends keyof T ? T[K] : number extends keyof T ? K extends `${number}` ? T[number] : never : never;
 type Join<K, P> = K extends string | number ? P extends string | number ? `${K}${'' extends P ? '' : '.'}${P}` : never : never;
-type Prev = [
-    never,
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6,
-    7,
-    8,
-    9,
-    10,
-    11,
-    12,
-    13,
-    14,
-    15,
-    16,
-    17,
-    18,
-    19,
-    20,
-    ...0[]
-];
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...0[]];
 export type ObjectPath<O, D extends number = 4> = [D] extends [never] ? never : O extends object ? {
     [K in keyof O]-?: K extends string | number ? `${K}` | Join<K, ObjectPath<O[K], Prev[D]>> : never;
 }[keyof O] : '';

package/dist/object.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"object.cjs","names":[],"sources":["../src/object/each.ts","../src/object/get-set.ts","../src/object/is.ts","../src/object/merge.ts","../src/object/process.ts"],"sourcesContent":["import type { AnyObject, MaybePromise } from '@/types';\n\n/**\n * 遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的回调函数。如果回调函数返回 false，则提前终止遍历。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * objectEach(obj, (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport function objectEach<\n  O extends AnyObject,\n  K extends keyof O & (string | number),\n>(obj: O, iterator: (this: O, val: O[K], key: K) => false | unknown): void {\n  for (const [key, val] of Object.entries(obj)) {\n    if (iterator.call(obj, val as O[K], key as K) === false) {\n      break;\n    }\n  }\n}\n\n/**\n * 异步遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的异步回调函数。如果回调函数返回 false，则提前终止遍历。\n * @returns 返回一个 Promise，当所有异步操作完成后，Promise 会被 resolve。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * await objectEachAsync(obj, async (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport async function objectEachAsync<\n  O extends AnyObject,\n  K extends keyof O & (string | number),\n>(\n  obj: O,\n  iterator: (this: O, val: O[K], key: K) => MaybePromise<false | unknown>,\n): Promise<void> {\n  for (const [key, val] of Object.entries(obj)) {\n    if ((await iterator.call(obj, val as O[K], key as K)) === false) {\n      break;\n    }\n  }\n}\n","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 = [\n  never,\n  0,\n  1,\n  2,\n  3,\n  4,\n  5,\n  6,\n  7,\n  8,\n  9,\n  10,\n  11,\n  12,\n  13,\n  14,\n  15,\n  16,\n  17,\n  18,\n  19,\n  20,\n  ...0[],\n];\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\n          ? `${K}` | Join<K, ObjectPath<O[K], Prev[D]>>\n          : 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<\n  O,\n  P extends ObjectPath<O, 4>,\n> = 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 ObjectNode<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 {ObjectNode<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 {ObjectNode<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): ObjectNode<O> {\n  const keys = pathToKeys(path);\n  const lastKey = keys.pop();\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\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-expect-error\n    parent = parent[key];\n  }\n\n  return {\n    parent: parent,\n    keys: keysFinal,\n    key: lastKey,\n    // @ts-expect-error\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 ObjectSetOptions<O extends AnyObject> = {\n  /**\n   * 在设置值之前调用的钩子函数。\n   * 如果返回 `false`，则阻止设置值。\n   *\n   * @param {ObjectNode<O> & { key: string }} node - 当前节点信息。\n   * @returns {boolean | undefined | void} 返回 `false` 时阻止设置值。\n   */\n  beforeSet(node: ObjectNode<O> & { key: string }): boolean | undefined;\n\n  /**\n   * 当遇到未定义的中间节点时调用的钩子函数。\n   * 返回值将用于创建中间节点。\n   *\n   * @param {ObjectNode<O>} node - 当前节点信息。\n   * @returns {AnyObject | AnyArray | undefined | void} 返回值将用于创建中间节点。\n   */\n  undefinedSet(node: ObjectNode<O>): AnyObject | AnyArray | undefined;\n};\n\n// biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\nconst defaultObjectSetOptions: ObjectSetOptions<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<ObjectSetOptions<O>>} options\n * @returns {ObjectNode<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<ObjectSetOptions<O>>} [options] - 可选配置项，用于控制设置行为。\n * @returns {ObjectNode<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<ObjectSetOptions<O>>,\n): ObjectNode<V> {\n  const { beforeSet, undefinedSet } = Object.assign(\n    {},\n    defaultObjectSetOptions,\n    options,\n  );\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-expect-error\n      val = parent[key] = seted;\n    }\n\n    // @ts-expect-error\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-expect-error\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 type { 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 (\n    Object.getOwnPropertyNames(obj).length === 0 &&\n    Object.getOwnPropertySymbols(obj).length === 0\n  );\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 { isArray, isObject, typeIs } from '@/type';\nimport type { AnyArray, AnyObject } from '@/types';\nimport { objectEach } from './each';\n\nexport type ObjectMergeRule = {\n  /**\n   * 处理冲突\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回 true 表示继续处理，否则返回 false\n   */\n  next: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n  }) => boolean;\n\n  /**\n   * 处理赋值\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回处理后的值\n   */\n  assign: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n    merge: () => unknown;\n  }) => unknown;\n};\n\nfunction _objectMerge(\n  mergeRule: ObjectMergeRule,\n  target: AnyObject | AnyArray,\n  ...sources: (AnyObject | AnyArray)[]\n) {\n  const seen = new WeakMap<AnyObject | AnyArray, AnyObject | AnyArray>();\n  const { assign, next } = mergeRule;\n  const align = (\n    target: AnyObject | AnyArray,\n    source: AnyObject | AnyArray,\n  ) => {\n    const targetType = typeIs(target);\n    const sourceType = typeIs(source);\n\n    if (targetType === sourceType) {\n      return target;\n    }\n\n    return sourceType === 'array' ? [] : {};\n  };\n  const each = (\n    source: AnyObject | AnyArray,\n    // biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\n    iterator: (val: any, key: string | number) => void,\n  ) => {\n    if (isObject(source)) {\n      objectEach(source, iterator);\n    } else {\n      source.forEach(iterator);\n    }\n  };\n\n  const merge = (\n    target: AnyObject | AnyArray,\n    source: AnyObject | AnyArray,\n  ): AnyObject | AnyArray => {\n    // 如果循环引用了，则直接返回目标对象\n    if (seen.has(source)) {\n      // biome-ignore lint/style/noNonNullAssertion: 必须存在\n      return seen.get(source)!;\n    }\n\n    // 对齐目标对象和源对象\n    const merged = align(target, source);\n\n    // 存储循环引用\n    seen.set(source, merged);\n\n    // 遍历源对象\n    each(source, (value, key) => {\n      if (!next({ target: merged, source, key })) {\n        return;\n      }\n\n      if (isObject(value) || isArray(value)) {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          // @ts-expect-error\n          merge: () => merge(merged[key], value),\n        });\n      } else {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          merge: () => value,\n        });\n      }\n    });\n\n    return merged;\n  };\n\n  let returnTarget = target;\n\n  for (const source of sources) {\n    returnTarget = merge(target, source);\n  }\n\n  return returnTarget;\n}\n\n/**\n * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。\n *\n * @param target - 目标对象或数组。\n * @param sources - 要合并的源对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj1 = { a: 1, b: { x: 10 } };\n * const obj2 = { b: { y: 20 }, c: 3 };\n * const merged = objectMerge(obj1, obj2);\n * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }\n * ```\n */\nexport function objectMerge(\n  target: AnyObject | AnyArray,\n  ...sources: (AnyObject | AnyArray)[]\n) {\n  return _objectMerge(\n    {\n      next() {\n        return true;\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    ...sources,\n  );\n}\n\n/**\n * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。\n * 支持多个默认对象，优先级从左到右依次降低。\n * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。\n *\n * @param target - 目标对象或数组。\n * @param defaults - 默认对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: undefined };\n * const defaults = { a: 4, b: 2, c: 3 };\n * const result = objectDefaults(obj, defaults);\n * console.log(result); // { a: 1, b: 2, c: 3 }\n *\n * const obj2 = { a: 1, b: 2 };\n * const defaults2 = { a: 5, b: 3, c: 4 };\n * const result2 = objectDefaults(obj2, defaults2);\n * console.log(result2); // { a: 1, b: 2, c: 4 }\n *\n * const obj3 = { a: { x: 1 }, b: undefined };\n * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };\n * const result3 = objectDefaults(obj3, defaults3);\n * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }\n * ```\n */\nexport function objectDefaults<T extends AnyObject | AnyArray>(\n  target: T,\n  defaults: T,\n): T {\n  return _objectMerge(\n    {\n      next({ target, key }) {\n        return (\n          // @ts-expect-error\n          target[key] === undefined ||\n          // @ts-expect-error\n          isObject(target[key]) ||\n          // @ts-expect-error\n          isArray(target[key])\n        );\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    defaults,\n  ) as T;\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>(\n  object: T,\n  keys: K[],\n): 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>(\n  object: T,\n  keys: K[],\n): 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\n/**\n * 根据提供的过滤函数过滤对象的属性，返回一个新对象，只包含满足条件的属性。\n *\n * @param object - 要过滤的对象。\n * @param predicate - 过滤函数，接收值和键作为参数，返回布尔值。\n * @returns 包含满足过滤条件的属性的新对象。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3, d: 4 };\n * const result = objectFilter(obj, (value, key) => value > 2);\n * console.log(result); // { c: 3, d: 4 }\n * ```\n */\nexport function objectFilter<T extends AnyObject>(\n  object: T,\n  predicate: (value: T[keyof T], key: keyof T) => boolean,\n): Partial<T> {\n  return Object.fromEntries(\n    Object.entries(object).filter(([key, value]) =>\n      predicate(value as T[keyof T], key as keyof T),\n    ),\n  ) as Partial<T>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,SAAgB,WAGd,KAAQ,UAAiE;CACzE,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,IAAI,EAC1C,IAAI,SAAS,KAAK,KAAK,KAAa,IAAS,KAAK,OAChD;;;;;;;;;;;;;;;;;;;AAsBN,eAAsB,gBAIpB,KACA,UACe;CACf,KAAK,MAAM,CAAC,KAAK,QAAQ,OAAO,QAAQ,IAAI,EAC1C,IAAK,MAAM,SAAS,KAAK,KAAK,KAAa,IAAS,KAAM,OACxD;;;;ACqBN,SAAS,WAAW,MAAyB;CAE3C,IAAI,aAAA,QAAQ,KAAK,EAAE,OAAO,CAAC,GAAG,KAAK;CAEnC,IAAI,YAAY,KAAK,QAAQ,cAAc,MAAM;CACjD,YAAY,UAAU,QAAQ,OAAO,GAAG;CACxC,OAAO,UAAU,MAAM,IAAI;;AAG7B,SAAS,gBAAgB,GAAY;CACnC,OAAO,aAAA,SAAS,EAAE,IAAI,aAAA,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;AAkDlC,SAAgB,UACd,KACA,MACe;CACf,MAAM,OAAO,WAAW,KAAK;CAC7B,MAAM,UAAU,KAAK,KAAK;CAE1B,IAAI,SAAc;CAClB,MAAM,YAAsB,EAAE;CAE9B,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,MAAM,KAAK;EAEjB,UAAU,KAAK,IAAI;EACnB,IAAI,CAAC,gBAAgB,OAAO,EAAE;EAG9B,SAAS,OAAO;;CAGlB,OAAO;EACG;EACR,MAAM;EACN,KAAK;EAEL,OAAO,gBAAgB,OAAO,IAAI,UAAU,OAAO,WAAW,KAAA;EAC/D;;AAuCH,IAAM,0BAAiD;CACrD,iBAAiB;CACjB,qBAAqB,EAAE;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BD,SAAgB,UACd,KACA,MACA,KACA,SACe;CACf,MAAM,EAAE,WAAW,iBAAiB,OAAO,OACzC,EAAE,EACF,yBACA,QACD;CACD,MAAM,OAAO,WAAW,KAAK;CAC7B,MAAM,UAAU,KAAK,KAAK;CAC1B,IAAI,SAAS;CACb,IAAI,UAAU;CACd,MAAM,YAAsB,EAAE;CAE9B,KAAK,MAAM,OAAO,MAAM;EACtB,IAAI,MAAM,OAAO;EACjB,UAAU,KAAK,IAAI;EAEnB,IAAI,aAAA,YAAY,IAAI,EAAE;GACpB,MAAM,QAAQ,aAAa;IACjB;IACR,MAAM;IACD;IACL,OAAO;IACR,CAAC;GAEF,IAAI,CAAC,OAAO;IACV,UAAU;IACV;;GAKF,MAAM,OAAO,OAAO;;EAItB,SAAS;;CAGX,IAAI,CAAC,WAAW,CAAC,aAAA,YAAY,QAAQ,EAAE;EACrC,UAAU,KAAK,QAAQ;EAEvB,IACE,UAAU;GACA;GACR,MAAM;GACN,KAAK;GACL,OAAO,OAAO;GACf,CAAC,EAIF,OAAO,WAAW;;CAItB,OAAO;EACL,MAAM;EACE;EACR,KAAK;EACL,OAAO;EACR;;;;;;;;;;;;;;;;;;AC5RH,SAAgB,cAAc,KAAyB;CACrD,OACE,OAAO,oBAAoB,IAAI,CAAC,WAAW,KAC3C,OAAO,sBAAsB,IAAI,CAAC,WAAW;;;;;;;;;;;;;;;;;AAmBjD,SAAgB,cAAc,KAAyB;CACrD,MAAM,QAAiB,OAAO,eAAe,IAAI;CAGjD,IAAI,CAAC,OAAO,OAAO;CAGnB,OAAO,UAAU,OAAO;;;;ACZ1B,SAAS,aACP,WACA,QACA,GAAG,SACH;CACA,MAAM,uBAAO,IAAI,SAAqD;CACtE,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,SACJ,QACA,WACG;EACH,MAAM,aAAa,aAAA,OAAO,OAAO;EACjC,MAAM,aAAa,aAAA,OAAO,OAAO;EAEjC,IAAI,eAAe,YACjB,OAAO;EAGT,OAAO,eAAe,UAAU,EAAE,GAAG,EAAE;;CAEzC,MAAM,QACJ,QAEA,aACG;EACH,IAAI,aAAA,SAAS,OAAO,EAClB,WAAW,QAAQ,SAAS;OAE5B,OAAO,QAAQ,SAAS;;CAI5B,MAAM,SACJ,QACA,WACyB;EAEzB,IAAI,KAAK,IAAI,OAAO,EAElB,OAAO,KAAK,IAAI,OAAO;EAIzB,MAAM,SAAS,MAAM,QAAQ,OAAO;EAGpC,KAAK,IAAI,QAAQ,OAAO;EAGxB,KAAK,SAAS,OAAO,QAAQ;GAC3B,IAAI,CAAC,KAAK;IAAE,QAAQ;IAAQ;IAAQ;IAAK,CAAC,EACxC;GAGF,IAAI,aAAA,SAAS,MAAM,IAAI,aAAA,QAAQ,MAAM,EAEnC,OAAO,OAAO,OAAO;IACnB,QAAQ;IACR;IACA;IAEA,aAAa,MAAM,OAAO,MAAM,MAAM;IACvC,CAAC;QAGF,OAAO,OAAO,OAAO;IACnB,QAAQ;IACR;IACA;IACA,aAAa;IACd,CAAC;IAEJ;EAEF,OAAO;;CAGT,IAAI,eAAe;CAEnB,KAAK,MAAM,UAAU,SACnB,eAAe,MAAM,QAAQ,OAAO;CAGtC,OAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,YACd,QACA,GAAG,SACH;CACA,OAAO,aACL;EACE,OAAO;GACL,OAAO;;EAET,OAAO,EAAE,SAAS;GAChB,OAAO,OAAO;;EAEjB,EACD,QACA,GAAG,QACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BH,SAAgB,eACd,QACA,UACG;CACH,OAAO,aACL;EACE,KAAK,EAAE,QAAQ,OAAO;GACpB,OAEE,OAAO,SAAS,KAAA,KAEhB,aAAA,SAAS,OAAO,KAAK,IAErB,aAAA,QAAQ,OAAO,KAAK;;EAGxB,OAAO,EAAE,SAAS;GAChB,OAAO,OAAO;;EAEjB,EACD,QACA,SACD;;;;;;;;;;;;;;;;;;ACzLH,SAAgB,WACd,QACA,MACY;CACZ,MAAM,SAAS,EAAE;CACjB,KAAK,MAAM,OAAO,MAChB,IAAI,OAAO,QACT,OAAO,OAAO,OAAO;CAGzB,OAAO;;;;;;;;;;;;;;;;AAiBT,SAAgB,WACd,QACA,MACY;CACZ,MAAM,SAAS,EAAE;CACjB,KAAK,MAAM,OAAO,QAChB,IAAI,CAAC,KAAK,SAAS,IAAoB,EAErC,OAAO,OAAO,OAAO;CAGzB,OAAO;;;;;;;;;;;;;;;;AAiBT,SAAgB,UACd,QACA,QACoB;CACpB,OAAO,OAAO,YACZ,OAAO,QAAQ,OAAO,CAAC,KAAK,CAAC,KAAK,WAAW,CAC3C,KACA,OAEE,OACA,IACD,CACF,CAAC,CACH;;;;;;;;;;;;;;;;AAiBH,SAAgB,aACd,QACA,WACY;CACZ,OAAO,OAAO,YACZ,OAAO,QAAQ,OAAO,CAAC,QAAQ,CAAC,KAAK,WACnC,UAAU,OAAqB,IAAe,CAC/C,CACF"}
+{"version":3,"file":"object.cjs","names":[],"sources":["../src/object/each.ts","../src/object/get-set.ts","../src/object/is.ts","../src/object/merge.ts","../src/object/process.ts"],"sourcesContent":["import type { AnyObject, MaybePromise } from '@/types';\n\n/**\n * 遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的回调函数。如果回调函数返回 false，则提前终止遍历。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * objectEach(obj, (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport function objectEach<O extends AnyObject, K extends keyof O & (string | number)>(\n  obj: O,\n  iterator: (this: O, val: O[K], key: K) => false | unknown,\n): void {\n  for (const [key, val] of Object.entries(obj)) {\n    if (iterator.call(obj, val as O[K], key as K) === false) {\n      break;\n    }\n  }\n}\n\n/**\n * 异步遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的异步回调函数。如果回调函数返回 false，则提前终止遍历。\n * @returns 返回一个 Promise，当所有异步操作完成后，Promise 会被 resolve。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * await objectEachAsync(obj, async (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport async function objectEachAsync<O extends AnyObject, K extends keyof O & (string | number)>(\n  obj: O,\n  iterator: (this: O, val: O[K], key: K) => MaybePromise<false | unknown>,\n): Promise<void> {\n  for (const [key, val] of Object.entries(obj)) {\n    if ((await iterator.call(obj, val as O[K], key as K)) === false) {\n      break;\n    }\n  }\n}\n","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 ObjectNode<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 {ObjectNode<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 {ObjectNode<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): ObjectNode<O> {\n  const keys = pathToKeys(path);\n  const lastKey = keys.pop();\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\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-expect-error\n    parent = parent[key];\n  }\n\n  return {\n    parent: parent,\n    keys: keysFinal,\n    key: lastKey,\n    // @ts-expect-error\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 ObjectSetOptions<O extends AnyObject> = {\n  /**\n   * 在设置值之前调用的钩子函数。\n   * 如果返回 `false`，则阻止设置值。\n   *\n   * @param {ObjectNode<O> & { key: string }} node - 当前节点信息。\n   * @returns {boolean | undefined | void} 返回 `false` 时阻止设置值。\n   */\n  beforeSet(node: ObjectNode<O> & { key: string }): boolean | undefined;\n\n  /**\n   * 当遇到未定义的中间节点时调用的钩子函数。\n   * 返回值将用于创建中间节点。\n   *\n   * @param {ObjectNode<O>} node - 当前节点信息。\n   * @returns {AnyObject | AnyArray | undefined | void} 返回值将用于创建中间节点。\n   */\n  undefinedSet(node: ObjectNode<O>): AnyObject | AnyArray | undefined;\n};\n\n// biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\nconst defaultObjectSetOptions: ObjectSetOptions<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<ObjectSetOptions<O>>} options\n * @returns {ObjectNode<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<ObjectSetOptions<O>>} [options] - 可选配置项，用于控制设置行为。\n * @returns {ObjectNode<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<ObjectSetOptions<O>>,\n): ObjectNode<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-expect-error\n      val = parent[key] = seted;\n    }\n\n    // @ts-expect-error\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-expect-error\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 type { 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 { isArray, isObject, typeIs } from '@/type';\nimport type { AnyArray, AnyObject } from '@/types';\nimport { objectEach } from './each';\n\nexport type ObjectMergeRule = {\n  /**\n   * 处理冲突\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回 true 表示继续处理，否则返回 false\n   */\n  next: (info: { target: AnyObject | AnyArray; source: AnyObject | AnyArray; key: string | number }) => boolean;\n\n  /**\n   * 处理赋值\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回处理后的值\n   */\n  assign: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n    merge: () => unknown;\n  }) => unknown;\n};\n\nfunction _objectMerge(mergeRule: ObjectMergeRule, target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  const seen = new WeakMap<AnyObject | AnyArray, AnyObject | AnyArray>();\n  const { assign, next } = mergeRule;\n  const align = (target: AnyObject | AnyArray, source: AnyObject | AnyArray) => {\n    const targetType = typeIs(target);\n    const sourceType = typeIs(source);\n\n    if (targetType === sourceType) {\n      return target;\n    }\n\n    return sourceType === 'array' ? [] : {};\n  };\n  const each = (\n    source: AnyObject | AnyArray,\n    // biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\n    iterator: (val: any, key: string | number) => void,\n  ) => {\n    if (isObject(source)) {\n      objectEach(source, iterator);\n    } else {\n      source.forEach(iterator);\n    }\n  };\n\n  const merge = (target: AnyObject | AnyArray, source: AnyObject | AnyArray): AnyObject | AnyArray => {\n    // 如果循环引用了，则直接返回目标对象\n    if (seen.has(source)) {\n      // biome-ignore lint/style/noNonNullAssertion: 必须存在\n      return seen.get(source)!;\n    }\n\n    // 对齐目标对象和源对象\n    const merged = align(target, source);\n\n    // 存储循环引用\n    seen.set(source, merged);\n\n    // 遍历源对象\n    each(source, (value, key) => {\n      if (!next({ target: merged, source, key })) {\n        return;\n      }\n\n      if (isObject(value) || isArray(value)) {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          // @ts-expect-error\n          merge: () => merge(merged[key], value),\n        });\n      } else {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          merge: () => value,\n        });\n      }\n    });\n\n    return merged;\n  };\n\n  let returnTarget = target;\n\n  for (const source of sources) {\n    returnTarget = merge(target, source);\n  }\n\n  return returnTarget;\n}\n\n/**\n * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。\n *\n * @param target - 目标对象或数组。\n * @param sources - 要合并的源对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj1 = { a: 1, b: { x: 10 } };\n * const obj2 = { b: { y: 20 }, c: 3 };\n * const merged = objectMerge(obj1, obj2);\n * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }\n * ```\n */\nexport function objectMerge(target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  return _objectMerge(\n    {\n      next() {\n        return true;\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    ...sources,\n  );\n}\n\n/**\n * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。\n * 支持多个默认对象，优先级从左到右依次降低。\n * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。\n *\n * @param target - 目标对象或数组。\n * @param defaults - 默认对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: undefined };\n * const defaults = { a: 4, b: 2, c: 3 };\n * const result = objectDefaults(obj, defaults);\n * console.log(result); // { a: 1, b: 2, c: 3 }\n *\n * const obj2 = { a: 1, b: 2 };\n * const defaults2 = { a: 5, b: 3, c: 4 };\n * const result2 = objectDefaults(obj2, defaults2);\n * console.log(result2); // { a: 1, b: 2, c: 4 }\n *\n * const obj3 = { a: { x: 1 }, b: undefined };\n * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };\n * const result3 = objectDefaults(obj3, defaults3);\n * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }\n * ```\n */\nexport function objectDefaults<T extends AnyObject | AnyArray>(target: T, defaults: T): T {\n  return _objectMerge(\n    {\n      next({ target, key }) {\n        return (\n          // @ts-expect-error\n          target[key] === undefined ||\n          // @ts-expect-error\n          isObject(target[key]) ||\n          // @ts-expect-error\n          isArray(target[key])\n        );\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    defaults,\n  ) as T;\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\n/**\n * 根据提供的过滤函数过滤对象的属性，返回一个新对象，只包含满足条件的属性。\n *\n * @param object - 要过滤的对象。\n * @param predicate - 过滤函数，接收值和键作为参数，返回布尔值。\n * @returns 包含满足过滤条件的属性的新对象。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3, d: 4 };\n * const result = objectFilter(obj, (value, key) => value > 2);\n * console.log(result); // { c: 3, d: 4 }\n * ```\n */\nexport function objectFilter<T extends AnyObject>(\n  object: T,\n  predicate: (value: T[keyof T], key: keyof T) => boolean,\n): Partial<T> {\n  return Object.fromEntries(\n    Object.entries(object).filter(([key, value]) => predicate(value as T[keyof T], key as keyof T)),\n  ) as Partial<T>;\n}\n"],"mappings":"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"}

package/dist/object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"object.mjs","names":[],"sources":["../src/object/each.ts","../src/object/get-set.ts","../src/object/is.ts","../src/object/merge.ts","../src/object/process.ts"],"sourcesContent":["import type { AnyObject, MaybePromise } from '@/types';\n\n/**\n * 遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的回调函数。如果回调函数返回 false，则提前终止遍历。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * objectEach(obj, (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport function objectEach<\n  O extends AnyObject,\n  K extends keyof O & (string | number),\n>(obj: O, iterator: (this: O, val: O[K], key: K) => false | unknown): void {\n  for (const [key, val] of Object.entries(obj)) {\n    if (iterator.call(obj, val as O[K], key as K) === false) {\n      break;\n    }\n  }\n}\n\n/**\n * 异步遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的异步回调函数。如果回调函数返回 false，则提前终止遍历。\n * @returns 返回一个 Promise，当所有异步操作完成后，Promise 会被 resolve。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * await objectEachAsync(obj, async (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport async function objectEachAsync<\n  O extends AnyObject,\n  K extends keyof O & (string | number),\n>(\n  obj: O,\n  iterator: (this: O, val: O[K], key: K) => MaybePromise<false | unknown>,\n): Promise<void> {\n  for (const [key, val] of Object.entries(obj)) {\n    if ((await iterator.call(obj, val as O[K], key as K)) === false) {\n      break;\n    }\n  }\n}\n","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 = [\n  never,\n  0,\n  1,\n  2,\n  3,\n  4,\n  5,\n  6,\n  7,\n  8,\n  9,\n  10,\n  11,\n  12,\n  13,\n  14,\n  15,\n  16,\n  17,\n  18,\n  19,\n  20,\n  ...0[],\n];\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\n          ? `${K}` | Join<K, ObjectPath<O[K], Prev[D]>>\n          : 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<\n  O,\n  P extends ObjectPath<O, 4>,\n> = 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 ObjectNode<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 {ObjectNode<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 {ObjectNode<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): ObjectNode<O> {\n  const keys = pathToKeys(path);\n  const lastKey = keys.pop();\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\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-expect-error\n    parent = parent[key];\n  }\n\n  return {\n    parent: parent,\n    keys: keysFinal,\n    key: lastKey,\n    // @ts-expect-error\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 ObjectSetOptions<O extends AnyObject> = {\n  /**\n   * 在设置值之前调用的钩子函数。\n   * 如果返回 `false`，则阻止设置值。\n   *\n   * @param {ObjectNode<O> & { key: string }} node - 当前节点信息。\n   * @returns {boolean | undefined | void} 返回 `false` 时阻止设置值。\n   */\n  beforeSet(node: ObjectNode<O> & { key: string }): boolean | undefined;\n\n  /**\n   * 当遇到未定义的中间节点时调用的钩子函数。\n   * 返回值将用于创建中间节点。\n   *\n   * @param {ObjectNode<O>} node - 当前节点信息。\n   * @returns {AnyObject | AnyArray | undefined | void} 返回值将用于创建中间节点。\n   */\n  undefinedSet(node: ObjectNode<O>): AnyObject | AnyArray | undefined;\n};\n\n// biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\nconst defaultObjectSetOptions: ObjectSetOptions<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<ObjectSetOptions<O>>} options\n * @returns {ObjectNode<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<ObjectSetOptions<O>>} [options] - 可选配置项，用于控制设置行为。\n * @returns {ObjectNode<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<ObjectSetOptions<O>>,\n): ObjectNode<V> {\n  const { beforeSet, undefinedSet } = Object.assign(\n    {},\n    defaultObjectSetOptions,\n    options,\n  );\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-expect-error\n      val = parent[key] = seted;\n    }\n\n    // @ts-expect-error\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-expect-error\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 type { 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 (\n    Object.getOwnPropertyNames(obj).length === 0 &&\n    Object.getOwnPropertySymbols(obj).length === 0\n  );\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 { isArray, isObject, typeIs } from '@/type';\nimport type { AnyArray, AnyObject } from '@/types';\nimport { objectEach } from './each';\n\nexport type ObjectMergeRule = {\n  /**\n   * 处理冲突\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回 true 表示继续处理，否则返回 false\n   */\n  next: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n  }) => boolean;\n\n  /**\n   * 处理赋值\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回处理后的值\n   */\n  assign: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n    merge: () => unknown;\n  }) => unknown;\n};\n\nfunction _objectMerge(\n  mergeRule: ObjectMergeRule,\n  target: AnyObject | AnyArray,\n  ...sources: (AnyObject | AnyArray)[]\n) {\n  const seen = new WeakMap<AnyObject | AnyArray, AnyObject | AnyArray>();\n  const { assign, next } = mergeRule;\n  const align = (\n    target: AnyObject | AnyArray,\n    source: AnyObject | AnyArray,\n  ) => {\n    const targetType = typeIs(target);\n    const sourceType = typeIs(source);\n\n    if (targetType === sourceType) {\n      return target;\n    }\n\n    return sourceType === 'array' ? [] : {};\n  };\n  const each = (\n    source: AnyObject | AnyArray,\n    // biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\n    iterator: (val: any, key: string | number) => void,\n  ) => {\n    if (isObject(source)) {\n      objectEach(source, iterator);\n    } else {\n      source.forEach(iterator);\n    }\n  };\n\n  const merge = (\n    target: AnyObject | AnyArray,\n    source: AnyObject | AnyArray,\n  ): AnyObject | AnyArray => {\n    // 如果循环引用了，则直接返回目标对象\n    if (seen.has(source)) {\n      // biome-ignore lint/style/noNonNullAssertion: 必须存在\n      return seen.get(source)!;\n    }\n\n    // 对齐目标对象和源对象\n    const merged = align(target, source);\n\n    // 存储循环引用\n    seen.set(source, merged);\n\n    // 遍历源对象\n    each(source, (value, key) => {\n      if (!next({ target: merged, source, key })) {\n        return;\n      }\n\n      if (isObject(value) || isArray(value)) {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          // @ts-expect-error\n          merge: () => merge(merged[key], value),\n        });\n      } else {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          merge: () => value,\n        });\n      }\n    });\n\n    return merged;\n  };\n\n  let returnTarget = target;\n\n  for (const source of sources) {\n    returnTarget = merge(target, source);\n  }\n\n  return returnTarget;\n}\n\n/**\n * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。\n *\n * @param target - 目标对象或数组。\n * @param sources - 要合并的源对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj1 = { a: 1, b: { x: 10 } };\n * const obj2 = { b: { y: 20 }, c: 3 };\n * const merged = objectMerge(obj1, obj2);\n * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }\n * ```\n */\nexport function objectMerge(\n  target: AnyObject | AnyArray,\n  ...sources: (AnyObject | AnyArray)[]\n) {\n  return _objectMerge(\n    {\n      next() {\n        return true;\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    ...sources,\n  );\n}\n\n/**\n * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。\n * 支持多个默认对象，优先级从左到右依次降低。\n * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。\n *\n * @param target - 目标对象或数组。\n * @param defaults - 默认对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: undefined };\n * const defaults = { a: 4, b: 2, c: 3 };\n * const result = objectDefaults(obj, defaults);\n * console.log(result); // { a: 1, b: 2, c: 3 }\n *\n * const obj2 = { a: 1, b: 2 };\n * const defaults2 = { a: 5, b: 3, c: 4 };\n * const result2 = objectDefaults(obj2, defaults2);\n * console.log(result2); // { a: 1, b: 2, c: 4 }\n *\n * const obj3 = { a: { x: 1 }, b: undefined };\n * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };\n * const result3 = objectDefaults(obj3, defaults3);\n * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }\n * ```\n */\nexport function objectDefaults<T extends AnyObject | AnyArray>(\n  target: T,\n  defaults: T,\n): T {\n  return _objectMerge(\n    {\n      next({ target, key }) {\n        return (\n          // @ts-expect-error\n          target[key] === undefined ||\n          // @ts-expect-error\n          isObject(target[key]) ||\n          // @ts-expect-error\n          isArray(target[key])\n        );\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    defaults,\n  ) as T;\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>(\n  object: T,\n  keys: K[],\n): 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>(\n  object: T,\n  keys: K[],\n): 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\n/**\n * 根据提供的过滤函数过滤对象的属性，返回一个新对象，只包含满足条件的属性。\n *\n * @param object - 要过滤的对象。\n * @param predicate - 过滤函数，接收值和键作为参数，返回布尔值。\n * @returns 包含满足过滤条件的属性的新对象。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3, d: 4 };\n * const result = objectFilter(obj, (value, key) => value > 2);\n * console.log(result); // { c: 3, d: 4 }\n * ```\n */\nexport function objectFilter<T extends AnyObject>(\n  object: T,\n  predicate: (value: T[keyof T], key: keyof T) => boolean,\n): Partial<T> {\n  return Object.fromEntries(\n    Object.entries(object).filter(([key, value]) =>\n      predicate(value as T[keyof T], key as keyof T),\n    ),\n  ) as Partial<T>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"object.mjs","names":[],"sources":["../src/object/each.ts","../src/object/get-set.ts","../src/object/is.ts","../src/object/merge.ts","../src/object/process.ts"],"sourcesContent":["import type { AnyObject, MaybePromise } from '@/types';\n\n/**\n * 遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的回调函数。如果回调函数返回 false，则提前终止遍历。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * objectEach(obj, (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport function objectEach<O extends AnyObject, K extends keyof O & (string | number)>(\n  obj: O,\n  iterator: (this: O, val: O[K], key: K) => false | unknown,\n): void {\n  for (const [key, val] of Object.entries(obj)) {\n    if (iterator.call(obj, val as O[K], key as K) === false) {\n      break;\n    }\n  }\n}\n\n/**\n * 异步遍历对象的每个键值对，并对每个键值对执行提供的回调函数。\n *\n * @param obj - 要遍历的对象。\n * @param iterator - 对每个键值对执行的异步回调函数。如果回调函数返回 false，则提前终止遍历。\n * @returns 返回一个 Promise，当所有异步操作完成后，Promise 会被 resolve。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3 };\n * const results: [string, number][] = [];\n * await objectEachAsync(obj, async (val, key) => {\n *   results.push([key, val]);\n * });\n * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]\n * ```\n */\nexport async function objectEachAsync<O extends AnyObject, K extends keyof O & (string | number)>(\n  obj: O,\n  iterator: (this: O, val: O[K], key: K) => MaybePromise<false | unknown>,\n): Promise<void> {\n  for (const [key, val] of Object.entries(obj)) {\n    if ((await iterator.call(obj, val as O[K], key as K)) === false) {\n      break;\n    }\n  }\n}\n","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 ObjectNode<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 {ObjectNode<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 {ObjectNode<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): ObjectNode<O> {\n  const keys = pathToKeys(path);\n  const lastKey = keys.pop();\n  // biome-ignore lint/suspicious/noExplicitAny: 内部使用\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-expect-error\n    parent = parent[key];\n  }\n\n  return {\n    parent: parent,\n    keys: keysFinal,\n    key: lastKey,\n    // @ts-expect-error\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 ObjectSetOptions<O extends AnyObject> = {\n  /**\n   * 在设置值之前调用的钩子函数。\n   * 如果返回 `false`，则阻止设置值。\n   *\n   * @param {ObjectNode<O> & { key: string }} node - 当前节点信息。\n   * @returns {boolean | undefined | void} 返回 `false` 时阻止设置值。\n   */\n  beforeSet(node: ObjectNode<O> & { key: string }): boolean | undefined;\n\n  /**\n   * 当遇到未定义的中间节点时调用的钩子函数。\n   * 返回值将用于创建中间节点。\n   *\n   * @param {ObjectNode<O>} node - 当前节点信息。\n   * @returns {AnyObject | AnyArray | undefined | void} 返回值将用于创建中间节点。\n   */\n  undefinedSet(node: ObjectNode<O>): AnyObject | AnyArray | undefined;\n};\n\n// biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\nconst defaultObjectSetOptions: ObjectSetOptions<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<ObjectSetOptions<O>>} options\n * @returns {ObjectNode<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<ObjectSetOptions<O>>} [options] - 可选配置项，用于控制设置行为。\n * @returns {ObjectNode<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<ObjectSetOptions<O>>,\n): ObjectNode<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-expect-error\n      val = parent[key] = seted;\n    }\n\n    // @ts-expect-error\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-expect-error\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 type { 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 { isArray, isObject, typeIs } from '@/type';\nimport type { AnyArray, AnyObject } from '@/types';\nimport { objectEach } from './each';\n\nexport type ObjectMergeRule = {\n  /**\n   * 处理冲突\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回 true 表示继续处理，否则返回 false\n   */\n  next: (info: { target: AnyObject | AnyArray; source: AnyObject | AnyArray; key: string | number }) => boolean;\n\n  /**\n   * 处理赋值\n   * @param target - 目标对象\n   * @param source - 源对象\n   * @param key - 键名\n   * @returns 返回处理后的值\n   */\n  assign: (info: {\n    target: AnyObject | AnyArray;\n    source: AnyObject | AnyArray;\n    key: string | number;\n    merge: () => unknown;\n  }) => unknown;\n};\n\nfunction _objectMerge(mergeRule: ObjectMergeRule, target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  const seen = new WeakMap<AnyObject | AnyArray, AnyObject | AnyArray>();\n  const { assign, next } = mergeRule;\n  const align = (target: AnyObject | AnyArray, source: AnyObject | AnyArray) => {\n    const targetType = typeIs(target);\n    const sourceType = typeIs(source);\n\n    if (targetType === sourceType) {\n      return target;\n    }\n\n    return sourceType === 'array' ? [] : {};\n  };\n  const each = (\n    source: AnyObject | AnyArray,\n    // biome-ignore lint/suspicious/noExplicitAny: 内部使用 any\n    iterator: (val: any, key: string | number) => void,\n  ) => {\n    if (isObject(source)) {\n      objectEach(source, iterator);\n    } else {\n      source.forEach(iterator);\n    }\n  };\n\n  const merge = (target: AnyObject | AnyArray, source: AnyObject | AnyArray): AnyObject | AnyArray => {\n    // 如果循环引用了，则直接返回目标对象\n    if (seen.has(source)) {\n      // biome-ignore lint/style/noNonNullAssertion: 必须存在\n      return seen.get(source)!;\n    }\n\n    // 对齐目标对象和源对象\n    const merged = align(target, source);\n\n    // 存储循环引用\n    seen.set(source, merged);\n\n    // 遍历源对象\n    each(source, (value, key) => {\n      if (!next({ target: merged, source, key })) {\n        return;\n      }\n\n      if (isObject(value) || isArray(value)) {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          // @ts-expect-error\n          merge: () => merge(merged[key], value),\n        });\n      } else {\n        // @ts-expect-error\n        merged[key] = assign({\n          target: merged,\n          source,\n          key,\n          merge: () => value,\n        });\n      }\n    });\n\n    return merged;\n  };\n\n  let returnTarget = target;\n\n  for (const source of sources) {\n    returnTarget = merge(target, source);\n  }\n\n  return returnTarget;\n}\n\n/**\n * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。\n *\n * @param target - 目标对象或数组。\n * @param sources - 要合并的源对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj1 = { a: 1, b: { x: 10 } };\n * const obj2 = { b: { y: 20 }, c: 3 };\n * const merged = objectMerge(obj1, obj2);\n * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }\n * ```\n */\nexport function objectMerge(target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]) {\n  return _objectMerge(\n    {\n      next() {\n        return true;\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    ...sources,\n  );\n}\n\n/**\n * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。\n * 支持多个默认对象，优先级从左到右依次降低。\n * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。\n *\n * @param target - 目标对象或数组。\n * @param defaults - 默认对象或数组。\n * @returns 合并后的对象或数组。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: undefined };\n * const defaults = { a: 4, b: 2, c: 3 };\n * const result = objectDefaults(obj, defaults);\n * console.log(result); // { a: 1, b: 2, c: 3 }\n *\n * const obj2 = { a: 1, b: 2 };\n * const defaults2 = { a: 5, b: 3, c: 4 };\n * const result2 = objectDefaults(obj2, defaults2);\n * console.log(result2); // { a: 1, b: 2, c: 4 }\n *\n * const obj3 = { a: { x: 1 }, b: undefined };\n * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };\n * const result3 = objectDefaults(obj3, defaults3);\n * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }\n * ```\n */\nexport function objectDefaults<T extends AnyObject | AnyArray>(target: T, defaults: T): T {\n  return _objectMerge(\n    {\n      next({ target, key }) {\n        return (\n          // @ts-expect-error\n          target[key] === undefined ||\n          // @ts-expect-error\n          isObject(target[key]) ||\n          // @ts-expect-error\n          isArray(target[key])\n        );\n      },\n      assign({ merge }) {\n        return merge();\n      },\n    },\n    target,\n    defaults,\n  ) as T;\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\n/**\n * 根据提供的过滤函数过滤对象的属性，返回一个新对象，只包含满足条件的属性。\n *\n * @param object - 要过滤的对象。\n * @param predicate - 过滤函数，接收值和键作为参数，返回布尔值。\n * @returns 包含满足过滤条件的属性的新对象。\n *\n * @example\n * ```typescript\n * const obj = { a: 1, b: 2, c: 3, d: 4 };\n * const result = objectFilter(obj, (value, key) => value > 2);\n * console.log(result); // { c: 3, d: 4 }\n * ```\n */\nexport function objectFilter<T extends AnyObject>(\n  object: T,\n  predicate: (value: T[keyof T], key: keyof T) => boolean,\n): Partial<T> {\n  return Object.fromEntries(\n    Object.entries(object).filter(([key, value]) => predicate(value as T[keyof T], key as keyof T)),\n  ) as Partial<T>;\n}\n"],"mappings":"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"}