@cloudcome/utils-core 1.1.1 → 1.2.0

package/dist/number.d.ts

@@ -0,0 +1,153 @@
+export type NumberFixedOptions = {
+    /**
+     * 保留的小数位数
+     * @default 0
+     */
+    precision?: number;
+    /**
+     * 舍入方法，0 为四舍五入，1 为向上取整，-1 为向下取整
+     * @default 0
+     */
+    round?: 0 | 1 | -1;
+};
+/**
+ * 对数字进行精确小数位数处理并按规则舍入
+ * @param number 需要处理的原始数值
+ * @param options 可选配置参数
+ * @returns 处理后的数值（number类型）
+ * @example
+ * // 四舍五入示例
+ * numberFixed(3.1415, { precision: 2 }); // 3.14
+ * // 向上取整示例
+ * numberFixed(3.1415, { precision: 2, round: 1 }); // 3.15
+ * // 向下取整示例
+ * numberFixed(3.9999, { precision: 1, round: -1 }); // 3.9
+ */
+export declare function numberFixed(number: number, options?: NumberFixedOptions): number;
+/**
+ * 生成指定范围内的随机整数
+ * @param {number} min - 随机数的最小值（包含）
+ * @param {number} max - 随机数的最大值（包含）
+ * @returns {number} - 生成的随机整数
+ * @example
+ * // 生成 1 到 10 之间的随机整数
+ * randomNumber(1, 10); // 可能返回 7
+ */
+export declare function randomNumber(min: number, max: number): number;
+/**
+ * 数字缩写选项
+ */
+export type NumberAbbrOptions = {
+    /**
+     * 进制基数，用于计算单位进阶（如 1000 表示千进制）
+     * @default 1000
+     */
+    base?: number;
+    /**
+     * 数值保留的小数位数
+     * @default 0
+     */
+    precision?: number;
+};
+/**
+ * 将数字转换为带单位缩写的字符串表示
+ *
+ * @param {number} number - 需要转换的原始数值
+ * @param {Array<string>} units - 单位数组，按从小到大顺序排列（如['B','KB','MB']），不能为空
+ * @param {NumberAbbrOptions} [options] - 可选配置参数
+ * @returns {string} - 转换后的带单位字符串（如"1.2KB"）
+ * @example
+ * // 基础用法
+ * numberAbbr(1500, ['', 'K', 'M'], { base: 1000 }); // "1.5K"
+ * @example
+ * // 自定义小数位
+ * numberAbbr(123456, ['B','KB','MB'], { precision: 1 }); // "0.1MB"
+ * @example
+ * // 处理不足基数的情况
+ * numberAbbr(500, ['B','KB']); // "500B"
+ */
+export declare function numberAbbr(number: number, units: Array<string>, options?: NumberAbbrOptions): string;
+/**
+ * 将文件大小转换为带单位缩写的字符串表示
+ *
+ * @param {number} number - 需要转换的文件大小数值
+ * @param {number} [precision=0] - 数值保留的小数位数
+ * @returns {string} - 转换后的带单位字符串（如"1.2KB"）
+ * @example
+ * // 基础用法
+ * fileSizeAbbr(1024); // "1KB"
+ * @example
+ * // 自定义小数位
+ * fileSizeAbbr(123456, 1); // "0.1MB"
+ */
+export declare function fileSizeAbbr(number: number, precision?: number): string;
+/**
+ * 将十进制数转换为指定进制的字符串表示
+ *
+ * @param {number | bigint} decimal - 需要转换的十进制数，可以是任意长度的数字或大整数
+ * @param {string} [dict] - 用于表示进制的字符字典，默认为数字、小写字母和大写字母的组合（62 进制）
+ * @returns {string} - 转换后的指定进制字符串
+ * @throws {Error} - 如果字符字典的长度小于 2，将抛出错误
+ * @example
+ * // 默认 62 进制
+ * numberConvert(123456789); // "8M0kX"
+ * @example
+ * // 自定义 16 进制
+ * numberConvert(255, '0123456789ABCDEF'); // "FF"
+ * @example
+ * // 处理大整数
+ * numberConvert(9007199254740991n); // "2gosa7pa2GV"
+ */
+export declare function numberConvert(decimal: number | bigint, dict?: string): string;
+/**
+ * 数字格式化配置选项
+ */
+export type NumberFormatOptions = {
+    /**
+     * 分隔符字符，用于数字分隔
+     * @default ','
+     * @example 使用 '_' 分隔符时，123456 会格式化为 '123_456'
+     */
+    separator?: string;
+    /**
+     * 分隔步长，即每隔多少位添加分隔符
+     * @default 3
+     * @example 步长为 2 时，123456 会格式化为 '12,34,56'
+     */
+    step?: number;
+};
+/**
+ * 数字格式化
+ * @param [number] {number} 数字
+ * @param options {NumberFormatOptions} 格式化配置
+ * @returns {string} 分割后的字符串
+ * @example
+ * // 使用默认分隔符和步长
+ * numberFormat(123456.789); // => "123,456.789"
+ * // 自定义分隔符
+ * numberFormat(123456.789, '_'); // => "123_456.789"
+ * // 自定义步长
+ * numberFormat(123456.789, 2); // => "12,34,56.789"
+ * // 使用对象配置
+ * numberFormat(123456.789, { separator: '.', step: 4 }); // => "12.3456.789"
+ */
+export declare function numberFormat(number: number, options: NumberFormatOptions): string;
+export declare function numberFormat(number: number, separator: string): string;
+export declare function numberFormat(number: number, step: number): string;
+export declare function numberFormat(number: number): string;
+/**
+ * 将数字限制在指定范围内。
+ *
+ * @param min - 最小值。
+ * @param number - 要限制的数字。
+ * @param max - 最大值。
+ * @returns 限制后的数字。
+ */
+export declare function numberClamp(min: number, number: number, max: number): number;
+/**
+ * 为数字添加单位
+ * @param number - 需要处理的数字，可以是数字类型或字符串类型
+ * @param unit - 要添加的单位，默认为空字符串
+ * @returns 如果输入是数字或纯数字字符串，则返回带单位的字符串；否则返回原值
+ */
+export declare function numberUnit(number: string | number, unit?: string): string;

