@codady/utils 0.0.9 → 0.0.11

package/src/deepEqual.js

@@ -0,0 +1,48 @@
+/**
+ * @since Last modified: 2025/12/24 17:11:15
+ * @function deepEqual
+ * @description Compares two values for deep equality. This function checks whether the values are deeply equal, meaning that if the values are objects or arrays, their properties or items are recursively compared. If they are primitive types, a direct comparison is performed.
+ * It supports comparison for arrays, objects, and primitive types (like numbers, strings, booleans, etc.). The comparison is done by value, not by reference.
+ *
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns {boolean} `true` if the values are deeply equal, otherwise `false`.
+ *
+ * @example
+ * deepEqual([1, 2, 3], [1, 2, 3]); // returns true
+ * deepEqual([1, 2, 3], [3, 2, 1]); // returns false
+ * deepEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // returns true
+ * deepEqual({ a: 1, b: 2 }, { a: 1, b: 3 }); // returns false
+ * deepEqual(5, 5); // returns true
+ * deepEqual('hello', 'hello'); // returns true
+ * deepEqual(5, '5'); // returns false
+ */
+const deepEqual = (a, b) => {
+    // If both are equal by reference
+    if (a === b)
+        return true;
+    // If both are arrays, check equality recursively
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    // If both are objects, check equality recursively
+    if (typeof a === 'object' && typeof b === 'object') {
+        const keysA = Object.keys(a), keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (let key of keysA) {
+            if (!keysB.includes(key) || !deepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    // For other types, direct comparison
+    return a === b;
+};
+export default deepEqual;

package/src/deepEqual.ts

@@ -0,0 +1,46 @@
+/**
+ * @since Last modified: 2025/12/24 17:11:15
+ * @function deepEqual
+ * @description Compares two values for deep equality. This function checks whether the values are deeply equal, meaning that if the values are objects or arrays, their properties or items are recursively compared. If they are primitive types, a direct comparison is performed.
+ * It supports comparison for arrays, objects, and primitive types (like numbers, strings, booleans, etc.). The comparison is done by value, not by reference.
+ * 
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns {boolean} `true` if the values are deeply equal, otherwise `false`.
+ * 
+ * @example
+ * deepEqual([1, 2, 3], [1, 2, 3]); // returns true
+ * deepEqual([1, 2, 3], [3, 2, 1]); // returns false
+ * deepEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // returns true
+ * deepEqual({ a: 1, b: 2 }, { a: 1, b: 3 }); // returns false
+ * deepEqual(5, 5); // returns true
+ * deepEqual('hello', 'hello'); // returns true
+ * deepEqual(5, '5'); // returns false
+ */
+const deepEqual = (a: any, b: any): boolean => {
+    // If both are equal by reference
+    if (a === b) return true;
+
+    // If both are arrays, check equality recursively
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!deepEqual(a[i], b[i])) return false;
+        }
+        return true;
+    }
+
+    // If both are objects, check equality recursively
+    if (typeof a === 'object' && typeof b === 'object') {
+        const keysA = Object.keys(a), keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) return false;
+        for (let key of keysA) {
+            if (!keysB.includes(key) || !deepEqual(a[key], b[key])) return false;
+        }
+        return true;
+    }
+
+    // For other types, direct comparison
+    return a === b;
+}
+export default deepEqual;

package/src/deepMerge.js

