@gx-design-vue/pro-utils 0.2.0-beta.80 → 0.2.0-beta.81

package/dist/cloneDeep/cloneDeepWith.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Deeply clones the given object.
+ *
+ * You can customize the deep cloning process using the `cloneValue` function.
+ * The function takes the current value `value`, the property name `key`, and the entire object `obj` as arguments.
+ * If the function returns a value, that value is used;
+ * if it returns `undefined`, the default cloning method is used.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @param {Function} [cloneValue] - A function to customize the cloning process.
+ * @returns {T} - A deep clone of the given object.
+ *
+ * @example
+ * // Clone a primitive value
+ * const num = 29;
+ * const clonedNum = cloneDeepWith(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num); // true
+ *
+ * @example
+ * // Clone an object with a customizer
+ * const obj = { a: 1, b: 2 };
+ * const clonedObj = cloneDeepWith(obj, (value) => {
+ *   if (typeof value === 'number') {
+ *     return value * 2; // Double the number
+ *   }
+ * });
+ * console.log(clonedObj); // { a: 2, b: 4 }
+ * console.log(clonedObj === obj); // false
+ *
+ * @example
+ * // Clone an array with a customizer
+ * const arr = [1, 2, 3];
+ * const clonedArr = cloneDeepWith(arr, (value) => {
+ *   return value + 1; // Increment each value
+ * });
+ * console.log(clonedArr); // [2, 3, 4]
+ * console.log(clonedArr === arr); // false
+ */
+export declare function cloneDeepWith<T>(obj: T, cloneValue: (value: any, key: PropertyKey | undefined, obj: T, stack: Map<any, any>) => any): T;
+export declare function cloneDeepWithImpl<T>(valueToClone: any, keyToClone: PropertyKey | undefined, objectToClone: T, stack?: Map<any, any>, cloneValue?: ((value: any, key: PropertyKey | undefined, obj: T, stack: Map<any, any>) => any) | undefined): T;
+export declare function copyProperties<T>(target: any, source: any, objectToClone?: T, stack?: Map<any, any> | undefined, cloneValue?: ((value: any, key: PropertyKey | undefined, obj: T, stack: Map<any, any>) => any) | undefined): void;

package/dist/cloneDeep/index.d.ts

@@ -10,7 +10,7 @@
  * const num = 29;
  * const clonedNum = clone(num);
  * console.log(clonedNum); // 29
- * console.log(clonedNum === num) ; // true
+ * console.log(clonedNum === num); // true
  *
  * @example
  * // Clone an array
@@ -45,4 +45,3 @@
  * console.log(clonedObj === obj); // false
  */
 export declare function cloneDeep<T>(obj: T): T;
-export declare function copyProperties(target: any, source: any, stack?: Map<any, any>): void;

package/dist/index.d.ts

@@ -7,12 +7,15 @@ import getScroll from './scroll/getScroll';
 import scrollTo from './scroll/scrollTo';
 import throttleByAnimationFrame from './scroll/throttleByAnimationFrame';
 export * from './cloneDeep';
+export * from './cloneDeep/cloneDeepWith';
 export * from './isBrowser';
 export * from './isDeepEqualReact';
 export * from './isImg';
 export * from './isNil';
 export * from './isUrl';
 export * from './merge';
+export * from './merge/mergeWith';
+export * from './merge/useDeepMege';
 export * from './nanoid';
 export * from './omitBoolean';
 export * from './omitUndefined';

package/dist/merge/index.d.ts

@@ -1,4 +1,3 @@
-import type { DeepPartial } from '../typings';
 /**
  * 用于合并 n 个对象
  * @param  {any[]} ...rest
@@ -6,18 +5,46 @@ import type { DeepPartial } from '../typings';
  */
 declare const merge: <T = any>(...rest: any[]) => T;
 /**
- * @Author      gx12358
- * @DateTime    2024/12/6
- * @lastTime    2024/12/6
- * @description 深度合并对象
- * @description target 目标值
- * @description source 合并值
- * @description options 参数配置
- * @description options - omitNil 去除空值
- * @description options - omitEmpty 去除空数组或对象
+ * Merges the properties of the source object into a deep clone of the target object.
+ * Unlike `merge`, This function does not modify the original target object.
+ *
+ * This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+ *
+ * - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+ * - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+ *
+ * Note that this function does not mutate the target object.
+ *
+ * @param {T} target - The target object to be cloned and merged into. This object is not modified directly.
+ * @param {S} source - The source object whose properties will be merged into the cloned target object.
+ * @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object.
+ *
+ * @template T - Type of the target object.
+ * @template S - Type of the source object.
+ *
+ * @example
+ * const target = { a: 1, b: { x: 1, y: 2 } };
+ * const source = { b: { y: 3, z: 4 }, c: 5 };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+ *
+ * @example
+ * const target = { a: [1, 2], b: { x: 1 } };
+ * const source = { a: [3], b: { y: 2 } };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+ *
+ * @example
+ * const target = { a: null };
+ * const source = { a: [1, 2, 3] };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [1, 2, 3] }
  */
