@codady/utils 0.0.10 → 0.0.11

package/src/deepMergeArrays.ts

@@ -0,0 +1,62 @@
+/**
+ * @since Last modified: 2025/12/24 17:49:40
+ * @function deepMergeArrays
+ * Deeply merges two arrays, with flexible options to replace, concatenate, or merge items.
+ * @param target The target array to merge into
+ * @param source The source array to merge from
+ * @param options Configuration options for merging
+ * @returns The deeply merged array
+ */
+
+'use strict';
+import getDataType from './getDataType';
+import deepClone from './deepClone';
+import deepMergeObjects from './deepMergeObjects';
+import deepMergeSets from './deepMergeSets';
+import deepMergeMaps from './deepMergeMaps';
+import deepMergeHelper from './deepMergeHelper';
+
+// Define options for deep merging
+export interface DeepMergeOptions {
+    itemMode?: 'merge' | 'replace' | 'concat'; // Mode for handling array items
+    propAppend?: boolean; // Whether to append properties (for objects)
+    targetClone?: boolean; // Whether to clone the target array
+    useEnable?: boolean,//如果target={enable:true},source=false,那么将输出target={enable:false}
+    useSymbol?: boolean,//合并对象中是否处理key=symbol
+}
+
+const deepMergeArrays = (target: any[], source: any[], options: DeepMergeOptions = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }): any[] => {
+    // Ensure both target and source are arrays
+    if (!Array.isArray(target) || !Array.isArray(source)) return target;
+
+    // Merge options, with default values
+    const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false }, options),
+
+        // If cloning is enabled, create a deep copy of the target array
+        result = opts.targetClone ? [...target] : target;
+
+    // Handle different merge strategies based on itemMode
+    if (opts.itemMode === 'replace') {
+        // Replace mode: clear the target array and push all items from the source array
+        result.length = 0;
+        result.push(...source);
+        return result;
+    } else if (opts.itemMode === 'concat') {
+        // Concatenate mode: append all items from the source array to the target array
+        result.push(...source);
+        return result;
+    } else {
+        // Default "merge" mode: recursively merge items in the arrays
+        for (let i = 0; i < source.length; i++) {
+            let resp = deepMergeHelper(result[i], source[i], opts);
+            //resp={result,flag,type}
+            //flag=true表示类型一致并完成了合并，false表示并没有合并需要直接赋值
+            if (!resp.flag) {
+                result[i] = source[i];
+            }
+        }
+        return result;
+    }
+}
+
+export default deepMergeArrays;

package/src/deepMergeHelper.js

@@ -0,0 +1,40 @@
+// deepMergeHelper.ts
+/**
+ * @description A helper function for deeply merging different types of values (Object, Array, Map, Set).
+ * This function is used by other deep merge functions to handle recursive merging of different types.
+ */
+import deepMergeObjects from './deepMergeObjects';
+import deepMergeArrays from './deepMergeArrays';
+import deepMergeMaps from './deepMergeMaps';
+import deepMergeSets from './deepMergeSets';
+import getDataType from './getDataType';
+/**
+ * Deep merge values based on their types (Object, Array, Set, Map).
+ */
+const deepMergeHelper = (target, source, options) => {
+    let targetType = getDataType(target), sourceType = getDataType(source), flag = true, type, result;
+    if (targetType === 'Object' && sourceType === 'Object') {
+        result = deepMergeObjects(target, source, options);
+        type = 'Object';
+    }
+    else if (targetType === 'Array' && sourceType === 'Array') {
+        result = deepMergeArrays(target, source, options);
+        type = 'Array';
+    }
+    else if (targetType === 'Set' && sourceType === 'Set') {
+        result = deepMergeSets(target, source, options);
+        type = 'Set';
+    }
+    else if (targetType === 'Map' && sourceType === 'Map') {
+        result = deepMergeMaps(target, source, options);
+        type = 'Map';
+    }
+    else {
+        flag = false;
+        result = target; // Default case, replace primitive values
+    }
+    return {
+        result, flag, type
+    };
+};
+export default deepMergeHelper;

package/src/deepMergeHelper.ts

