@codady/utils 0.0.38 → 0.0.40

package/src/stringToEncodings.ts

@@ -0,0 +1,110 @@
+/**
+ * @since Last modified: 2026/02/05 15:12:33
+ * Generate a stable Unicode code point from a string.
+ * - Without registry: FNV-1a 64-bit hash mapping (fast, stateless)
+ * - With registry: Guaranteed zero-collision allocation
+ */
+export type StringEncodingResult = {
+  unicode: string;
+  htmlDec: string;
+  htmlHex: string;
+  hex: string;
+  codePoint: number;
+  hash: string;
+  name: string;
+  collision?: boolean;
+};
+
+export type StringEncodingOptions = {
+  start?: number;
+  end?: number;
+  registryMap?: Map<string, number>; // optional
+};
+
+
+const stringToEncodings = (
+  name: string,
+  options: StringEncodingOptions = {}
+): StringEncodingResult => {
+
+  // Default: Supplementary Private Use Area (Plane 15 and Plane 16)
+  //1,114,110 places,5000 strings => 0 collision
+  const start = options.start ?? 0xF0000,
+    end = options.end ?? 0x10FFFD,
+    range = BigInt(end - start + 1),
+    registry = options.registryMap,
+    /** Format result */
+    formatResult = (
+      name: string,
+      codePoint: number,
+      hash: string,
+      collision: boolean
+    ): StringEncodingResult => {
+      const hex = codePoint.toString(16).toUpperCase();
+
+      return {
+        name,
+        unicode: `U+${hex}`,
+        htmlDec: `&#${codePoint};`,
+        htmlHex: `&#x${hex};`,
+        hex,
+        codePoint,
+        hash,
+        collision,
+      };
+    };
+
+
+  // -----------------------------
+  // 1. Compute FNV-1a 64-bit hash
+  // -----------------------------
+  let hash = BigInt("0xcbf29ce484222325");
+  const prime = BigInt("0x100000001b3");
+
+  for (const ch of name) {
+    hash ^= BigInt(ch.codePointAt(0)!);
+    hash *= prime;
+  }
+
+  const hashHex = hash.toString(16).toUpperCase();
+
+  // -----------------------------
+  // 2. Stateless mode (no registry)
+  // -----------------------------
+  if (!registry) {
+    const offset = Number(hash % range),
+      codePoint = start + offset;
+    return formatResult(name, codePoint, hashHex, false);
+  }
+
+  // -----------------------------
+  // 3. Registry mode (0 collision)
+  // -----------------------------
+
+  // Already assigned → return stable mapping
+  if (registry.has(name)) {
+    return formatResult(name, registry.get(name)!, hashHex, false);
+  }
+
+  // Initial candidate from hash
+  let offset = Number(hash % range),
+    codePoint = start + offset,
+    collision = false;
+
+  const used = new Set(registry.values());
+
+  // Linear probing to resolve collisions
+  while (used.has(codePoint)) {
+    collision = true;
+    offset = (offset + 1) % Number(range);
+    codePoint = start + offset;
+  }
+
+  // Commit allocation
+  registry.set(name, codePoint);
+
+  return formatResult(name, codePoint, hashHex, collision);
+};
+
+
+export default stringToEncodings;

package/src/unicodeToEncodings.js

@@ -0,0 +1,51 @@
+/**
+ * @since Last modified: 2026/02/05 17:06:59
+ * Parses a Unicode input (string or number) and converts it into
+ * multiple encoding formats including Unicode notation, HTML entities,
+ * hexadecimal code, and decimal code point.
+ *
+ * Supported input formats:
+ * - Unicode string: "U+F123"
+ * - Hex string: "F123", "0xF123"
+ * - Decimal string: "61731"
+ * - Numeric code point: 61731
+ *
+ * This utility is useful for:
+ * - Icon font Unicode decoding
+ * - HTML entity generation
+ * - Unicode debugging and inspection
+ * - Glyph mapping and font tooling
+ * - PUA (Private Use Area) management workflows
+ *
+ * @param input - Unicode input as a string or numeric code point
+ * @returns An object containing Unicode, hex, decimal, and HTML encodings
+ * @throws Error if the input cannot be parsed into a valid Unicode code point
+ */
+const unicodeToEncodings = (input) => {
+    let codePoint;
+    if (typeof input === "number") {
+        codePoint = input;
+    }
+    else {
+        const cleaned = input.trim()
+            .replace(/^U\+/i, "")
+            .replace(/^0x/i, "");
+        codePoint = /^[0-9A-F]+$/i.test(cleaned)
+            ? parseInt(cleaned, 16)
+            : parseInt(cleaned, 10);
+    }
+    // Validate parsed code point
+    if (!Number.isFinite(codePoint)) {
+        throw new Error("Invalid Unicode input");
+    }
+    // Convert code point to uppercase hexadecimal representation
+    const hex = codePoint.toString(16).toUpperCase();
+    return {
+        unicode: `U+${hex}`,
+        hex,
+        codePoint,
+        htmlDec: `&#${codePoint};`,
+        htmlHex: `&#x${hex};`,
+    };
+};
+export default unicodeToEncodings;