package/dist/number.mjs

@@ -0,0 +1,14 @@
+import "./merge.mjs";
+import { f, b, d, n, a, c, e, r } from "./string2.mjs";
+import "./type.mjs";
+export {
+  f as fileSizeAbbr,
+  b as numberAbbr,
+  d as numberClamp,
+  n as numberConvert,
+  a as numberFixed,
+  c as numberFormat,
+  e as numberUnit,
+  r as randomNumber
+};
+//# sourceMappingURL=number.mjs.map

package/dist/number.mjs.map

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

package/{src/object/each.ts → dist/object/each.d.ts}

@@ -1,5 +1,4 @@
-import type { AnyObject, MaybePromise } from '@/types';
-
+import { AnyObject, MaybePromise } from '../types';
 /**
  * 遍历对象的每个键值对，并对每个键值对执行提供的回调函数。
  *
@@ -16,17 +15,7 @@ import type { AnyObject, MaybePromise } from '@/types';
  * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]
  * ```
  */
-export function objectEach<O extends AnyObject, K extends keyof O & (string | number)>(
-  obj: O,
-  iterator: (this: O, val: O[K], key: K) => false | unknown,
-): void {
-  for (const [key, val] of Object.entries(obj)) {
-    if (iterator.call(obj, val as O[K], key as K) === false) {
-      break;
-    }
-  }
-}
-
+export declare function objectEach<O extends AnyObject, K extends keyof O & (string | number)>(obj: O, iterator: (this: O, val: O[K], key: K) => false | unknown): void;
 /**
  * 异步遍历对象的每个键值对，并对每个键值对执行提供的回调函数。
  *
@@ -44,13 +33,4 @@ export function objectEach<O extends AnyObject, K extends keyof O & (string | nu
  * console.log(results); // [['a', 1], ['b', 2], ['c', 3]]
  * ```
  */
