@composy/store-core 0.0.1

package/esm/types/utility.d.ts

@@ -0,0 +1,312 @@
+/**
+ * 工具类型定义
+ *
+ * 提供常用的类型工具，用于增强类型安全
+ * @module types/utility
+ */
+/**
+ * 深度部分类型
+ *
+ * 将对象的所有属性（包括嵌套属性）设为可选
+ *
+ * @template T - 原始类型
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   name: string
+ *   address: { city: string; zip: string }
+ * }
+ *
+ * type PartialUser = DeepPartial<User>
+ * // { name?: string; address?: { city?: string; zip?: string } }
+ * ```
+ */
+export type DeepPartial<T> = T extends object ? T extends Array<infer U> ? Array<DeepPartial<U>> : T extends Map<infer K, infer V> ? Map<DeepPartial<K>, DeepPartial<V>> : T extends Set<infer U> ? Set<DeepPartial<U>> : T extends Function ? T : {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/**
+ * 深度只读类型
+ *
+ * 将对象的所有属性（包括嵌套属性）设为只读
+ *
+ * @template T - 原始类型
+ *
+ * @example
+ * ```typescript
+ * interface Config {
+ *   api: { url: string; timeout: number }
+ * }
+ *
+ * type ReadonlyConfig = DeepReadonly<Config>
+ * // { readonly api: { readonly url: string; readonly timeout: number } }
+ * ```
+ */
+export type DeepReadonly<T> = T extends object ? T extends Array<infer U> ? ReadonlyArray<DeepReadonly<U>> : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends Function ? T : {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+} : T;
+/**
+ * 只读 Map 类型
+ */
+type ReadonlyMap<K, V> = Omit<Map<K, V>, 'set' | 'delete' | 'clear'>;
+/**
+ * 只读 Set 类型
+ */
+type ReadonlySet<T> = Omit<Set<T>, 'add' | 'delete' | 'clear'>;
+/**
+ * 获取对象的所有路径
+ *
+ * @template T - 对象类型
+ *
+ * @example
+ * ```typescript
+ * interface State {
+ *   user: { name: string; age: number }
+ *   settings: { theme: string }
+ * }
+ *
+ * type Paths = PathsOf<State>
+ * // 'user' | 'user.name' | 'user.age' | 'settings' | 'settings.theme'
+ * ```
+ */
+export type PathsOf<T, Prefix extends string = ''> = T extends object ? T extends Array<unknown> ? Prefix : {
+    [K in keyof T & string]: K extends string ? Prefix extends '' ? K | PathsOf<T[K], K> : `${Prefix}.${K}` | PathsOf<T[K], `${Prefix}.${K}`> : never;
+}[keyof T & string] : Prefix;
+/**
+ * 根据路径获取类型
+ *
+ * @template T - 对象类型
+ * @template P - 路径字符串
+ *
+ * @example
+ * ```typescript
+ * interface State {
+ *   user: { name: string; age: number }
+ * }
+ *
+ * type UserName = PathValue<State, 'user.name'> // string
+ * type User = PathValue<State, 'user'> // { name: string; age: number }
+ * ```
+ */
+export type PathValue<T, P extends string> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : P extends keyof T ? T[P] : never;
+/**
+ * 提取函数的参数类型
+ *
+ * @template T - 函数类型
+ */
+export type ArgumentsOf<T extends (...args: unknown[]) => unknown> = T extends (...args: infer P) => unknown ? P : never;
+/**
+ * 提取函数的返回类型（异步函数自动解包 Promise）
+ *
+ * @template T - 函数类型
+ */
+export type AsyncReturnType<T extends (...args: unknown[]) => unknown> = T extends (...args: unknown[]) => Promise<infer R> ? R : T extends (...args: unknown[]) => infer R ? R : never;
+/**
+ * 非空类型
+ *
+ * 从类型中排除 null 和 undefined
+ *
+ * @template T - 原始类型
+ */
+export type NonNullable<T> = T extends null | undefined ? never : T;
+/**
+ * 可为 null 的类型
+ *
+ * @template T - 原始类型
+ */
+export type Nullable<T> = T | null;
+/**
+ * 可选的类型
+ *
+ * @template T - 原始类型
+ */
+export type Optional<T> = T | undefined;
+/**
+ * 品牌类型
+ *
+ * 用于创建名义类型系统
+ *
+ * @template T - 基础类型
+ * @template Brand - 品牌标识
+ *
+ * @example
+ * ```typescript
+ * type UserId = Brand<string, 'UserId'>
+ * type PostId = Brand<string, 'PostId'>
+ *
+ * // UserId 和 PostId 不能互相赋值，即使底层都是 string
+ * ```
+ */
+export type Brand<T, Brand extends string> = T & {
+    __brand: Brand;
+};
+/**
+ * 严格对象类型
+ *
+ * 确保对象不包含多余的属性
+ *
+ * @template T - 期望类型
+ * @template Actual - 实际类型
+ */
+export type Exact<T, Actual extends T> = T & {
+    [K in keyof Actual]: K extends keyof T ? T[K] : never;
+};
+/**
+ * 获取对象的必需键
+ *
+ * @template T - 对象类型
+ */
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? never : K;
+}[keyof T];
+/**
+ * 获取对象的可选键
+ *
+ * @template T - 对象类型
+ */
+export type OptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+}[keyof T];
+/**
+ * 选择对象的部分属性设为必需
+ *
+ * @template T - 对象类型
+ * @template K - 需要设为必需的键
+ */
+export type RequireKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * 选择对象的部分属性设为可选
+ *
+ * @template T - 对象类型
+ * @template K - 需要设为可选的键
+ */
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * 合并两个类型
+ *
+ * 第二个类型的属性会覆盖第一个类型
+ *
+ * @template T - 第一个类型
+ * @template U - 第二个类型
+ */
+export type Merge<T, U> = Omit<T, keyof U> & U;
+/**
+ * 获取两个类型的公共键
+ *
+ * @template T - 第一个类型
+ * @template U - 第二个类型
+ */
+export type CommonKeys<T, U> = keyof T & keyof U;
+/**
+ * 函数类型
+ */
+export type AnyFunction = (...args: unknown[]) => unknown;
+/**
+ * 异步函数类型
+ */
+export type AsyncFunction = (...args: unknown[]) => Promise<unknown>;
+/**
+ * 类类型
+ *
+ * @template T - 实例类型
+ */
+export type Constructor<T = unknown> = new (...args: unknown[]) => T;
+/**
+ * 抽象类类型
+ *
+ * @template T - 实例类型
+ */
+export type AbstractConstructor<T = unknown> = abstract new (...args: unknown[]) => T;
+/**
+ * 确保类型不为 never
+ *
+ * @template T - 待检查类型
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * 确保类型是数组
+ *
+ * @template T - 待检查类型
+ */
+export type IsArray<T> = T extends unknown[] ? true : false;
+/**
+ * 确保类型是对象（非数组、非函数）
+ *
+ * @template T - 待检查类型
+ */
+export type IsPlainObject<T> = T extends object ? T extends Function ? false : T extends unknown[] ? false : true : false;
+/**
+ * 值类型为指定类型的键
+ *
+ * @template T - 对象类型
+ * @template V - 值类型
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   id: number
+ *   name: string
+ *   age: number
+ * }
+ *
+ * type NumberKeys = KeysOfType<User, number> // 'id' | 'age'
+ * ```
+ */
+export type KeysOfType<T, V> = {
+    [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * 排除值类型为指定类型的键
+ *
+ * @template T - 对象类型
+ * @template V - 要排除的值类型
+ */
+export type KeysExcludeType<T, V> = {
+    [K in keyof T]: T[K] extends V ? never : K;
+}[keyof T];
+/**
+ * 仅保留值类型为指定类型的属性
+ *
+ * @template T - 对象类型
+ * @template V - 值类型
+ */
+export type PickByType<T, V> = Pick<T, KeysOfType<T, V>>;
+/**
+ * 排除值类型为指定类型的属性
+ *
+ * @template T - 对象类型
+ * @template V - 要排除的值类型
+ */
+export type OmitByType<T, V> = Pick<T, KeysExcludeType<T, V>>;
+/**
+ * 提取 Promise 的值类型
+ *
+ * @template T - Promise 类型
+ */
+export type Awaited<T> = T extends Promise<infer U> ? Awaited<U> : T;
+/**
+ * 联合类型转交叉类型
+ *
+ * @template U - 联合类型
+ */
+export type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * 元组类型转联合类型
+ *
+ * @template T - 元组类型
+ */
+export type TupleToUnion<T extends unknown[]> = T[number];
+/**
+ * 字符串字面量首字母大写
+ *
+ * @template S - 字符串类型
+ */
+export type Capitalize<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+/**
+ * 字符串字面量首字母小写
+ *
+ * @template S - 字符串类型
+ */
+export type Uncapitalize<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+export {};
+//# sourceMappingURL=utility.d.ts.map

package/esm/utils/debounce-throttle.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 防抖和节流工具函数
+ *
+ * 提供性能优化的防抖、节流功能
+ * @module utils/debounce-throttle
+ */
+/**
+ * 防抖函数返回类型
+ */
+export interface DebouncedFunction<T extends (...args: never[]) => void> {
+    (...args: Parameters<T>): void;
+    /** 取消待执行的调用 */
+    cancel: () => void;
+    /** 立即执行待处理的调用 */
+    flush: () => void;
+    /** 是否有待处理的调用 */
+    pending: () => boolean;
+}
+/**
+ * 节流函数返回类型
+ */
+export interface ThrottledFunction<T extends (...args: never[]) => void> {
+    (...args: Parameters<T>): void;
+    /** 取消待执行的调用 */
+    cancel: () => void;
+}
+/**
+ * 创建防抖函数
+ *
+ * 在连续调用停止后，延迟指定时间执行函数
+ *
+ * @template T - 函数类型
+ * @param fn - 需要防抖的函数
+ * @param delay - 延迟时间（毫秒）
+ * @param immediate - 是否在首次调用时立即执行
+ * @returns 防抖后的函数
+ *
+ * @example
+ * ```typescript
+ * const debouncedSearch = debounce((query: string) => {
+ *   fetchResults(query)
+ * }, 300)
+ *
+ * // 连续调用只会在最后一次调用后 300ms 执行
+ * debouncedSearch('a')
+ * debouncedSearch('ab')
+ * debouncedSearch('abc') // 只有这次会触发
+ *
+ * // 取消待执行的调用
+ * debouncedSearch.cancel()
+ * ```
+ */
+export declare function debounce<T extends (...args: never[]) => void>(fn: T, delay: number, immediate?: boolean): DebouncedFunction<T>;
+/**
+ * 创建节流函数
+ *
+ * 在指定时间间隔内最多执行一次函数
+ *
+ * @template T - 函数类型
+ * @param fn - 需要节流的函数
+ * @param interval - 间隔时间（毫秒）
+ * @param options - 节流选项
+ * @param options.leading - 是否在时间窗开始时立即执行
+ * @param options.trailing - 是否在时间窗结束时补执行最后一次调用
+ * @returns 节流后的函数
+ *
+ * @example
+ * ```typescript
+ * const throttledUpdate = throttle((x: number, y: number) => {
+ *   updatePosition(x, y)
+ * }, 100)
+ *
+ * // 在 100ms 内多次调用，只会执行一次
+ * window.addEventListener('mousemove', (e) => {
+ *   throttledUpdate(e.clientX, e.clientY)
+ * })
+ *
+ * // 取消
+ * throttledUpdate.cancel()
+ * ```
+ */
+export declare function throttle<T extends (...args: never[]) => void>(fn: T, interval: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): ThrottledFunction<T>;
+//# sourceMappingURL=debounce-throttle.d.ts.map

package/esm/utils/debounce-throttle.js

@@ -0,0 +1,86 @@
+/*!
+* ***********************************
+* @composy/store-core v0.0.1      *
+* Built with rollup               *
+* Build time: 2024-08-17 11:27:33 *
+* Build mode: production          *
+* Minified: No                    *
+* ***********************************
+*/
+//#region src/utils/debounce-throttle.ts
+function debounce(fn, delay, immediate = false) {
+	let timer = null;
+	let lastArgs = null;
+	const debounced = ((...args) => {
+		lastArgs = args;
+		if (timer) clearTimeout(timer);
+		if (immediate && !timer) {
+			fn(...args);
+			timer = setTimeout(() => {
+				timer = null;
+				lastArgs = null;
+			}, delay);
+		} else timer = setTimeout(() => {
+			fn(...args);
+			timer = null;
+			lastArgs = null;
+		}, delay);
+	});
+	debounced.cancel = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+			lastArgs = null;
+		}
+	};
+	debounced.flush = () => {
+		if (timer && lastArgs) {
+			clearTimeout(timer);
+			fn(...lastArgs);
+			timer = null;
+			lastArgs = null;
+		}
+	};
+	debounced.pending = () => timer !== null;
+	return debounced;
+}
+function throttle(fn, interval, options = {}) {
+	const { leading = true, trailing = true } = options;
+	let timer = null;
+	let lastTime = 0;
+	let lastArgs = null;
+	const throttled = ((...args) => {
+		const now = Date.now();
+		const remaining = interval - (now - lastTime);
+		lastArgs = args;
+		if (remaining <= 0 || remaining > interval) {
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			lastTime = now;
+			if (leading || lastTime !== 0) fn(...args);
+			lastArgs = null;
+		} else if (!timer && trailing) timer = setTimeout(() => {
+			lastTime = trailing ? Date.now() : 0;
+			timer = null;
+			if (lastArgs) {
+				fn(...lastArgs);
+				lastArgs = null;
+			}
+		}, remaining);
+	});
+	throttled.cancel = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		lastTime = 0;
+		lastArgs = null;
+	};
+	return throttled;
+}
+//#endregion
+export { debounce, throttle };
+/*! End of @composy/store-core | Powered by @composy/builder */
+//# sourceMappingURL=debounce-throttle.js.map

