@cloudcome/utils-core 1.19.1 → 1.20.1

package/dist/function.mjs

@@ -1,79 +1,135 @@
 import { isNumber } from "./type.mjs";
-function fnNoop() {
-}
+//#region src/function.ts
+/**
+* 一个空操作函数，不执行任何操作。
+*
+* @example
+* ```typescript
+* fnNoop(); // 不执行任何操作
+* ```
+*/
+function fnNoop() {}
+/**
+* 创建一个防抖函数，该函数会在指定的等待时间后执行，如果在等待时间内再次调用，则重新计时。
+*
+* @param fn - 需要防抖的函数。
+* @param wait - 等待时间（毫秒）或包含 `wait` 和 `leading` 选项的对象。
+* @returns 返回一个防抖函数，该函数具有 `cancel` 方法，用于取消防抖操作。
+*
+* @example
+* ```typescript
+* const debouncedFn = fnDebounce(() => {
+*   console.log('Debounced!');
+* }, 100);
+*
+* debouncedFn(); // 不会立即执行
+* debouncedFn(); // 重新计时
+* debouncedFn.cancel(); // 取消防抖操作
+* ```
+*/
 function fnDebounce(fn, wait) {
-  const options = isNumber(wait) ? { wait } : wait;
-  let canceled = false;
-  let timer;
-  let leading = false;
-  const debounced = function(...args) {
-    if (canceled) return;
-    if (options.leading && !leading) {
-      leading = true;
-      fn.apply(this, args);
-      return;
-    }
-    clearTimeout(timer);
-    timer = setTimeout(() => {
-      if (canceled) return;
-      fn.apply(this, args);
-    }, options.wait);
-  };
-  debounced.cancel = () => {
-    clearTimeout(timer);
-    canceled = true;
-  };
-  return debounced;
+	const options = isNumber(wait) ? { wait } : wait;
+	let canceled = false;
+	let timer;
+	let leading = false;
+	const debounced = function(...args) {
+		if (canceled) return;
+		if (options.leading && !leading) {
+			leading = true;
+			fn.apply(this, args);
+			return;
+		}
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			if (canceled) return;
+			fn.apply(this, args);
+		}, options.wait);
+	};
+	debounced.cancel = () => {
+		clearTimeout(timer);
+		canceled = true;
+	};
+	return debounced;
 }
+/**
+* 创建一个节流函数，该函数会在指定的等待时间内最多执行一次，如果在等待时间内再次调用，则忽略后续调用。
+*
+* @param fn - 需要节流的函数。
+* @param wait - 等待时间（毫秒）或包含 `wait`、`leading` 和 `trailing` 选项的对象。
+* @returns 返回一个节流函数，该函数具有 `cancel` 方法，用于取消节流操作。
+*
+* @example
+* ```typescript
+* const throttledFn = fnThrottle(() => {
+*   console.log('Throttled!');
+* }, 100);
+*
+* throttledFn(); // 立即执行
+* throttledFn(); // 忽略
+* throttledFn.cancel(); // 取消节流操作
+* ```
+*/
 function fnThrottle(fn, wait) {
-  const options = isNumber(wait) ? { wait } : wait;
-  const waitFinal = options.wait;
-  let lastTime = 0;
-  let canceled = false;
-  let timer;
-  const throttled = function(...args) {
-    if (canceled) return;
-    const now = Date.now();
-    let executed = false;
-    if (options.leading && lastTime === 0) {
-      lastTime = now;
-      fn.apply(this, args);
-      executed = true;
-    } else if (lastTime > 0 && now - lastTime >= waitFinal) {
-      lastTime = now;
-      fn.apply(this, args);
-      executed = true;
-    } else if (lastTime === 0) {
-      lastTime = now;
-    }
-    if (options.trailing && !executed) {
-      clearTimeout(timer);
-      timer = setTimeout(() => {
-        fn.apply(this, args);
-      }, waitFinal);
-    }
-  };
-  throttled.cancel = () => {
-    canceled = true;
-    clearTimeout(timer);
-  };
-  return throttled;
+	const options = isNumber(wait) ? { wait } : wait;
+	const waitFinal = options.wait;
+	let lastTime = 0;
+	let canceled = false;
+	let timer;
+	const throttled = function(...args) {
+		if (canceled) return;
+		const now = Date.now();
+		let executed = false;
+		if (options.leading && lastTime === 0) {
+			lastTime = now;
+			fn.apply(this, args);
+			executed = true;
+		} else if (lastTime > 0 && now - lastTime >= waitFinal) {
+			lastTime = now;
+			fn.apply(this, args);
+			executed = true;
+		} else if (lastTime === 0) lastTime = now;
+		if (options.trailing && !executed) {
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				fn.apply(this, args);
+			}, waitFinal);
+		}
+	};
+	throttled.cancel = () => {
+		canceled = true;
+		clearTimeout(timer);
+	};
+	return throttled;
 }