@@ -0,0 +1,34 @@
+/**
+ * @since Last modified: 2025/12/24 17:21:45
+ * @function deepMerge
+ * @description Deeply merges two data structures (Object, Array, Map, or Set) based on their types.
+ * This function recursively merges the properties or items of the target and source, depending on their types.
+ * If the types of target and source do not match, the target will be returned unchanged.
+ * @param target The target data structure to merge into (can be Object, Array, Map, or Set).
+ * @param source The source data structure to merge from (can be Object, Array, Map, or Set).
+ * @param opts Configuration options for merging. The default options include:
+ *  - `itemMode`: Specifies the merging mode (`'merge'`, `'replace'`, or `'concat'`).
+ *  - `propAppend`: Whether to append properties from the source if they do not exist in the target.
+ *  - `targetClone`: Whether to clone the target before merging (if true, the target is not modified).
+ *  - `useEnable`: Some special handling for specific objects that have `enable` properties.
+ *  - `useSymbol`: Whether to merge symbol properties.
+ * @returns The deeply merged target data structure.
+ * @example
+ * let x = { a: 'man', b: 0, c: [] };
+ * let y = { a: 'woman', b: 2, d: 'new' };
+ * const merged = deepMerge(x, y, { itemMode: 'merge', propAppend: true });
+ * // Returns { a: 'woman', b: 2, c: [], d: 'new' }
+ */
+'use strict';
+import deepMergeHelper from './deepMergeHelper';
+const deepMerge = (target, source, opts = {}) => {
+    // Get the data types of the target and source
+    let options = Object.assign({
+        itemMode: 'merge', // Default merge mode
+        propAppend: true, // Default to appending properties from source to target
+        targetClone: false, // Do not clone target by default
+        useEnable: true // Enable special handling for objects with an `enable` property
+    }, opts);
+    return deepMergeHelper(target, source, options);
+};
+export default deepMerge;

package/src/deepMerge.ts

@@ -0,0 +1,40 @@
+/**
+ * @since Last modified: 2025/12/24 17:21:45
+ * @function deepMerge
+ * @description Deeply merges two data structures (Object, Array, Map, or Set) based on their types.
+ * This function recursively merges the properties or items of the target and source, depending on their types.
+ * If the types of target and source do not match, the target will be returned unchanged.
+ * @param target The target data structure to merge into (can be Object, Array, Map, or Set).
+ * @param source The source data structure to merge from (can be Object, Array, Map, or Set).
+ * @param opts Configuration options for merging. The default options include:
+ *  - `itemMode`: Specifies the merging mode (`'merge'`, `'replace'`, or `'concat'`).
+ *  - `propAppend`: Whether to append properties from the source if they do not exist in the target.
+ *  - `targetClone`: Whether to clone the target before merging (if true, the target is not modified).
+ *  - `useEnable`: Some special handling for specific objects that have `enable` properties.
+ *  - `useSymbol`: Whether to merge symbol properties.
+ * @returns The deeply merged target data structure.
+ * @example
+ * let x = { a: 'man', b: 0, c: [] };
+ * let y = { a: 'woman', b: 2, d: 'new' };
+ * const merged = deepMerge(x, y, { itemMode: 'merge', propAppend: true });
+ * // Returns { a: 'woman', b: 2, c: [], d: 'new' }
+ */
+'use strict';
+import getDataType from './getDataType';
+import deepMergeObjects from './deepMergeObjects';
+import deepMergeArrays, { DeepMergeOptions } from './deepMergeArrays';
+import deepMergeMaps from './deepMergeMaps';
+import deepMergeSets from './deepMergeSets';
+import deepMergeHelper from './deepMergeHelper';
+const deepMerge = (target: Object | Array<any> | Map<any, any> | Set<any>, source: any, opts: DeepMergeOptions = {}): Object | Array<any> | Map<any, any> | Set<any> => {
+    // Get the data types of the target and source
+    let options = Object.assign({
+            itemMode: 'merge', // Default merge mode
+            propAppend: true,  // Default to appending properties from source to target
+            targetClone: false, // Do not clone target by default
+            useEnable: true // Enable special handling for objects with an `enable` property
+        }, opts);
+
+   return deepMergeHelper(target,source,options);
+}
+export default deepMerge;

package/src/deepMergeArrays.js

@@ -0,0 +1,45 @@
+/**
+ * @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 deepMergeHelper from './deepMergeHelper';
+const deepMergeArrays = (target, source, options = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }) => {
+    // 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/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;