package/src/unicodeToEncodings.ts

@@ -0,0 +1,55 @@
+/**
+ * @since Last modified: 2026/02/05 17:06:59
+ * Parses a Unicode input (string or number) and converts it into
+ * multiple encoding formats including Unicode notation, HTML entities,
+ * hexadecimal code, and decimal code point.
+ *
+ * Supported input formats:
+ * - Unicode string: "U+F123"
+ * - Hex string: "F123", "0xF123"
+ * - Decimal string: "61731"
+ * - Numeric code point: 61731
+ *
+ * This utility is useful for:
+ * - Icon font Unicode decoding
+ * - HTML entity generation
+ * - Unicode debugging and inspection
+ * - Glyph mapping and font tooling
+ * - PUA (Private Use Area) management workflows
+ *
+ * @param input - Unicode input as a string or numeric code point
+ * @returns An object containing Unicode, hex, decimal, and HTML encodings
+ * @throws Error if the input cannot be parsed into a valid Unicode code point
+ */
+const unicodeToEncodings = (input: string | number) => {
+  let codePoint: number;
+
+  if (typeof input === "number") {
+    codePoint = input;
+  } else {
+    const cleaned = input.trim()
+      .replace(/^U\+/i, "")
+      .replace(/^0x/i, "");
+
+    codePoint = /^[0-9A-F]+$/i.test(cleaned)
+      ? parseInt(cleaned, 16)
+      : parseInt(cleaned, 10);
+  }
+
+  // Validate parsed code point
+  if (!Number.isFinite(codePoint)) {
+    throw new Error("Invalid Unicode input");
+  }
+
+  // Convert code point to uppercase hexadecimal representation
+  const hex = codePoint.toString(16).toUpperCase();
+
+  return {
+    unicode: `U+${hex}`,
+    hex,
+    codePoint,
+    htmlDec: `&#${codePoint};`,
+    htmlHex: `&#x${hex};`,
+  };
+};
+export default unicodeToEncodings;

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

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

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

@@ -1,2 +0,0 @@
-const COMMA = ',';
-export default COMMA;

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

@@ -1,47 +0,0 @@
-/**
- * @since Last modified: 2025/12/16 14:43:51
- * Deep clone an array or object to a JSON-compatible structure.
- * Converts non-serializable types like functions, symbols, Date, RegExp to plain values.
- *
- * @template T
- * @param {T} data - Array or object to clone
- * @returns {T} - New object with different memory address, in a JSON-compatible structure
- *
- * @example
- * const obj = { a: '', b: 0, c: [] };
- * const cloned = deepCloneToJSON(obj);
- *
- * @example
- * const arr = [{}, {}, {}];
- * const cloned = deepCloneToJSON(arr);
- */
-'use strict';
-import getDataType from './getDataType';
-const deepCloneToJSON = (data) => {
-    const dataType = getDataType(data);
-    // Handle objects
-    if (dataType === 'Object') {
-        const newObj = {};
-        // Clone regular properties
-        for (const key in data) {
-            newObj[key] = deepCloneToJSON(data[key]);
-        }
-        for (const key in newObj) {
-            newObj[key] === undefined && Reflect.deleteProperty(newObj, key);
-        }
-        return newObj;
-        // Handle arrays
-    }
-    else if (dataType === 'Array') {
-        let tmp = data.map((item, index) => deepCloneToJSON(item)).filter(item => item !== undefined);
-        return tmp;
-        // Handle Date objects
-    }
-    else if (!['Number', 'String', 'Boolean', 'Null'].includes(dataType)) {
-        return undefined;
-    }
-    else {
-        return data;
-    }
-};
-export default deepCloneToJSON;

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;