-declare function deepMerge<T extends object>(target: T, source: DeepPartial<T>, options?: {
-    omitNil?: boolean;
-    omitEmpty?: boolean;
-}): T;
+declare function deepMerge<T extends Record<PropertyKey, any>, S extends Record<PropertyKey, any>>(target: T, source: S): T & S;
 export { deepMerge, merge };

package/dist/merge/mergeWith.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Merges the properties of the source object into the target object.
+ *
+ * You can provide a custom `merge` function to control how properties are merged. It should return the value to be set in the target object.
+ *
+ * If it returns `undefined`, a default deep merge will be applied for arrays and objects:
+ *
+ * - If a property in the source object is an array or an object and the corresponding property in the target object is also an array or object, they will be merged.
+ * - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+ *
+ * Note that this function mutates the target object.
+ *
+ * @param {T} target - The target object into which the source object properties will be merged. This object is modified in place.
+ * @param {S} source - The source object whose properties will be merged into the target object.
+ * @param {(targetValue: any, sourceValue: any, key: string, target: T, source: S) => any} merge - A custom merge function that defines how properties should be combined. It receives the following arguments:
+ *   - `targetValue`: The current value of the property in the target object.
+ *   - `sourceValue`: The value of the property in the source object.
+ *   - `key`: The key of the property being merged.
+ *   - `target`: The target object.
+ *   - `source`: The source object.
+ *
+ * @returns {T & S} The updated target object with properties from the source object merged in.
+ *
+ * @template T - Type of the target object.
+ * @template S - Type of the source object.
+ *
+ * @example
+ * const target = { a: 1, b: 2 };
+ * const source = { b: 3, c: 4 };
+ *
+ * mergeWith(target, source, (targetValue, sourceValue) => {
+ *   if (typeof targetValue === 'number' && typeof sourceValue === 'number') {
+ *     return targetValue + sourceValue;
+ *   }
+ * });
+ * // Returns { a: 1, b: 5, c: 4 }
+ * @example
+ * const target = { a: [1], b: [2] };
+ * const source = { a: [3], b: [4] };
+ *
+ * const result = mergeWith(target, source, (objValue, srcValue) => {
+ *   if (Array.isArray(objValue)) {
+ *     return objValue.concat(srcValue);
+ *   }
+ * });
+ *
+ * expect(result).toEqual({ a: [1, 3], b: [2, 4] });
+ */
+export declare function mergeWith<T extends Record<PropertyKey, any>, S extends Record<PropertyKey, any>>(target: T, source: S, merge: (targetValue: any, sourceValue: any, key: string, target: T, source: S) => any): T & S;

package/dist/merge/useDeepMege.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Merges the properties of the source object into a deep clone of the target object.
+ * Unlike `merge`, This function does not modify the original target object.
+ *
+ * This function performs a deep merge, meaning nested objects and arrays are merged recursively.
+ *
+ * - If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.
+ * - If a property in the source object is undefined, it will not overwrite a defined property in the target object.
+ *
+ * Note that this function does not mutate the target object.
+ *
+ * @param {T} target - The target object to be cloned and merged into. This object is not modified directly.
+ * @param {S} source - The source object whose properties will be merged into the cloned target object.
+ * @returns {T & S} A new object with properties from the source object merged into a deep clone of the target object.
+ *
+ * @template T - Type of the target object.
+ * @template S - Type of the source object.
+ *
+ * @example
+ * const target = { a: 1, b: { x: 1, y: 2 } };
+ * const source = { b: { y: 3, z: 4 }, c: 5 };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: 1, b: { x: 1, y: 3, z: 4 }, c: 5 }
+ *
+ * @example
+ * const target = { a: [1, 2], b: { x: 1 } };
+ * const source = { a: [3], b: { y: 2 } };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [3, 2], b: { x: 1, y: 2 } }
+ *
+ * @example
+ * const target = { a: null };
+ * const source = { a: [1, 2, 3] };
+ *
+ * const result = toMerged(target, source);
+ * console.log(result);
+ * // Output: { a: [1, 2, 3] }
+ */
+export declare function useDeepMerge<T extends Record<PropertyKey, any>, S extends Record<PropertyKey, any>>(target: T, source: S): T & S;