@codady/utils 0.0.10 → 0.0.12

package/src/deepMergeMaps.ts

@@ -0,0 +1,67 @@
+/**
+ * @since Last modified: 2025/12/25 08:22:06
+ * @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 _target = result.get(key),
+                    _source = value,
+                    resp = deepMergeHelper(_target, _source, 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, _source);
+                } 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
+                options.propAppend && result.set(key, value);
+            }
+        });
+
+        return result;
+    }
+}
+
+export default deepMergeMaps;

package/src/deepMergeObjects.js

@@ -0,0 +1,89 @@
+/**
+ * @since Last modified: 2025/12/25 08:21:18
+ * @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 (resp.type) {
+                    if (resp.type === 'Object') {
+                        //如果遇上对象则深度复制
+                        result[k] = resp.result;
+                    }
+                }
+                else {
+                    //其他清空则直接覆盖
+                    result[k] = source[k];
+                }
+            }
+        }
+        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,91 @@
+/**
+ * @since Last modified: 2025/12/25 08:21:18
+ * @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 (resp.type) {
+                    if (resp.type === 'Object') {
+                        //如果遇上对象则深度复制
+                        (result as any)[k] = resp.result;
+                    }
+                } else {
+                    //其他清空则直接覆盖
+                    (result as any)[k] = source[k];
+                }
+            }
+
+        } 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,43 @@
+/**
+ * @since Last modified: 2025/12/25 08:10:14
+ * @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 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
+        const _result = [...result], _source = [...source], resp = deepMergeHelper(_result, _source, opts);
+        result.clear();
+        for (let item of resp.result)
+            result.add(item);
+        return result;
+    }
+};
+export default deepMergeSets;

package/src/deepMergeSets.ts

@@ -0,0 +1,52 @@
+/**
+ * @since Last modified: 2025/12/25 08:10:14
+ * @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
+        const _result = [...result],
+            _source = [...source],
+            resp = deepMergeHelper(_result, _source, opts);
+        result.clear();
+        for (let item of resp.result) result.add(item);
+        return result;
+    }
+}
+
+export default deepMergeSets;

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

@@ -0,0 +1,5 @@
+/**
+ * Available Map mutation methods
+ */
+export const mapMutableMethods = ['set', 'delete', 'clear'];
+export default mapMutableMethods;

package/src/shallowCopy.js

@@ -0,0 +1,46 @@
+/**
+ * @since Last modified: 2025/12/25 12:07:26
+ * shallowCopy
+ *
+ * This function performs a shallow copy of various data structures:
+ * - Set
+ * - Map
+ * - Array
+ * - Plain Object (including properties with Symbol keys)
+ *
+ * It returns a new instance of the data structure, but the elements or properties of reference types (such as objects or arrays) will be copied by reference.
+ * Primitive types (e.g., number, string, boolean) will be returned directly.
+ */
+'use strict';
+import getDataType from "./getDataType";
+const shallowCopy = (data) => {
+    const dataType = getDataType(data);
+    // Check if data is a Set
+    if (dataType === 'Set') {
+        // Shallow copy Set
+        return new Set([...data]);
+    }
+    // Check if data is a Map
+    if (dataType === 'Map') {
+        // Shallow copy Map
+        return new Map([...data]);
+    }
+    // Check if data is an Array
+    if (Array.isArray(data)) {
+        // Shallow copy Array
+        return [...data];
+    }
+    // Check if data is a Plain Object (including Symbol keys)
+    if (dataType === 'object') {
+        const obj = data; // Ensure the object type includes string and symbol keys
+        const symbolProperties = Object.getOwnPropertySymbols(obj).reduce((acc, sym) => {
+            acc[sym] = obj[sym];
+            return acc;
+        }, {});
+        // Shallow copy the object and include the Symbol properties
+        return { ...obj, ...symbolProperties };
+    }
+    // For other types (such as numbers, strings, booleans, etc.), return the original value
+    return data;
+};
+export default shallowCopy;

package/src/shallowCopy.ts

@@ -0,0 +1,55 @@
+/**
+ * @since Last modified: 2025/12/25 12:07:26
+ * shallowCopy
+ * 
+ * This function performs a shallow copy of various data structures:
+ * - Set
+ * - Map
+ * - Array
+ * - Plain Object (including properties with Symbol keys)
+ * 
+ * It returns a new instance of the data structure, but the elements or properties of reference types (such as objects or arrays) will be copied by reference.
+ * Primitive types (e.g., number, string, boolean) will be returned directly.
+ */
+'use strict';
+
+import getDataType from "./getDataType";
+
+const shallowCopy = (data: any): any => {
+    const dataType = getDataType(data);
+
+    // Check if data is a Set
+    if (dataType === 'Set') {
+        // Shallow copy Set
+        return new Set([...data]);
+    }
+
+    // Check if data is a Map
+    if (dataType === 'Map') {
+        // Shallow copy Map
+        return new Map([...data]);
+    }
+
+    // Check if data is an Array
+    if (Array.isArray(data)) {
+        // Shallow copy Array
+        return [...data];
+    }
+
+    // Check if data is a Plain Object (including Symbol keys)
+    if (dataType === 'object') {
+        const obj = data as { [key: string | symbol]: any }; // Ensure the object type includes string and symbol keys
+        const symbolProperties = Object.getOwnPropertySymbols(obj).reduce((acc: { [key: symbol]: any }, sym: symbol) => {
+            acc[sym] = obj[sym];
+            return acc;
+        }, {});
+
+        // Shallow copy the object and include the Symbol properties
+        return { ...obj, ...symbolProperties };
+    }
+
+    // For other types (such as numbers, strings, booleans, etc.), return the original value
+    return data;
+};
+
+export default shallowCopy;