-export async function objectEachAsync<O extends AnyObject, K extends keyof O & (string | number)>(
-  obj: O,
-  iterator: (this: O, val: O[K], key: K) => MaybePromise<false | unknown>,
-): Promise<void> {
-  for (const [key, val] of Object.entries(obj)) {
-    if ((await iterator.call(obj, val as O[K], key as K)) === false) {
-      break;
-    }
-  }
-}
+export declare function objectEachAsync<O extends AnyObject, K extends keyof O & (string | number)>(obj: O, iterator: (this: O, val: O[K], key: K) => MaybePromise<false | unknown>): Promise<void>;

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

@@ -0,0 +1,111 @@
+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[]];
+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] : '';
+export type ObjectLeafPath<O, D extends number = 4> = [D] extends [never] ? never : O extends object ? {
+    [K in keyof O]-?: K extends string | number ? O[K] extends string | number ? `${K}` | Join<K, ObjectLeafPath<O[K], Prev[D]>> : Join<K, ObjectLeafPath<O[K], Prev[D]>> : never;
+}[keyof O] : '';
+export type ObjectPathValue<O, P extends ObjectPath<O, 4>> = P extends `${infer Key}.${infer Rest}` ? Rest extends ObjectPath<Idx<O, Key>, 4> ? ObjectPathValue<Idx<O, Key>, Rest> : never : Idx<O, P>;
+/**
+ * 表示对象节点的信息。
+ *
+ * @template V - 键值的类型。
+ */
+export type TObjectNode<V = unknown | undefined> = {
+    /**
+     * 当前节点的父级对象。
+     */
+    parent: unknown | undefined;
+    /**
+     * 当前节点的键名路径。
+     */
+    keys: string[];
+    /**
+     * 当前节点的键名。
+     */
+    key: string | undefined;
+    /**
+     * 当前节点的键值。
+     */
+    value: V;
+};
+/**
+ * 根据属性路径获取属性值
+ * @param {O} obj
+ * @param {string | string[] | P} path
+ * @returns {TObjectNode<O>}
+ * 根据属性路径获取属性值。
+ *
+ * @template O - 目标对象的类型。
+ * @template P - 属性路径的类型。
+ * @param {O} obj - 要操作的目标对象。
+ * @param {P | string | string[]} path - 属性路径，可以是字符串或字符串数组。支持点分隔符（如 "a.b.c"）或数组形式（如 ["a", "b", "c"]）。
+ * @returns {TObjectNode<O>} 返回一个包含父级、键名路径、键名和键值的对象节点。
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: { b: { c: 42 } } };
+ * const result = objectGet(obj, 'a.b.c');
+ * console.log(result.value); // 输出 42
+ * ```
+ */
+export declare function objectGet<O extends AnyObject, P extends ObjectPath<O>>(obj: O, path: P | string | string[]): TObjectNode<O>;
+/**
+ * 配置选项，用于控制 `objectSet` 的行为。
+ *
+ * @template O - 目标对象的类型。
+ */
+export type TObjectSetOptions<O extends AnyObject> = {
+    /**
+     * 在设置值之前调用的钩子函数。
+     * 如果返回 `false`，则阻止设置值。
+     *
+     * @param {TObjectNode<O> & { key: string }} node - 当前节点信息。
+     * @returns {boolean | undefined | void} 返回 `false` 时阻止设置值。
+     */
+    beforeSet(node: TObjectNode<O> & {
+        key: string;
+    }): boolean | undefined | void;
+    /**
+     * 当遇到未定义的中间节点时调用的钩子函数。
+     * 返回值将用于创建中间节点。
+     *
+     * @param {TObjectNode<O>} node - 当前节点信息。
+     * @returns {AnyObject | AnyArray | undefined | void} 返回值将用于创建中间节点。
+     */
+    undefinedSet(node: TObjectNode<O>): AnyObject | AnyArray | undefined | void;
+};
+/**
+ * 根据属性路径设置属性值
+ * @param {AnyObject} obj
+ * @param {string} path
+ * @param {V} val
+ * @param {Partial<TObjectSetOptions<O>>} options
+ * @returns {TObjectNode<O, V>}
+ * 根据属性路径设置属性值。
+ *
+ * @template O - 目标对象的类型。
+ * @template V - 要设置的值的类型。
+ * @param {O} obj - 要操作的目标对象。
+ * @param {string | string[]} path - 属性路径，可以是字符串或字符串数组。支持点分隔符（如 "a.b.c"）或数组形式（如 ["a", "b", "c"]）。
+ * @param {V} val - 要设置的值。
+ * @param {Partial<TObjectSetOptions<O>>} [options] - 可选配置项，用于控制设置行为。
+ * @returns {TObjectNode<V>} 返回一个包含父级、键名路径、键名和键值的对象节点。
+ *
+ * @example
+ * ```typescript
+ * const obj = {};
+ * objectSet(obj, 'a.b.c', 42);
+ * console.log(obj); // 输出 { a: { b: { c: 42 } } }
+ *
+ * objectSet(obj, 'a.b.c', 100, {
+ *   beforeSet: (node) => node.key === 'c',
+ * });
+ * console.log(obj); // 输出 { a: { b: { c: 100 } } }
+ * ```
+ */
+export declare function objectSet<O extends AnyObject, V>(obj: O, path: string | string[], val: V, options?: Partial<TObjectSetOptions<O>>): TObjectNode<V>;
+export {};