+/**
+* 创建一个只执行一次的函数，无论调用多少次，实际执行的函数体也只会执行一次。
+*
+* @param fn - 需要只执行一次的函数。
+* @returns 返回一个只执行一次的函数，该函数在第一次调用后会缓存结果并返回缓存的结果。
+*
+* @example
+* ```typescript
+* const onceFn = fnOnce(() => {
+*   console.log('This will be logged only once.');
+*   return 42;
+* });
+*
+* console.log(onceFn()); // 输出: This will be logged only once. 42
+* console.log(onceFn()); // 输出: 42
+* ```
+*/
 function fnOnce(fn) {
-  let called = false;
-  let result;
-  return function(...args) {
-    if (!called) {
-      called = true;
-      result = fn.apply(this, args);
-    }
-    return result;
-  };
+	let called = false;
+	let result;
+	return function(...args) {
+		if (!called) {
+			called = true;
+			result = fn.apply(this, args);
+		}
+		return result;
+	};
 }
-export {
-  fnDebounce,
-  fnNoop,
-  fnOnce,
-  fnThrottle
-};
-//# sourceMappingURL=function.mjs.map
+//#endregion
+export { fnDebounce, fnNoop, fnOnce, fnThrottle };
+
+//# sourceMappingURL=function.mjs.map

package/dist/function.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"function.mjs","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>(fn: F, wait: number | DebounceOptions) {\n  const options: DebounceOptions = isNumber(wait) ? { wait } : wait;\n  let canceled = false;\n  // biome-ignore lint/suspicious/noExplicitAny: <explanation>\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: <explanation>\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: <explanation>\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"],"names":[],"mappings":";AAWO,SAAS,SAAS;AAEzB;AAmCgB,SAAA,WAAkC,IAAO,MAAgC;AACvF,QAAM,UAA2B,SAAS,IAAI,IAAI,EAAE,KAAS,IAAA;AAC7D,MAAI,WAAW;AAEX,MAAA;AACJ,MAAI,UAAU;AAER,QAAA,YAAY,YAA4B,MAAqB;AACjE,QAAI,SAAU;AAGV,QAAA,QAAQ,WAAW,CAAC,SAAS;AACrB,gBAAA;AACP,SAAA,MAAM,MAAM,IAAI;AACnB;AAAA,IAAA;AAIF,iBAAa,KAAK;AAClB,YAAQ,WAAW,MAAM;AACvB,UAAI,SAAU;AAEX,SAAA,MAAM,MAAM,IAAI;AAAA,IAAA,GAClB,QAAQ,IAAI;AAAA,EACjB;AAEA,YAAU,SAAS,MAAM;AACvB,iBAAa,KAAK;AACP,eAAA;AAAA,EACb;AAEO,SAAA;AACT;AAuCgB,SAAA,WAAkC,IAAO,MAAgC;AACvF,QAAM,UAAU,SAAS,IAAI,IAAI,EAAE,KAAS,IAAA;AAC5C,QAAM,YAAY,QAAQ;AAC1B,MAAI,WAAW;AACf,MAAI,WAAW;AAEX,MAAA;AAEE,QAAA,YAAY,YAA4B,MAAqB;AACjE,QAAI,SAAU;AAER,UAAA,MAAM,KAAK,IAAI;AACrB,QAAI,WAAW;AAGX,QAAA,QAAQ,WAAW,aAAa,GAAG;AAC1B,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AACR,iBAAA;AAAA,IAIJ,WAAA,WAAW,KAAK,MAAM,YAAY,WAAW;AACzC,iBAAA;AACR,SAAA,MAAM,MAAM,IAAI;AACR,iBAAA;AAAA,IAAA,WAIJ,aAAa,GAAG;AACZ,iBAAA;AAAA,IAAA;AAIT,QAAA,QAAQ,YAAY,CAAC,UAAU;AACjC,mBAAa,KAAK;AAClB,cAAQ,WAAW,MAAM;AACpB,WAAA,MAAM,MAAM,IAAI;AAAA,SAClB,SAAS;AAAA,IAAA;AAAA,EAEhB;AAEA,YAAU,SAAS,MAAM;AACZ,eAAA;AACX,iBAAa,KAAK;AAAA,EACpB;AAEO,SAAA;AACT;AAmBO,SAAS,OAA8B,IAAO;AACnD,MAAI,SAAS;AAET,MAAA;AAEJ,SAAO,YAA4B,MAAqB;AACtD,QAAI,CAAC,QAAQ;AACF,eAAA;AACA,eAAA,GAAG,MAAM,MAAM,IAAI;AAAA,IAAA;AAGvB,WAAA;AAAA,EACT;AACF;"}
+{"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>(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"],"mappings":";;;;;;;;;;AAWA,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"}

package/dist/index.cjs