@@ -0,0 +1,45 @@
+// deepMergeHelper.ts
+/**
+ * @description A helper function for deeply merging different types of values (Object, Array, Map, Set).
+ * This function is used by other deep merge functions to handle recursive merging of different types.
+ */
+
+import deepMergeObjects from './deepMergeObjects';
+import deepMergeArrays from './deepMergeArrays';
+import deepMergeMaps from './deepMergeMaps';
+import deepMergeSets from './deepMergeSets';
+import { DeepMergeOptions } from './deepMergeArrays';
+import getDataType from './getDataType';
+
+/**
+ * Deep merge values based on their types (Object, Array, Set, Map).
+ */
+const deepMergeHelper = (target: any, source: any, options: DeepMergeOptions): any => {
+    let targetType = getDataType(target),
+        sourceType = getDataType(source),
+        flag = true,
+        type,
+        result;
+
+    if (targetType === 'Object' && sourceType === 'Object') {
+        result = deepMergeObjects(target, source, options);
+        type = 'Object';
+    } else if (targetType === 'Array' && sourceType === 'Array') {
+        result = deepMergeArrays(target, source, options);
+        type = 'Array';
+    } else if (targetType === 'Set' && sourceType === 'Set') {
+        result = deepMergeSets(target, source, options);
+        type = 'Set';
+    } else if (targetType === 'Map' && sourceType === 'Map') {
+        result = deepMergeMaps(target, source, options);
+        type = 'Map';
+    } else {
+        flag = false;
+        result = target; // Default case, replace primitive values
+    }
+    return {
+        result, flag,type
+    };
+}
+
+export default deepMergeHelper;

package/src/deepMergeMaps - /345/211/257/346/234/254.js"

@@ -0,0 +1,78 @@
+/**
+ * @since Last modified: 2025/12/24 17:05:22
+ * @function deepMergeMaps
+ * Deeply merges two Maps, with flexible options to replace, concatenate, or merge entries.
+ * @param target The target Map to merge into
+ * @param source The source Map to merge from
+ * @param options Configuration options for merging
+ * @returns The deeply merged Map
+ */
+'use strict';
+import getDataType from './getDataType';
+import deepMergeObjects from './deepMergeObjects';
+import deepMergeArrays from './deepMergeArrays';
+import deepMergeSets from './deepMergeSets';
+const deepMergeMaps = (target, source, options = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }) => {
+    // Ensure both target and source are Maps
+    if (!(target instanceof Map) || !(source instanceof Map))
+        return target;
+    // Merge options, with default values
+    const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, options), 
+    // If cloning is enabled, create a deep copy of the target Map
+    result = opts.targetClone ? new Map(target) : target;
+    // Handle different merge strategies based on itemMode
+    if (opts.itemMode === 'replace') {
+        // Replace mode: clear the target Map and add all entries from the source Map
+        result.clear();
+        source.forEach((value, key) => result.set(key, value));
+        return result;
+    }
+    else if (opts.itemMode === 'concat') {
+        // Concatenate mode: add all entries from the source Map to the target Map
+        source.forEach((value, key) => result.set(key, value));
+        return result;
+    }
+    else {
+        // Default "merge" mode: recursively merge entries in the Maps
+        source.forEach((value, key) => {
+            // Check if the key already exists in the target Map
+            if (result.has(key)) {
+                const targetValue = result.get(key), sourceValue = value;
+                const targetType = getDataType(targetValue), sourceType = getDataType(sourceValue);
+                // If both target and source values are of the same type, merge them
+                if (targetType === sourceType) {
+                    if (targetType === 'Object') {
+                        // If both target and source are objects, merge them recursively
+                        result.set(key, deepMergeObjects(targetValue, sourceValue, opts));
+                    }
+                    else if (targetType === 'Array') {
+                        // If both target and source are arrays, merge them recursively
+                        deepMergeArrays(targetValue, sourceValue, opts);
+                    }
+                    else if (targetType === 'Map') {
+                        // If both target and source are Maps, merge them recursively
+                        deepMergeMaps(targetValue, sourceValue, opts);
+                    }
+                    else if (targetType === 'Set') {
+                        // If both target and source are Sets, merge them recursively
+                        deepMergeSets(targetValue, sourceValue, opts);
+                    }
+                    else {
+                        // For simple values, overwrite the target value with the source value
+                        result.set(key, sourceValue);
+                    }
+                }
+                else {
+                    // If types don't match, overwrite the target value with the source value
+                    result.set(key, sourceValue);
+                }
+            }
+            else {
+                // If the key doesn't exist in the target, add the entry from the source Map
+                result.set(key, value);
+            }
+        });
+        return result;
+    }
+};
+export default deepMergeMaps;