package/dist/object/is.d.ts

@@ -0,0 +1,32 @@
+import { AnyObject } from '../types';
+/**
+ * 检查一个对象是否为空对象（不包含任何自有属性，包括符号属性）。
+ *
+ * @param obj - 要检查的对象
+ * @returns 如果对象没有自有属性（包括符号属性）则返回 true，否则返回 false
+ *
+ * @example
+ * ```typescript
+ * isEmptyObject({}); // true
+ * isEmptyObject({ a: 1 }); // false
+ * isEmptyObject(Object.create(null)); // true
+ * isEmptyObject({ [Symbol('key')]: 'value' }); // false
+ * ```
+ */
+export declare function isEmptyObject(obj: AnyObject): boolean;
+/**
+ * 检查一个对象是否为纯对象（通过对象字面量或Object构造函数创建，而非其他构造函数的实例）。
+ *
+ * @param obj - 要检查的对象
+ * @returns 如果是纯对象则返回 true，否则返回 false
+ *
+ * @example
+ * ```typescript
+ * isPlainObject({}); // true
+ * isPlainObject(Object.create(null)); // true
+ * isPlainObject(new Date()); // false
+ * isPlainObject([]); // false
+ * isPlainObject(() => {}); // false
+ * ```
+ */
+export declare function isPlainObject(obj: AnyObject): boolean;

package/dist/object/merge.d.ts

