@codady/utils 0.0.9 → 0.0.11

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;

package/src/getUniqueId.js

@@ -1,5 +1,5 @@
 /**
-* @since Last modified: 2025/12/19 15:18:57
+* @since Last modified: 2025/12/22 14:29:27
  * Generates a unique identifier string
  *
  * The ID format is: `[prefix_]timestamp_randomBase36_extraRandom`
@@ -13,23 +13,27 @@
  * 3. Additional 4-digit random number for extra entropy
  * 4. Optional prefix for categorization
  *
- * @param prefix - Optional prefix string for the ID (e.g., 'snax', 'user', 'doc')
- * @param extra - Optional 4-digit random number
+ * @param options.prefix - Optional prefix string for the ID (e.g., 'snax', 'user', 'doc')
+ * @param options.suffix - Optional suffix string for the ID (e.g., 'snax', 'user', 'doc')
+ * @param options.base10 - Optional 4-digit random number
+ * @param options.base36 - Optional 9-digit random charactor
  * @returns A unique identifier string
  */
-export const getUniqueId = (prefix, extra = true) => {
+export const getUniqueId = (options = {}) => {
+    const prefix = options.prefix, suffix = options.suffix, base10 = options.base10, base36 = options.base36;
     // Current timestamp in milliseconds (since Unix epoch)
     // This provides the primary uniqueness guarantee
     const timestamp = Date.now(), 
     // Generate a base-36 random string (0-9, a-z)
     // Math.random() returns a number in [0, 1), converting to base-36 gives a compact representation
     // substring(2, 11) extracts 9 characters starting from index 2
-    random = Math.random().toString(36).substring(2, 11), 
+    //0.259854635->0.9crs03e8v2
+    base36Random = base36 ? '-' + Math.random().toString(36).substring(2, 11) : '', 
     // Additional 4-digit random number for extra randomness
     // This helps avoid collisions in high-frequency generation scenarios
-    extraRandom = extra ? '_' + Math.floor(Math.random() * 10000).toString().padStart(4, '0') : '', prefixString = prefix ? prefix + '_' : '';
+    base10Random = base10 ? '-' + Math.floor(Math.random() * 10000).toString().padStart(4, '0') : '', prefixString = prefix ? prefix + '-' : '', suffixString = suffix ? '-' + suffix : '';
     // Construct the final ID string
     // Format: [prefix_]timestamp_randomBase36_extraRandom
-    return `${prefixString}${timestamp}_${random}${extraRandom}`;
+    return `${prefixString}${timestamp}${base36Random}${base10Random}${suffixString}`;
 };
 export default getUniqueId;

package/src/getUniqueId.ts

@@ -1,5 +1,5 @@
 /**
-* @since Last modified: 2025/12/19 15:18:57
+* @since Last modified: 2025/12/22 14:29:27
  * Generates a unique identifier string
  * 
  * The ID format is: `[prefix_]timestamp_randomBase36_extraRandom`
@@ -13,11 +13,17 @@
  * 3. Additional 4-digit random number for extra entropy
  * 4. Optional prefix for categorization
  * 
- * @param prefix - Optional prefix string for the ID (e.g., 'snax', 'user', 'doc')
- * @param extra - Optional 4-digit random number
+ * @param options.prefix - Optional prefix string for the ID (e.g., 'snax', 'user', 'doc')
+ * @param options.suffix - Optional suffix string for the ID (e.g., 'snax', 'user', 'doc')
+ * @param options.base10 - Optional 4-digit random number
+ * @param options.base36 - Optional 9-digit random charactor
  * @returns A unique identifier string
  */
-export const getUniqueId = (prefix?: string, extra = true): string => {
+export const getUniqueId = (options: { prefix?: string, suffix?: string, base10?: boolean,base36?: boolean } = {}): string => {
+    const prefix = options.prefix,
+        suffix = options.suffix,
+        base10 = options.base10,
+        base36 = options.base36;
     // Current timestamp in milliseconds (since Unix epoch)
     // This provides the primary uniqueness guarantee
     const timestamp = Date.now(),
@@ -25,16 +31,17 @@ export const getUniqueId = (prefix?: string, extra = true): string => {
         // Generate a base-36 random string (0-9, a-z)
         // Math.random() returns a number in [0, 1), converting to base-36 gives a compact representation
         // substring(2, 11) extracts 9 characters starting from index 2
-        random = Math.random().toString(36).substring(2, 11),
-
+        //0.259854635->0.9crs03e8v2
+        base36Random = base36?'-' +Math.random().toString(36).substring(2, 11):'',
         // Additional 4-digit random number for extra randomness
         // This helps avoid collisions in high-frequency generation scenarios
-        extraRandom = extra ? '_' + Math.floor(Math.random() * 10000).toString().padStart(4, '0') : '',
-        prefixString = prefix ? prefix + '_' : '';
+        base10Random = base10 ? '-' + Math.floor(Math.random() * 10000).toString().padStart(4, '0') : '',
+        prefixString = prefix ? prefix + '-' : '',
+        suffixString = suffix ? '-' + suffix : '';
 
     // Construct the final ID string
     // Format: [prefix_]timestamp_randomBase36_extraRandom
-    return `${prefixString}${timestamp}_${random}${extraRandom}`;
+    return `${prefixString}${timestamp}${base36Random}${base10Random}${suffixString}`;
 };
 
 export default getUniqueId;

package/src/mapMutableMethods.js

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

package/src/mapMutableMethods.ts

@@ -0,0 +1,15 @@
+/**
+ * @since Last modified: 2025/12/22 17:16:39
+ * 
+ */
+/**
+ * Available mutation methods for Map objects
+ */
+export type MapMutationNames = 'set' | 'delete' | 'clear';
+
+/**
+ * Available Map mutation methods
+ */
+export const mapMutableMethods: MapMutationNames[] = ['set', 'delete', 'clear'];
+
+export default mapMutableMethods;

package/src/mutableMethods.js

@@ -1,5 +1,5 @@
-const mutableMethods = [
+const arrayMutableMethods = [
     'push', 'pop', 'shift', 'unshift', 'splice',
     'sort', 'reverse', 'copyWithin', 'fill'
 ];
-export default mutableMethods;
+export default arrayMutableMethods;

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

@@ -0,0 +1,5 @@
+/**
+ * Available Set mutation methods
+ */
+export const setMutableMethods = ['add', 'delete', 'clear'];
+export default setMutableMethods;

package/src/setMutableMethods.js

@@ -0,0 +1,5 @@
+/**
+ * Available Set mutation methods
+ */
+export const setMutableMethods = ['add', 'delete', 'clear'];
+export default setMutableMethods;

package/src/setMutableMethods.ts

@@ -0,0 +1,14 @@
+/**
+ * @since Last modified: 2025/12/22 17:15:21
+ * 
+ */
+/**
+ * Available mutation methods for Set objects
+ */
+export type SetMutationNames = 'add' | 'delete' | 'clear';
+/**
+ * Available Set mutation methods
+ */
+export const setMutableMethods: SetMutationNames[] = ['add', 'delete', 'clear'];
+
+export default setMutableMethods;

package/src/wrapArrayMethods.js

@@ -1,5 +1,5 @@
 /**
- * @since Last modified: 2025/12/19 10:14:03
+ * @since Last modified: 2025/12/22 17:14:00
  * Mutates an array by applying one of the allowed mutation methods such as push, pop, shift, unshift, splice, etc.
  * Supports tracking of added, removed, and updated items for undo/redo or tracking purposes.
  * The mutation methods that can be tracked include push, pop, shift, unshift, splice, sort, reverse, fill, and copyWithin.
@@ -18,7 +18,7 @@
  * methods.push(4); // arr is now [1, 2, 3, 4]
  */
 'use strict';
-import mutableMethods from "./mutableMethods";
+import arrayMutableMethods from "./arrayMutableMethods";
 const wrapArrayMethods = ({ target, onBeforeMutate = () => { }, onAfterMutate = () => { }, allowList, props = {}, }) => {
     // Validation: Ensure target is an array and method is allowed
     if (!Array.isArray(target)) {
@@ -26,7 +26,7 @@ const wrapArrayMethods = ({ target, onBeforeMutate = () => { }, onAfterMutate =
     }
     //使用默认
     if (!allowList || allowList?.length) {
-        allowList = mutableMethods;
+        allowList = arrayMutableMethods;
     }
     const methods = {};
     for (let method of allowList) {
@@ -42,10 +42,10 @@ const wrapArrayMethods = ({ target, onBeforeMutate = () => { }, onAfterMutate =
                     context.addedItems = [...args];
                     break;
                 case 'pop':
-                    context.poppedValue = target[len - 1];
+                    context.poppedItem = target[len - 1];
                     break;
                 case 'shift':
-                    context.shiftedValue = target[0];
+                    context.shiftedItem = target[0];
                     break;
                 case 'splice':
                     const [s, d] = args, 

package/src/wrapArrayMethods.ts

@@ -1,5 +1,5 @@
 /**
- * @since Last modified: 2025/12/19 10:14:03
+ * @since Last modified: 2025/12/22 17:14:00
  * Mutates an array by applying one of the allowed mutation methods such as push, pop, shift, unshift, splice, etc.
  * Supports tracking of added, removed, and updated items for undo/redo or tracking purposes.
  * The mutation methods that can be tracked include push, pop, shift, unshift, splice, sort, reverse, fill, and copyWithin.
@@ -19,7 +19,7 @@
  */
 'use strict';
 
-import mutableMethods, { ArrayMutationNames } from "./mutableMethods";
+import arrayMutableMethods, { ArrayMutationNames } from "./arrayMutableMethods";
 
 
 /**
@@ -27,8 +27,8 @@ import mutableMethods, { ArrayMutationNames } from "./mutableMethods";
  */
 export interface MutationContextt {
     addedItems?: any[];      // Items added to the array
-    poppedValue?: any;       // Value popped from the array
-    shiftedValue?: any;      // Value shifted from the array
+    poppedItem?: any;       // Value popped from the array
+    shiftedItem?: any;      // Value shifted from the array
     deletedItems?: any[];    // Items removed from the array
     oldSnapshot?: any[];     // Snapshot of the array before methods like 'sort' or 'reverse'
     oldItems?: any[];        // Items overwritten (for methods like 'fill' or 'copyWithin')
@@ -87,7 +87,7 @@ const wrapArrayMethods = <T = any>({
     }
     //使用默认
     if (!allowList || allowList?.length) {
-        allowList = mutableMethods;
+        allowList = arrayMutableMethods;
     }
 
     const methods: Partial<ArrayMutationMethods<T>> = {};
@@ -109,10 +109,10 @@ const wrapArrayMethods = <T = any>({
                     context.addedItems = [...args];
                     break;
                 case 'pop':
-                    context.poppedValue = target[len - 1];
+                    context.poppedItem = target[len - 1];
                     break;
                 case 'shift':
-                    context.shiftedValue = target[0];
+                    context.shiftedItem = target[0];
                     break;
                 case 'splice':
                     const [s, d] = args,

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

@@ -0,0 +1,119 @@
+/**
+ * @since Last modified: 2025/12/22 16:37:23
+ * Wraps Map objects with mutation tracking capabilities.
+ * Provides hooks for before/after mutation events and captures detailed context
+ * for undo/redo or change tracking purposes.
+ *
+ * @template K - Map key type
+ * @template V - Map value type
+ * @param {MapMutationOptions<K, V>} options - Configuration object containing target Map and callbacks
+ * @returns {MapMutationMethods<K, V>} - Object containing wrapped Map mutation methods
+ *
+ * @example
+ * // Basic usage with tracking
+ * const map = new Map([['key1', 'value1']]);
+ * const methods = wrapMap({
+ *   target: map,
+ *   onAfterMutate: (patch) => {
+ *     console.log(`Map ${patch.method} called`, patch.context);
+ *   }
+ * });
+ *
+ * methods.set('key2', 'value2'); // Tracked
+ * methods.delete('key1'); // Tracked
+ * methods.clear(); // Tracked
+ *
+ * @example
+ * // With undo/redo support
+ * const history: MapMutationPatch<any, any>[] = [];
+ * const map = new Map<string, number>();
+ *
+ * const methods = wrapMap({
+ *   target: map,
+ *   onBeforeMutate: (context) => {
+ *     console.log('Before mutation:', context);
+ *   },
+ *   onAfterMutate: (patch) => {
+ *     history.push(patch);
+ *     console.log('Mutation recorded:', patch.method, 'History size:', history.length);
+ *   }
+ * });
+ */
+'use strict';
+/**
+ * Available Map mutation methods
+ */
+export const mapMutableMethods = ['set', 'delete', 'clear'];
+/**
+ * Creates wrapped mutation methods for Map with tracking capabilities
+ *
+ * @param options Configuration options
+ * @returns Object containing wrapped Map mutation methods
+ * @throws TypeError if target is not a Map
+ */
+const wrapMap = ({ target, onBeforeMutate = () => { }, onAfterMutate = () => { }, allowList = mapMutableMethods, props = {}, }) => {
+    // Validation: Ensure target is a Map
+    if (!(target instanceof Map)) {
+        throw new TypeError("The 'target' parameter must be a Map.");
+    }
+    // Create method wrappers
+    const methods = {};
+    // Helper to create wrapped method
+    const createWrappedMethod = (method) => {
+        return function (...args) {
+            const context = {};
+            // Capture pre-mutation context based on method
+            switch (method) {
+                case 'set': {
+                    const [key, newValue] = args;
+                    context.key = key;
+                    context.newValue = newValue;
+                    context.hadKey = target.has(key);
+                    context.oldValue = context.hadKey ? target.get(key) : undefined;
+                    break;
+                }
+                case 'delete': {
+                    const [key] = args;
+                    context.key = key;
+                    context.existed = target.has(key);
+                    break;
+                }
+                case 'clear': {
+                    context.clearedEntries = Array.from(target.entries());
+                    context.previousSize = target.size;
+                    break;
+                }
+            }
+            // Execute before mutation callback
+            onBeforeMutate(context);
+            // Execute the native Map method
+            const result = target[method].apply(target, args);
+            // Construct patch object
+            const patch = {
+                method,
+                result,
+                args,
+                context,
+                target,
+                ...props
+            };
+            // Execute after mutation callback
+            onAfterMutate(patch);
+            return result;
+        };
+    };
+    // Wrap allowed methods
+    for (const method of allowList) {
+        if (mapMutableMethods.includes(method)) {
+            methods[method] = createWrappedMethod(method);
+        }
+    }
+    // Add target reference
+    Object.defineProperty(methods, 'target', {
+        get: () => target,
+        enumerable: false,
+        configurable: false
+    });
+    return methods;
+};
+export default wrapMap;

package/src/wrapMapMethods.js

@@ -0,0 +1,118 @@
+/**
+ * @since Last modified: 2025/12/22 17:19:32
+ * Wraps Map objects with mutation tracking capabilities.
+ * Provides hooks for before/after mutation events and captures detailed context
+ * for undo/redo or change tracking purposes.
+ *
+ * @template K - Map key type
+ * @template V - Map value type
+ * @param {MapMutationOptions<K, V>} options - Configuration object containing target Map and callbacks
+ * @returns {MapMutationMethods<K, V>} - Object containing wrapped Map mutation methods
+ *
+ * @example
+ * // Basic usage with tracking
+ * const map = new Map([['key1', 'value1']]);
+ * const methods = wrapMap({
+ *   target: map,
+ *   onAfterMutate: (patch) => {
+ *     console.log(`Map ${patch.method} called`, patch.context);
+ *   }
+ * });
+ *
+ * methods.set('key2', 'value2'); // Tracked
+ * methods.delete('key1'); // Tracked
+ * methods.clear(); // Tracked
+ *
+ * @example
+ * // With undo/redo support
+ * const history: MapMutationPatch<any, any>[] = [];
+ * const map = new Map<string, number>();
+ *
+ * const methods = wrapMap({
+ *   target: map,
+ *   onBeforeMutate: (context) => {
+ *     console.log('Before mutation:', context);
+ *   },
+ *   onAfterMutate: (patch) => {
+ *     history.push(patch);
+ *     console.log('Mutation recorded:', patch.method, 'History size:', history.length);
+ *   }
+ * });
+ */
+'use strict';
+import mapMutableMethods from "./mapMutableMethods";
+/**
+ * Creates wrapped mutation methods for Map with tracking capabilities
+ *
+ * @param options Configuration options
+ * @returns Object containing wrapped Map mutation methods
+ * @throws TypeError if target is not a Map
+ */
+const wrapMapMethods = ({ target, onBeforeMutate = () => { }, onAfterMutate = () => { }, allowList = mapMutableMethods, props = {}, }) => {
+    // Validation: Ensure target is a Map
+    if (!(target instanceof Map)) {
+        throw new TypeError("The 'target' parameter must be a Map.");
+    }
+    // Create method wrappers
+    const methods = {};
+    // Helper to create wrapped method
+    const createWrappedMethod = (method) => {
+        return function (...args) {
+            const context = {};
+            // Capture pre-mutation context based on method
+            switch (method) {
+                case 'set': {
+                    const [key, newValue] = args;
+                    context.key = key;
+                    context.newValue = newValue;
+                    context.existed = target.has(key);
+                    context.oldValue = context.existed ? target.get(key) : undefined;
+                    break;
+                }
+                case 'delete': {
+                    const [key] = args;
+                    context.key = key;
+                    context.existed = target.has(key);
+                    context.value = context.existed ? target.get(key) : undefined;
+                    break;
+                }
+                case 'clear': {
+                    context.clearedItems = Array.from(target.entries());
+                    //用来做验证
+                    context.previousSize = target.size;
+                    break;
+                }
+            }
+            // Execute before mutation callback
+            onBeforeMutate(context);
+            // Execute the native Map method
+            const result = target[method].apply(target, args);
+            // Construct patch object
+            const patch = {
+                method,
+                result,
+                args,
+                context,
+                target,
+                ...props
+            };
+            // Execute after mutation callback
+            onAfterMutate(patch);
+            return result;
+        };
+    };
+    // Wrap allowed methods
+    for (const method of allowList) {
+        if (mapMutableMethods.includes(method)) {
+            methods[method] = createWrappedMethod(method);
+        }
+    }
+    // Add target reference
+    Object.defineProperty(methods, 'target', {
+        get: () => target,
+        enumerable: false,
+        configurable: false
+    });
+    return methods;
+};
+export default wrapMapMethods;