package/src/deepMergeMaps.js

@@ -0,0 +1,57 @@
+/**
+ * @since Last modified: 2025/12/24 17:48:20
+ * @function deepMergeMaps
+ * Deeply merges two Maps, with flexible options to replace, concatenate, or merge entries.
+ * @param target The target Map to merge into
+ * @param source The source Map to merge from
+ * @param options Configuration options for merging
+ * @returns The deeply merged Map
+ */
+'use strict';
+import deepMergeHelper from './deepMergeHelper';
+const deepMergeMaps = (target, source, options = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }) => {
+    // Ensure both target and source are Maps
+    if (!(target instanceof Map) || !(source instanceof Map))
+        return target;
+    // Merge options, with default values
+    const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, options), 
+    // If cloning is enabled, create a deep copy of the target Map
+    result = opts.targetClone ? new Map(target) : target;
+    // Handle different merge strategies based on itemMode
+    if (opts.itemMode === 'replace') {
+        // Replace mode: clear the target Map and add all entries from the source Map
+        result.clear();
+        source.forEach((value, key) => result.set(key, value));
+        return result;
+    }
+    else if (opts.itemMode === 'concat') {
+        // Concatenate mode: add all entries from the source Map to the target Map
+        source.forEach((value, key) => result.set(key, value));
+        return result;
+    }
+    else {
+        // Default "merge" mode: recursively merge entries in the Maps
+        source.forEach((value, key) => {
+            // Check if the key already exists in the target Map
+            if (result.has(key)) {
+                const targetValue = result.get(key), sourceValue = value, resp = deepMergeHelper(targetValue, sourceValue, opts);
+                //resp={result,flag,type}
+                //flag=true表示类型一致并完成了合并，false表示并没有合并需要直接赋值
+                if (!resp.flag) {
+                    // For simple values, overwrite the target value with the source value
+                    result.set(key, sourceValue);
+                }
+                else {
+                    // If both target and source are objects, merge them recursively
+                    resp.type === 'Object' && result.set(key, resp.result);
+                }
+            }
+            else {
+                // If the key doesn't exist in the target, add the entry from the source Map
+                result.set(key, value);
+            }
+        });
+        return result;
+    }
+};
+export default deepMergeMaps;

package/src/deepMergeMaps.ts

@@ -0,0 +1,67 @@
+/**
+ * @since Last modified: 2025/12/24 17:48:20
+ * @function deepMergeMaps
+ * Deeply merges two Maps, with flexible options to replace, concatenate, or merge entries.
+ * @param target The target Map to merge into
+ * @param source The source Map to merge from
+ * @param options Configuration options for merging
+ * @returns The deeply merged Map
+ */
+
+'use strict';
+
+import getDataType from './getDataType';
+import deepMergeObjects from './deepMergeObjects';
+import deepMergeArrays, { DeepMergeOptions } from './deepMergeArrays';
+import deepMergeSets from './deepMergeSets';
+import deepEqual from './deepEqual';
+import deepMergeHelper from './deepMergeHelper';
+
+const deepMergeMaps = (target: Map<any, any>, source: Map<any, any>, options: DeepMergeOptions = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }): Map<any, any> => {
+    // Ensure both target and source are Maps
+    if (!(target instanceof Map) || !(source instanceof Map)) return target;
+
+    // Merge options, with default values
+    const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, options),
+
+        // If cloning is enabled, create a deep copy of the target Map
+        result = opts.targetClone ? new Map(target) : target;
+
+    // Handle different merge strategies based on itemMode
+    if (opts.itemMode === 'replace') {
+        // Replace mode: clear the target Map and add all entries from the source Map
+        result.clear();
+        source.forEach((value, key) => result.set(key, value));
+        return result;
+    } else if (opts.itemMode === 'concat') {
+        // Concatenate mode: add all entries from the source Map to the target Map
+        source.forEach((value, key) => result.set(key, value));
+        return result;
+    } else {
+        // Default "merge" mode: recursively merge entries in the Maps
+        source.forEach((value, key) => {
+            // Check if the key already exists in the target Map
+            if (result.has(key)) {
+                const targetValue = result.get(key),
+                    sourceValue = value,
+                    resp = deepMergeHelper(targetValue, sourceValue, opts);
+                //resp={result,flag,type}
+                //flag=true表示类型一致并完成了合并，false表示并没有合并需要直接赋值
+                if (!resp.flag) {
+                    // For simple values, overwrite the target value with the source value
+                    result.set(key, sourceValue);
+                } else {
+                    // If both target and source are objects, merge them recursively
+                    resp.type === 'Object' && result.set(key, resp.result);
+                }
+            } else {
+                // If the key doesn't exist in the target, add the entry from the source Map
+                result.set(key, value);
+            }
+        });
+
+        return result;
+    }
+}
+
+export default deepMergeMaps;