package/esm/utils/debounce-throttle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce-throttle.js","names":[],"sources":["../../src/utils/debounce-throttle.ts"],"sourcesContent":["/**\n * 防抖和节流工具函数\n *\n * 提供性能优化的防抖、节流功能\n * @module utils/debounce-throttle\n */\n\n/**\n * 防抖函数返回类型\n */\nexport interface DebouncedFunction<T extends (...args: never[]) => void> {\n  (...args: Parameters<T>): void\n  /** 取消待执行的调用 */\n  cancel: () => void\n  /** 立即执行待处理的调用 */\n  flush: () => void\n  /** 是否有待处理的调用 */\n  pending: () => boolean\n}\n\n/**\n * 节流函数返回类型\n */\nexport interface ThrottledFunction<T extends (...args: never[]) => void> {\n  (...args: Parameters<T>): void\n  /** 取消待执行的调用 */\n  cancel: () => void\n}\n\n/**\n * 创建防抖函数\n *\n * 在连续调用停止后，延迟指定时间执行函数\n *\n * @template T - 函数类型\n * @param fn - 需要防抖的函数\n * @param delay - 延迟时间（毫秒）\n * @param immediate - 是否在首次调用时立即执行\n * @returns 防抖后的函数\n *\n * @example\n * ```typescript\n * const debouncedSearch = debounce((query: string) => {\n *   fetchResults(query)\n * }, 300)\n *\n * // 连续调用只会在最后一次调用后 300ms 执行\n * debouncedSearch('a')\n * debouncedSearch('ab')\n * debouncedSearch('abc') // 只有这次会触发\n *\n * // 取消待执行的调用\n * debouncedSearch.cancel()\n * ```\n */\nexport function debounce<T extends (...args: never[]) => void>(\n  fn: T,\n  delay: number,\n  immediate = false,\n): DebouncedFunction<T> {\n  let timer: ReturnType<typeof setTimeout> | null = null\n  let lastArgs: Parameters<T> | null = null\n\n  const debounced = ((...args: Parameters<T>) => {\n    lastArgs = args\n\n    if (timer) {\n      clearTimeout(timer)\n    }\n\n    if (immediate && !timer) {\n      fn(...args)\n      timer = setTimeout(() => {\n        timer = null\n        lastArgs = null\n      }, delay)\n    }\n    else {\n      timer = setTimeout(() => {\n        fn(...args)\n        timer = null\n        lastArgs = null\n      }, delay)\n    }\n  }) as DebouncedFunction<T>\n\n  debounced.cancel = () => {\n    if (timer) {\n      clearTimeout(timer)\n      timer = null\n      lastArgs = null\n    }\n  }\n\n  debounced.flush = () => {\n    if (timer && lastArgs) {\n      clearTimeout(timer)\n      fn(...lastArgs)\n      timer = null\n      lastArgs = null\n    }\n  }\n\n  debounced.pending = () => timer !== null\n\n  return debounced\n}\n\n/**\n * 创建节流函数\n *\n * 在指定时间间隔内最多执行一次函数\n *\n * @template T - 函数类型\n * @param fn - 需要节流的函数\n * @param interval - 间隔时间（毫秒）\n * @param options - 节流选项\n * @param options.leading - 是否在时间窗开始时立即执行\n * @param options.trailing - 是否在时间窗结束时补执行最后一次调用\n * @returns 节流后的函数\n *\n * @example\n * ```typescript\n * const throttledUpdate = throttle((x: number, y: number) => {\n *   updatePosition(x, y)\n * }, 100)\n *\n * // 在 100ms 内多次调用，只会执行一次\n * window.addEventListener('mousemove', (e) => {\n *   throttledUpdate(e.clientX, e.clientY)\n * })\n *\n * // 取消\n * throttledUpdate.cancel()\n * ```\n */\nexport function throttle<T extends (...args: never[]) => void>(\n  fn: T,\n  interval: number,\n  options: { leading?: boolean, trailing?: boolean } = {},\n): ThrottledFunction<T> {\n  const { leading = true, trailing = true } = options\n  let timer: ReturnType<typeof setTimeout> | null = null\n  let lastTime = 0\n  let lastArgs: Parameters<T> | null = null\n\n  const throttled = ((...args: Parameters<T>) => {\n    const now = Date.now()\n    const remaining = interval - (now - lastTime)\n\n    lastArgs = args\n\n    if (remaining <= 0 || remaining > interval) {\n      if (timer) {\n        clearTimeout(timer)\n        timer = null\n      }\n      lastTime = now\n      if (leading || lastTime !== 0) {\n        fn(...args)\n      }\n      lastArgs = null\n    }\n    else if (!timer && trailing) {\n      timer = setTimeout(() => {\n        lastTime = trailing ? Date.now() : 0\n        timer = null\n        if (lastArgs) {\n          fn(...lastArgs)\n          lastArgs = null\n        }\n      }, remaining)\n    }\n  }) as ThrottledFunction<T>\n\n  throttled.cancel = () => {\n    if (timer) {\n      clearTimeout(timer)\n      timer = null\n    }\n    lastTime = 0\n    lastArgs = null\n  }\n\n  return throttled\n}\n"],"mappings":";;;;;;;;;;AAuDO,SAAS,SACd,IACA,OACA,YAAY,OACU;CACtB,IAAI,QAA8C;CAClD,IAAI,WAAiC;CAErC,MAAM,cAAa,GAAI,SAAwB;EAC7C,WAAW;EAEX,IAAI,OACF,aAAa,KAAK;EAGpB,IAAI,aAAa,CAAC,OAAO;GACvB,GAAG,GAAG,IAAI;GACV,QAAQ,iBAAiB;IACvB,QAAQ;IACR,WAAW;GACb,GAAG,KAAK;EACV,OAEE,QAAQ,iBAAiB;GACvB,GAAG,GAAG,IAAI;GACV,QAAQ;GACR,WAAW;EACb,GAAG,KAAK;CAEZ;CAEA,UAAU,eAAe;EACvB,IAAI,OAAO;GACT,aAAa,KAAK;GAClB,QAAQ;GACR,WAAW;EACb;CACF;CAEA,UAAU,cAAc;EACtB,IAAI,SAAS,UAAU;GACrB,aAAa,KAAK;GAClB,GAAG,GAAG,QAAQ;GACd,QAAQ;GACR,WAAW;EACb;CACF;CAEA,UAAU,gBAAgB,UAAU;CAEpC,OAAO;AACT;AA8BO,SAAS,SACd,IACA,UACA,UAAqD,CAAC,GAChC;CACtB,MAAM,EAAE,UAAU,MAAM,WAAW,SAAS;CAC5C,IAAI,QAA8C;CAClD,IAAI,WAAW;CACf,IAAI,WAAiC;CAErC,MAAM,cAAa,GAAI,SAAwB;EAC7C,MAAM,MAAM,KAAK,IAAI;EACrB,MAAM,YAAY,YAAY,MAAM;EAEpC,WAAW;EAEX,IAAI,aAAa,KAAK,YAAY,UAAU;GAC1C,IAAI,OAAO;IACT,aAAa,KAAK;IAClB,QAAQ;GACV;GACA,WAAW;GACX,IAAI,WAAW,aAAa,GAC1B,GAAG,GAAG,IAAI;GAEZ,WAAW;EACb,OAAA,IACS,CAAC,SAAS,UACjB,QAAQ,iBAAiB;GACvB,WAAW,WAAW,KAAK,IAAI,IAAI;GACnC,QAAQ;GACR,IAAI,UAAU;IACZ,GAAG,GAAG,QAAQ;IACd,WAAW;GACb;EACF,GAAG,SAAS;CAEhB;CAEA,UAAU,eAAe;EACvB,IAAI,OAAO;GACT,aAAa,KAAK;GAClB,QAAQ;EACV;EACA,WAAW;EACX,WAAW;CACb;CAEA,OAAO;AACT"}