@@ -1,5 +1,10 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const VERSION = "1.19.0";
+//#region src/index.ts
+/**
+* `@cloudcome/utils-core` 版本号
+*/
+var VERSION = "1.20.1";
+//#endregion
 exports.VERSION = VERSION;
-//# sourceMappingURL=index.cjs.map
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../src/index.ts"],"sourcesContent":["/**\n * `@cloudcome/utils-core` 版本号\n */\nexport const VERSION = PKG_VERSION;\n"],"names":[],"mappings":";;AAGO,MAAM,UAAU;;"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@cloudcome/utils-core` 版本号\n */\nexport const VERSION = PKG_VERSION;\n"],"mappings":";;;;;AAGA,IAAa,UAAA"}

package/dist/index.mjs

@@ -1,5 +1,9 @@
-const VERSION = "1.19.0";
-export {
-  VERSION
-};
-//# sourceMappingURL=index.mjs.map
+//#region src/index.ts
+/**
+* `@cloudcome/utils-core` 版本号
+*/
+var VERSION = "1.20.1";
+//#endregion
+export { VERSION };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":["/**\n * `@cloudcome/utils-core` 版本号\n */\nexport const VERSION = PKG_VERSION;\n"],"names":[],"mappings":"AAGO,MAAM,UAAU;"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@cloudcome/utils-core` 版本号\n */\nexport const VERSION = PKG_VERSION;\n"],"mappings":";;;;AAGA,IAAa,UAAA"}

package/dist/number.cjs

@@ -1,15 +1,11 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./merge.cjs");
-const number = require("./string2.cjs");
-require("./type.cjs");
-exports.fileSizeAbbr = number.fileSizeAbbr;
-exports.numberAbbr = number.numberAbbr;
-exports.numberClamp = number.numberClamp;
-exports.numberConvert = number.numberConvert;
-exports.numberDecimals = number.numberDecimals;
-exports.numberFixed = number.numberFixed;
-exports.numberFormat = number.numberFormat;
-exports.numberUnit = number.numberUnit;
-exports.randomNumber = number.randomNumber;
-//# sourceMappingURL=number.cjs.map
+const require_string = require("./string2.cjs");
+exports.fileSizeAbbr = require_string.fileSizeAbbr;
+exports.numberAbbr = require_string.numberAbbr;
+exports.numberClamp = require_string.numberClamp;
+exports.numberConvert = require_string.numberConvert;
+exports.numberDecimals = require_string.numberDecimals;
+exports.numberFixed = require_string.numberFixed;
+exports.numberFormat = require_string.numberFormat;
+exports.numberUnit = require_string.numberUnit;
+exports.randomNumber = require_string.randomNumber;

package/dist/number.mjs

@@ -1,15 +1,2 @@
-import "./merge.mjs";
-import { f, b, d, n, g, a, c, e, r } from "./string2.mjs";
-import "./type.mjs";
-export {
-  f as fileSizeAbbr,
-  b as numberAbbr,
-  d as numberClamp,
-  n as numberConvert,
-  g as numberDecimals,
-  a as numberFixed,
-  c as numberFormat,
-  e as numberUnit,
-  r as randomNumber
-};
-//# sourceMappingURL=number.mjs.map
+import { _ as numberFixed, b as randomNumber, f as fileSizeAbbr, g as numberDecimals, h as numberConvert, m as numberClamp, p as numberAbbr, v as numberFormat, y as numberUnit } from "./string2.mjs";
+export { fileSizeAbbr, numberAbbr, numberClamp, numberConvert, numberDecimals, numberFixed, numberFormat, numberUnit, randomNumber };

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

@@ -68,7 +68,7 @@ export type ObjectSetOptions<O extends AnyObject> = {
      */
     beforeSet(node: ObjectNode<O> & {
         key: string;
-    }): boolean | undefined | void;
+    }): boolean | undefined;
     /**
      * 当遇到未定义的中间节点时调用的钩子函数。
      * 返回值将用于创建中间节点。
@@ -76,7 +76,7 @@ export type ObjectSetOptions<O extends AnyObject> = {
      * @param {ObjectNode<O>} node - 当前节点信息。
      * @returns {AnyObject | AnyArray | undefined | void} 返回值将用于创建中间节点。
      */
-    undefinedSet(node: ObjectNode<O>): AnyObject | AnyArray | undefined | void;
+    undefinedSet(node: ObjectNode<O>): AnyObject | AnyArray | undefined;
 };
 /**
  * 根据属性路径设置属性值

package/dist/object/merge.d.ts

@@ -23,8 +23,8 @@ export type ObjectMergeRule = {
         target: AnyObject | AnyArray;
         source: AnyObject | AnyArray;
         key: string | number;
-        merge: () => any;
-    }) => any;
+        merge: () => unknown;
+    }) => unknown;
 };
 /**
  * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。