@@ -0,0 +1,72 @@
+import { AnyArray, AnyObject } from '../types';
+export type TObjectMergeRule = {
+    /**
+     * 处理冲突
+     * @param target - 目标对象
+     * @param source - 源对象
+     * @param key - 键名
+     * @returns 返回 true 表示继续处理，否则返回 false
+     */
+    next: (info: {
+        target: AnyObject | AnyArray;
+        source: AnyObject | AnyArray;
+        key: string | number;
+    }) => boolean;
+    /**
+     * 处理赋值
+     * @param target - 目标对象
+     * @param source - 源对象
+     * @param key - 键名
+     * @returns 返回处理后的值
+     */
+    assign: (info: {
+        target: AnyObject | AnyArray;
+        source: AnyObject | AnyArray;
+        key: string | number;
+        merge: () => any;
+    }) => any;
+};
+/**
+ * 合并多个对象或数组。如果遇到循环引用，则直接返回目标对象。
+ *
+ * @param target - 目标对象或数组。
+ * @param sources - 要合并的源对象或数组。
+ * @returns 合并后的对象或数组。
+ *
+ * @example
+ * ```typescript
+ * const obj1 = { a: 1, b: { x: 10 } };
+ * const obj2 = { b: { y: 20 }, c: 3 };
+ * const merged = objectMerge(obj1, obj2);
+ * console.log(merged); // { a: 1, b: { x: 10, y: 20 }, c: 3 }
+ * ```
+ */
+export declare function objectMerge(target: AnyObject | AnyArray, ...sources: (AnyObject | AnyArray)[]): AnyObject | AnyArray;
+/**
+ * 为对象设置默认值。如果目标对象中的属性为 `undefined`，则使用默认对象中的属性值。
+ * 支持多个默认对象，优先级从左到右依次降低。
+ * 如果目标对象中的属性已经是对象或数组，则递归地设置默认值。
+ *
+ * @param target - 目标对象或数组。
+ * @param defaults - 默认对象或数组。
+ * @returns 合并后的对象或数组。
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1, b: undefined };
+ * const defaults = { a: 4, b: 2, c: 3 };
+ * const result = objectDefaults(obj, defaults);
+ * console.log(result); // { a: 1, b: 2, c: 3 }
+ *
+ * const obj2 = { a: 1, b: 2 };
+ * const defaults2 = { a: 5, b: 3, c: 4 };
+ * const result2 = objectDefaults(obj2, defaults2);
+ * console.log(result2); // { a: 1, b: 2, c: 4 }
+ *
+ * const obj3 = { a: { x: 1 }, b: undefined };
+ * const defaults3 = { a: { x: 4, z: 3 }, b: { y: 2 } };
+ * const result3 = objectDefaults(obj3, defaults3);
+ * console.log(result3); // { a: { x: 1, z: 3 }, b: { y: 2 } }
+ * ```
+ */
+export declare function objectDefaults<T extends AnyObject | AnyArray>(target: T, defaults: T): T;

package/{src/object/process.ts → dist/object/process.d.ts}

@@ -1,5 +1,4 @@
-import type { AnyObject } from '@/types';
-
+import { AnyObject } from '../types';
 /**
  * 从对象中选择指定键的属性，返回一个新的对象。
  *
@@ -14,16 +13,7 @@ import type { AnyObject } from '@/types';
  * console.log(result); // { a: 1, c: 3 }
  * ```
  */
-export function objectPick<T extends AnyObject, K extends keyof T>(object: T, keys: K[]): Pick<T, K> {
-  const result = {} as Pick<T, K>;
-  for (const key of keys) {
-    if (key in object) {
-      result[key] = object[key];
-    }
-  }
-  return result;
-}
-
+export declare function objectPick<T extends AnyObject, K extends keyof T>(object: T, keys: K[]): Pick<T, K>;
 /**
  * 从对象中排除指定键的属性，返回一个新的对象。
  *
@@ -38,17 +28,7 @@ export function objectPick<T extends AnyObject, K extends keyof T>(object: T, ke
  * console.log(result); // { b: 2, c: 3 }
  * ```
  */
-export function objectOmit<T extends AnyObject, K extends keyof T>(object: T, keys: K[]): Omit<T, K> {
-  const result = {} as Omit<T, K>;
-  for (const key in object) {
-    if (!keys.includes(key as unknown as K)) {
-      // @ts-expect-error
-      result[key] = object[key];
-    }
-  }
-  return result;
-}
-
+export declare function objectOmit<T extends AnyObject, K extends keyof T>(object: T, keys: K[]): Omit<T, K>;
 /**
  * 遍历对象的每个键值对，并对每个键值对执行提供的映射函数，返回一个新的对象。
  *
@@ -63,18 +43,4 @@ export function objectOmit<T extends AnyObject, K extends keyof T>(object: T, ke
  * console.log(result); // { a: '2', b: '4', c: '6' }
  * ```
  */
-export function objectMap<T extends AnyObject, V>(
-  object: T,
-  mapper: (value: T[keyof T], key: keyof T) => V,
-): Record<keyof T, V> {
-  return Object.fromEntries(
-    Object.entries(object).map(([key, value]) => [
-      key,
-      mapper(
-        // @ts-expect-error
-        value,
-        key as keyof T,
-      ),
-    ]),
-  ) as Record<keyof T, V>;
-}
+export declare function objectMap<T extends AnyObject, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => V): Record<keyof T, V>;

package/dist/object.cjs

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

package/dist/object.cjs.map

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