package/esm/utils/deep-clone.d.ts

@@ -0,0 +1,143 @@
+/**
+ * 深拷贝工具
+ *
+ * 提供高性能的深拷贝、浅拷贝和深度合并功能
+ * @module utils/deep-clone
+ */
+/**
+ * 判断是否为对象
+ *
+ * @param value - 待检查的值
+ * @returns 是否为对象
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * 判断是否为普通对象（非数组、非内置对象）
+ *
+ * @param value - 待检查的值
+ * @returns 是否为普通对象
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * 深拷贝配置选项
+ */
+export interface DeepCloneOptions {
+    /** 是否优先使用 structuredClone（默认 true） */
+    useStructuredClone?: boolean;
+    /** 是否克隆函数（默认 false，函数保持引用） */
+    cloneFunctions?: boolean;
+    /** 是否克隆 Symbol 属性（默认 false） */
+    cloneSymbols?: boolean;
+    /** 最大深度（默认无限制） */
+    maxDepth?: number;
+    /** 自定义克隆器 */
+    customCloner?: <T>(value: T, clone: <U>(v: U) => U) => T | undefined;
+}
+/**
+ * 深拷贝
+ *
+ * 高性能深拷贝实现，优先使用原生 structuredClone（如果可用）
+ *
+ * @template T - 值类型
+ * @param value - 要拷贝的值
+ * @param options - 配置选项
+ * @returns 拷贝后的值
+ *
+ * @example
+ * ```typescript
+ * const obj = { a: 1, b: { c: 2 } }
+ * const cloned = deepClone(obj)
+ * cloned.b.c = 3
+ * console.log(obj.b.c) // 2
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // 带配置的深拷贝
+ * const cloned = deepClone(obj, {
+ *   maxDepth: 5,
+ *   cloneSymbols: true
+ * })
+ * ```
+ */
+export declare function deepClone<T>(value: T, options?: DeepCloneOptions): T;
+/**
+ * 浅拷贝
+ *
+ * @template T - 值类型
+ * @param value - 要拷贝的值
+ * @returns 拷贝后的值
+ *
+ * @example
+ * ```typescript
+ * const arr = [1, 2, { a: 3 }]
+ * const cloned = shallowClone(arr)
+ * cloned[2].a = 4
+ * console.log(arr[2].a) // 4 (浅拷贝，嵌套对象共享引用)
+ * ```
+ */
+export declare function shallowClone<T>(value: T): T;
+/**
+ * 深度合并配置选项
+ */
+export interface DeepMergeOptions {
+    /** 数组合并策略：'replace' 替换 | 'concat' 连接 | 'merge' 按索引合并 */
+    arrayStrategy?: 'replace' | 'concat' | 'merge';
+    /** 是否克隆源对象（默认 true） */
+    clone?: boolean;
+    /** 最大深度 */
+    maxDepth?: number;
+}
+/**
+ * 深度合并对象
+ *
+ * 将多个源对象深度合并到目标对象
+ *
+ * @template T - 目标对象类型
+ * @param target - 目标对象
+ * @param sources - 源对象列表
+ * @returns 合并后的对象
+ *
+ * @example
+ * ```typescript
+ * const target = { a: 1, b: { c: 2 } }
+ * const source = { b: { d: 3 }, e: 4 }
+ * const result = deepMerge(target, source)
+ * // { a: 1, b: { c: 2, d: 3 }, e: 4 }
+ * ```
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(target: T, ...sources: Array<Partial<T>>): T;
+/**
+ * 带配置的深度合并
+ *
+ * @template T - 目标对象类型
+ * @param target - 目标对象
+ * @param options - 合并配置
+ * @param sources - 源对象列表
+ * @returns 合并后的对象
+ */
+export declare function deepMergeWithOptions<T extends Record<string, unknown>>(target: T, options: DeepMergeOptions, ...sources: Array<Partial<T>>): T;
+/**
+ * 比较两个值是否深度相等
+ *
+ * @param a - 第一个值
+ * @param b - 第二个值
+ * @returns 是否相等
+ *
+ * @example
+ * ```typescript
+ * deepEqual({ a: 1 }, { a: 1 }) // true
+ * deepEqual([1, 2], [1, 2]) // true
+ * deepEqual({ a: { b: 1 } }, { a: { b: 2 } }) // false
+ * ```
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * 冻结对象（深度）
+ *
+ * @template T - 对象类型
+ * @param obj - 要冻结的对象
+ * @returns 冻结后的对象
+ */
+export declare function deepFreeze<T extends object>(obj: T): Readonly<T>;
+//# sourceMappingURL=deep-clone.d.ts.map