package/src/deepMergeObjects.js

@@ -0,0 +1,82 @@
+/**
+ * @since Last modified: 2025/12/24 17:46:42
+ * @function deepMergeObjects
+ * @description Merge two objects. The key name of Source is allowed to be the Symbol type, and the Symbol key name of the source will be added directly to the target.
+ * @param {Object} target  - The original target of the merge.
+ * @param {Object} source  - The object that will merge into the target.
+ * @param {DeepMergeOptions} [opts]  - Parameters used for merging objects.
+ * @param {boolean} [opts.arrAppend=false]  - If value is an array, whether to append or override.
+ * @param {boolean} [opts.propAppend=true]  - Whether to append properties from source to target if not already present.
+ * @param {boolean} [opts.targetClone=false]  - Whether to clone the target object, if true, the original target will not be changed.
+ * @param {boolean} [opts.useEnable=true]  - Whether to merge enable property.
+ * @param {boolean} [opts.useSymbol=true]  - Whether to merge symbol properties.
+ * @returns {Object} - The merged object.
+ * @example
+ * let x ={a:'man',b:0,c:[]}, b={a:'woman',b:2};
+ * deepMergeObjects(x, b);
+ * // Returns {a:'woman', b:2, c:[]}
+ */
+'use strict';
+import getDataType from './getDataType';
+import deepClone from './deepClone';
+import deepMergeHelper from './deepMergeHelper';
+const deepMergeObjects = (target, source, opts = {}) => {
+    let targetType = getDataType(target), sourceType = getDataType(source);
+    //target不是对象或者source为空则直接返回
+    if (targetType !== 'Object' || sourceType !== 'Object') {
+        return target;
+    }
+    const options = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, opts), 
+    //如果是复制方法，则先复制target
+    result = options.targetClone ? deepClone(target) : target;
+    for (let k in source) {
+        if (source.hasOwnProperty(k) && result.hasOwnProperty(k)) {
+            let resp = deepMergeHelper(result[k], source[k], opts);
+            //resp={result,flag,type}
+            //flag=true表示类型一致并完成了合并，false表示并没有合并需要直接赋值
+            if (!resp.flag) {
+                //类型不同则直接覆盖
+                if (options.useEnable && result.hasOwnProperty(k) && result[k]?.hasOwnProperty('enable') && typeof source[k] === 'boolean') {
+                    //部分替换，仅针对result={enable:true/false,a:''}，source=false/true这种情况和相反的情况，因为这种情况再笨框架比较多见  
+                    if (result[k]?.hasOwnProperty('enable') && typeof source[k] === 'boolean') {
+                        //result={enable:true,a:'',b:''},source[k]=false=>result={enable:false,a:'',b:''}
+                        result[k].enable = source[k];
+                    }
+                    else if (source[k]?.hasOwnProperty('enable') && typeof result[k] === 'boolean') {
+                        //source={enable:true,a:'',b:''},(result as any)[k]=false=>result={enable:false,a:'',b:''}
+                        result = Object.assign({ enable: result[k] }, source[k]);
+                    }
+                    else {
+                        //完全替换
+                        result[k] = source[k];
+                    }
+                }
+                else {
+                    //完全替换
+                    result[k] = source[k];
+                }
+            }
+            else {
+                // If both target and source are objects, merge them recursively
+                if (resp.type === 'Object') {
+                    result[k] = resp.result;
+                }
+            }
+        }
+        else if (source.hasOwnProperty(k) && !result.hasOwnProperty(k) && options.propAppend) {
+            //如果source有属性，result没有该属性，但是options允许追加属性则直接赋值
+            result[k] = source[k];
+        }
+    }
+    //Symbol键直接追加，因为Symbol是唯一，结果同Object.assign
+    if (options.useSymbol) {
+        let symbols = Object.getOwnPropertySymbols(source);
+        if (symbols.length > 0) {
+            for (let k of symbols) {
+                result[k] = source[k];
+            }
+        }
+    }
+    return result;
+};
+export default deepMergeObjects;

