@codady/utils 0.0.39 → 0.0.40

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

@@ -1,78 +0,0 @@
-/**
- * @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/escapeHTML - /345/211/257/346/234/254.js"

@@ -1,29 +0,0 @@
-/**
- * @function escapeHTML
- * @description Escapes HTML characters in a string to prevent XSS attacks.
- * This function replaces special characters such as <, >, &, ", ', etc. with their corresponding HTML entities.
- *
- * @param {string} str - The input string to be escaped.
- * @returns {string} - The escaped string with special HTML characters replaced by HTML entities.
- *
- * @example
- * escapeHTML("<div>Hello & 'world'</div>");
- * // returns "&lt;div&gt;Hello &amp; &#39;world&#39;&lt;/div&gt;"
- */
-export const escapeHTML = (str) => {
-    // Mapping of HTML special characters to their corresponding HTML entities
-    const escapes = {
-        '&': '&amp;',
-        '<': '&lt;',
-        '>': '&gt;',
-        '"': '&quot;',
-        "'": '&#39;',
-        '`': '&#96;',
-        '=': '&#61;',
-        '/': '&#47;'
-    };
-    // Replace each special character in the input string with its corresponding HTML entity
-    return str.replace(/[&<>"'`=\/]/g, (match) => {
-        return escapes[match];
-    });
-};

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

@@ -1,38 +0,0 @@
-/**
- * @since Last modified: 2025/12/16 09:00:41
- * @function getDataType
- * @description Get object type.Can detect object types such as Array, Object, Function,
- * Window，Location，History，Navigator，XMLHttpRequest， WebSocket,FileReader,MediaStream
- * Class , String, Number, Boolean, Date, Symbol ,File ,Blob,
- * Error,Promise,ArrayBuffer,TypedArray, Set, weakSet, Map, weakMap, Null, Undefined,
- * Text, DocumentFragment,Comment, XMLDocument, ProcessingInstruction, Range, TreeWalker,
- * NodeIterator,SVGSVGElement,MathMLElement, HTMLxxxElement (Dom nodes all contain HTML),Promise,AsyncFunction and Instance.
- * @param {*} obj - Can be any object
- * @returns {string} - Returns the name of the data type.
- */
-'use strict';
-const getDataType = (obj) => {
-    let tmp = Object.prototype.toString.call(obj).slice(8, -1), result;
-    if (tmp === 'Function' && /^\s*class\s+/.test(obj.toString())) {
-        result = 'Class';
-    }
-    else if (tmp === 'Object' && Object.getPrototypeOf(obj) !== Object.prototype) {
-        result = 'Instance';
-    }
-    else {
-        result = tmp;
-    }
-    return result;
-    //document.createElement -> HTMLxxxElement
-    //document.createDocumentFragment() -> DocumentFragment
-    //document.createComment() -> Comment
-    //document.createTextNode -> Text
-    //document.createCDATASection() -> XMLDocument
-    //document.createProcessingInstruction() -> ProcessingInstruction
-    //document.createRange() -> Range
-    //document.createTreeWalker() -> TreeWalker
-    //document.createNodeIterator() -> NodeIterator
-    //document.createElementNS('http://www.w3.org/2000/svg', 'svg'); -> SVGSVGElement
-    //document.createElementNS('http://www.w3.org/1998/Math/MathML', 'math'); -> MathMLElement
-};
-export default getDataType;

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

@@ -1,45 +0,0 @@
-/**
- * @since Last modified: 2025/12/25 14:22:26
- * @function isEmpty
- * @description Determine whether it is empty data.The data itself is empty data: 0| ''|false|undefined|null; <br>empty function: function () {}|() => {}; <br>empty array and empty objects: []|{}| [null]| [ undefined]| ['']| [""];<br> empty symbol object: symbol()|symbol.For(), will be judged as empty.
- * @param {*} data  - Can be any data
- * @returns {boolean}  - Return true or false
- * @example
- * ax.isEmpty([null]);
- * <!--return true-->
- */
-//简介：判断是否为空数据。本身为空的数据：0|''|false|undefined|null；空函数：function(){}|()=>{}；空数组和空对象：[]|{}|[null]|[undefined]|['']|[""]；空Symbol对象：Symbol()|Symbol.for()，都将判断为空。
-//返回：true或false
-'use strict';
-import getDataType from './getDataType';
-const isEmpty = (data) => {
-    let type = getDataType(data), flag;
-    if (!data) {
-        //0,'',false,undefined,null
-        flag = true;
-    }
-    else {
-        //function(){}|()=>{}
-        //[null]|[undefined]|['']|[""]
-        //[]|{}
-        //Symbol()|Symbol.for()
-        //Set,Map
-        //Date/Regex
-        flag = (type === 'Object') ? (Object.keys(data).length === 0) :
-            (type === 'Array') ? data.join('') === '' :
-                (type === 'Function') ? (data.toString().replace(/\s+/g, '').match(/{.*}/g)[0] === '{}') :
-                    (type === 'Symbol') ? (data.toString().replace(/\s+/g, '').match(/\(.*\)/g)[0] === '()') :
-                        (type === 'Set' || type === 'Map') ? data.size === 0 :
-                            type === 'Date' ? isNaN(data.getTime()) :
-                                type === 'RegExp' ? data.source === '' :
-                                    type === 'ArrayBuffer' ? data.byteLength === 0 :
-                                        (type === 'NodeList' || type === 'HTMLCollection') ? data.length === 0 :
-                                            ('length' in data && typeof data.length === 'number') ? data.length === 0 :
-                                                ('size' in data && typeof data.size === 'number') ? data.size === 0 :
-                                                    (type === 'Error' || data instanceof Error) ? data.message === '' :
-                                                        (type.includes('Array') && (['Uint8Array', 'Int8Array', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array'].includes(type))) ? data.length === 0 :
-                                                            false;
-    }
-    return flag;
-};
-export default isEmpty;

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

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

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

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

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

@@ -1,119 +0,0 @@
-/**
- * @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;