package/src/deepMergeObjects.ts

@@ -0,0 +1,85 @@
+/**
+ * @since Last modified: 2025/12/24 17:46:42
+ * @function deepMergeObjects
+ * @description Merge two objects. The key name of Source is allowed to be the Symbol type, and the Symbol key name of the source will be added directly to the target.
+ * @param {Object} target  - The original target of the merge.
+ * @param {Object} source  - The object that will merge into the target.
+ * @param {DeepMergeOptions} [opts]  - Parameters used for merging objects.
+ * @param {boolean} [opts.arrAppend=false]  - If value is an array, whether to append or override.
+ * @param {boolean} [opts.propAppend=true]  - Whether to append properties from source to target if not already present.
+ * @param {boolean} [opts.targetClone=false]  - Whether to clone the target object, if true, the original target will not be changed.
+ * @param {boolean} [opts.useEnable=true]  - Whether to merge enable property.
+ * @param {boolean} [opts.useSymbol=true]  - Whether to merge symbol properties.
+ * @returns {Object} - The merged object.
+ * @example
+ * let x ={a:'man',b:0,c:[]}, b={a:'woman',b:2};
+ * deepMergeObjects(x, b);
+ * // Returns {a:'woman', b:2, c:[]}
+ */
+'use strict';
+import getDataType from './getDataType';
+import deepClone from './deepClone';
+import deepMergeArrays, { DeepMergeOptions } from './deepMergeArrays';
+import deepMergeSets from './deepMergeSets';
+import deepMergeMaps from './deepMergeMaps';
+import deepMergeHelper from './deepMergeHelper';
+const deepMergeObjects = (target: Object, source: any, opts: DeepMergeOptions = {}): Object => {
+    let targetType = getDataType(target),
+        sourceType = getDataType(source);
+    //target不是对象或者source为空则直接返回
+    if (targetType !== 'Object' || sourceType !== 'Object') {
+        return target;
+    }
+
+    const options = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, opts),
+        //如果是复制方法，则先复制target
+        result = options.targetClone ? deepClone(target) : target;
+
+    for (let k in source) {
+        if (source.hasOwnProperty(k) && result.hasOwnProperty(k)) {
+
+            let resp = deepMergeHelper((result as any)[k], source[k], opts);
+            //resp={result,flag,type}
+            //flag=true表示类型一致并完成了合并，false表示并没有合并需要直接赋值
+            if (!resp.flag) {
+                //类型不同则直接覆盖
+                if (options.useEnable && result.hasOwnProperty(k) && (result as any)[k]?.hasOwnProperty('enable') && typeof source[k] === 'boolean') {
+                    //部分替换，仅针对result={enable:true/false,a:''}，source=false/true这种情况和相反的情况，因为这种情况再笨框架比较多见  
+                    if ((result as any)[k]?.hasOwnProperty('enable') && typeof source[k] === 'boolean') {
+                        //result={enable:true,a:'',b:''},source[k]=false=>result={enable:false,a:'',b:''}
+                        (result as any)[k].enable = source[k];
+                    } else if (source[k]?.hasOwnProperty('enable') && typeof (result as any)[k] === 'boolean') {
+                        //source={enable:true,a:'',b:''},(result as any)[k]=false=>result={enable:false,a:'',b:''}
+                        (result as any) = Object.assign({ enable: (result as any)[k] }, source[k]);
+                    } else {
+                        //完全替换
+                        (result as any)[k] = source[k];
+                    }
+                } else {
+                    //完全替换
+                    (result as any)[k] = source[k];
+                }
+            } else {
+                // If both target and source are objects, merge them recursively
+                if (resp.type === 'Object') {
+                    (result as any)[k] = resp.result;
+                }
+            }
+
+        } else if (source.hasOwnProperty(k) && !result.hasOwnProperty(k) && options.propAppend) {
+            //如果source有属性，result没有该属性，但是options允许追加属性则直接赋值
+            (result as any)[k] = source[k];
+        }
+    }
+    //Symbol键直接追加，因为Symbol是唯一，结果同Object.assign
+    if (options.useSymbol) {
+        let symbols = Object.getOwnPropertySymbols(source);
+        if (symbols.length > 0) {
+            for (let k of symbols) {
+                (result as any)[k] = source[k];
+            }
+        }
+    }
+    return result;
+}
+export default deepMergeObjects;

package/src/deepMergeSets.js

@@ -0,0 +1,48 @@
+/**
+ * @since Last modified: 2025/12/24 17:48:38
+ * @function deepMergeSets
+ * Deeply merges two Sets, with flexible options to replace, concatenate, or merge items.
+ * @param target The target Set to merge into
+ * @param source The source Set to merge from
+ * @param options Configuration options for merging
+ * @returns The deeply merged Set
+ */
+'use strict';
+import deepEqual from './deepEqual';
+import deepMergeHelper from './deepMergeHelper';
+const deepMergeSets = (target, source, options = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }) => {
+    // Ensure both target and source are Sets
+    if (!(target instanceof Set) || !(source instanceof Set))
+        return target;
+    // Merge options, with default values
+    const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, options), 
+    // If cloning is enabled, create a deep copy of the target Set
+    result = opts.targetClone ? new Set(target) : target;
+    // Handle different merge strategies based on itemMode
+    if (opts.itemMode === 'replace') {
+        // Replace mode: clear the target Set and add all items from the source Set
+        result.clear();
+        for (let item of source)
+            result.add(item);
+        return result;
+    }
+    else if (opts.itemMode === 'concat') {
+        // Concatenate mode: add all items from the source Set to the target Set
+        for (let item of source)
+            result.add(item);
+        return result;
+    }
+    else {
+        // Default "merge" mode: recursively merge items in the Sets
+        for (let item of source) {
+            // Check the type of the target and source items
+            let _target = [...result].find(val => deepEqual(val, item)), resp = deepMergeHelper(_target, item, opts);
+            //resp={result,flag}
+            //flag=true表示类型一致并完成了合并，false表示并没有合并需要直接赋值
+            !resp.flag && result.add(item);
+        }
+        ;
+        return result;
+    }
+};
+export default deepMergeSets;

package/src/deepMergeSets.ts

@@ -0,0 +1,55 @@
+/**
+ * @since Last modified: 2025/12/24 17:48:38
+ * @function deepMergeSets
+ * Deeply merges two Sets, with flexible options to replace, concatenate, or merge items.
+ * @param target The target Set to merge into
+ * @param source The source Set to merge from
+ * @param options Configuration options for merging
+ * @returns The deeply merged Set
+ */
+
+'use strict';
+
+import getDataType from './getDataType';
+import deepMergeObjects from './deepMergeObjects';
+import deepMergeArrays, { DeepMergeOptions } from './deepMergeArrays';
+import deepEqual from './deepEqual';
+import deepMergeMaps from './deepMergeMaps';
+import deepMergeHelper from './deepMergeHelper';
+
+
+const deepMergeSets = (target: Set<any>, source: Set<any>, options: DeepMergeOptions = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }): Set<any> => {
+    // Ensure both target and source are Sets
+    if (!(target instanceof Set) || !(source instanceof Set)) return target;
+
+    // Merge options, with default values
+    const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, options),
+
+        // If cloning is enabled, create a deep copy of the target Set
+        result = opts.targetClone ? new Set(target) : target;
+
+    // Handle different merge strategies based on itemMode
+    if (opts.itemMode === 'replace') {
+        // Replace mode: clear the target Set and add all items from the source Set
+        result.clear();
+        for (let item of source) result.add(item);
+        return result;
+    } else if (opts.itemMode === 'concat') {
+        // Concatenate mode: add all items from the source Set to the target Set
+        for (let item of source) result.add(item);
+        return result;
+    } else {
+        // Default "merge" mode: recursively merge items in the Sets
+        for (let item of source) {
+            // Check the type of the target and source items
+            let _target = [...result].find(val => deepEqual(val, item)),
+                resp = deepMergeHelper(_target, item, opts);
+            //resp={result,flag}
+            //flag=true表示类型一致并完成了合并，false表示并没有合并需要直接赋值
+            !resp.flag && result.add(item);
+        };
+        return result;
+    }
+}
+
+export default deepMergeSets;