@antscorp/antsomi-ui 2.0.82 → 2.0.83-text-editor-beta.1

package/es/utils/common.js

@@ -430,35 +430,56 @@ export function generateKey() {
 }
 export const formatUserId = (userId) => String(userId || '').replace(/(\d{3})(\d{3})(\d{0,})/, `$1-$2-$3`);
 /**
- * Function to remove accent
- * @param str - String want to remove accent
- * @returns {string} - Result after remove accent
+ * Normalizes a string for searching by:
+ * 1. Converting to NFD Unicode form and removing diacritics.
+ * 2. Converting to lowercase.
+ * 3. Removing all whitespace.
+ * @param str The string to normalize.
+ * @returns The normalized string.
  */
-export const removeAccent = (str) => {
-    str = str.replace(/[àáạảãâầấậẩẫăằắặẳẵ]/g, 'a');
-    str = str.replace(/[èéẹẻẽêềếệểễ]/g, 'e');
-    str = str.replace(/[ìíịỉĩ]/g, 'i');
-    str = str.replace(/[òóọỏõôồốộổỗơờớợởỡ]/g, 'o');
-    str = str.replace(/[ùúụủũưừứựửữ]/g, 'u');
-    str = str.replace(/[ỳýỵỷỹ]/g, 'y');
-    str = str.replace(/đ/g, 'd');
-    str = str.replace(/[ÀÁẠẢÃÂẦẤẬẨẪĂẰẮẶẲẴ]/g, 'A');
-    str = str.replace(/[ÈÉẸẺẼÊỀẾỆỂỄ]/g, 'E');
-    str = str.replace(/[ÌÍỊỈĨ]/g, 'I');
-    str = str.replace(/[ÒÓỌỎÕÔỒỐỘỔỖƠỜỚỢỞỠ]/g, 'O');
-    str = str.replace(/Ù|Ú|Ụ|Ủ|Ũ|Ư|Ừ|Ứ|Ự|Ử|Ữ/g, 'U');
-    str = str.replace(/Ỳ|Ý|Ỵ|Ỷ|Ỹ/g, 'Y');
-    str = str.replace(/Đ/g, 'D');
-    return str;
-};
-/** Remove all accents and convert string to lower case, remove leading and trailing white space */
-export const simplifyString = (str) => removeAccent(`${str || ''}`.toLowerCase().trim()) || '';
+function normalizeStringForSearch(str) {
+    if (!str) {
+        return ''; // Handle null, undefined, or empty string inputs
+    }
+    return str
+        .normalize('NFD') // Decompose accented characters (e.g., "á" -> "a" + "´")
+        .replace(/[\u0300-\u036f]/g, '') // Remove diacritical marks
+        .toLowerCase() // Convert to lowercase
+        .replace(/\s+/g, ''); // Remove all whitespace
+}
 /**
+ * Checks string matching based on a query, supporting fuzzy matching,
+ * where the query characters must appear in order within the target string.
+ * Allows for missing characters in the query relative to the target,
+ * and ignores case, diacritics, and spaces.
+ *
  * @param str target string
  * @param queryStr search query
  * @returns true if target string includes search query
  */
-export const searchStringQuery = (str, queryStr) => simplifyString(str).includes(simplifyString(queryStr || ''));
+export const searchStringQuery = (str, queryStr) => {
+    const normalizedQuery = normalizeStringForSearch(queryStr);
+    const normalizedItem = normalizeStringForSearch(str);
+    // Optimization: if normalized query is longer than normalized item,
+    // it cannot be a subsequence.
+    if (normalizedQuery.length > normalizedItem.length) {
+        return false;
+    }
+    // Subsequence check:
+    // Iterate through both normalized strings.
+    // If characters match, advance the query pointer.
+    // Always advance the item pointer.
+    let queryIndex = 0;
+    let itemIndex = 0;
+    while (queryIndex < normalizedQuery.length && itemIndex < normalizedItem.length) {
+        if (normalizedQuery[queryIndex] === normalizedItem[itemIndex]) {
+            queryIndex++;
+        }
+        itemIndex++;
+    }
+    // If queryIndex reached the end of normalizedQuery, all its characters were found in order.
+    return queryIndex === normalizedQuery.length;
+};
 /**
  * Checks if any of the provided values match the search value.
  *

package/es/utils/index.d.ts

@@ -9,3 +9,4 @@ export * from './actionButtons';
 export * from './dataTable';
 export * from './cookie';
 export * from './attribute';
+export * from './web';

package/es/utils/index.js

@@ -9,3 +9,4 @@ export * from './actionButtons';
 export * from './dataTable';
 export * from './cookie';
 export * from './attribute';
+export * from './web';

package/es/utils/tree.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Tree utilities with performance optimizations using level-based operations.
+ *
+ * Key performance improvements:
+ * - Level property enables O(1) depth checks and early exit conditions
+ * - Pre-allocated arrays for path operations avoid costly array resizing
+ * - Level-based filtering for efficient node selection
+ * - Optimized tree traversal with level-aware recursion control
+ *
+ * @file src/utils/tree.ts
+ */
+/**
+ * Represents the structure of a tree node before normalization.
+ * @template T The type of data stored in the node.
+ */
+export interface TreeNode<T> {
+    /** The unique identifier for the node. */
+    id: string;
+    /** The data payload of the node. */
+    data: T;
+    /** Optional array of child nodes. Children are full TreeNode objects. */
+    children?: TreeNode<T>[];
+}
+/**
+ * Represents the structure of a normalized tree node, as stored in the `items` map.
+ * @template T The type of data stored in the node.
+ */
+export interface NormalizedNode<T> {
+    /** The unique identifier for the node. */
+    id: string;
+    /** The data payload of the node. */
+    data: T;
+    /** The ID of the parent node, or null if it's a root node. */
+    parentId: string | null;
+    /** An array of IDs of the direct children of this node. */
+    childIds: string[];
+    /** The depth/level of this node in the tree (0 for root nodes). */
+    level: number;
+}
+/**
+ * Represents the overall shape of the normalized tree data store.
+ * @template T The type of data stored in the tree nodes.
+ */
+export interface NormalizedTreeState<T> {
+    /** A Map where keys are item IDs (strings) and values are NormalizedNode objects. */
+    items: Map<string, NormalizedNode<T>>;
+    /** A Set of IDs for the top-level (root) nodes. */
+    rootItemIds: Set<string>;
+}
+/**
+ * Normalizes a tree structure from a nested format to a flat, relational format.
+ * Each node is stored in a map by its ID, and relationships are maintained via `parentId` and `childIds`.
+ *
+ * @template T The type of data in the tree nodes.
+ * @param {TreeNode<T>[]} nodes - An array of root tree nodes in their original nested structure.
+ * @returns {NormalizedTreeState<T>} The normalized tree state, containing a map of items and a set of root item IDs.
+ */
+export declare function normalizeTreeData<T>(nodes: TreeNode<T>[]): NormalizedTreeState<T>;
+/**
+ * Retrieves all normalized nodes from the items store as an array.
+ *
+ * @template T The type of data in the nodes.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T>[]} An array of all normalized nodes.
+ */
+export declare function getAllItems<T>(itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T>[];
+/**
+ * Recursively reconstructs a subtree (or a portion of it) from the normalized data,
+ * starting from a given item ID.
+ *
+ * @template T The type of data in the nodes.
+ * @param {string} itemId - The ID of the node from which to start reconstructing the subtree.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @param {number} [maxLevels=Infinity] - The maximum number of levels of children to retrieve.
+ * @param {number} [startLevel] - The starting level for depth calculation (used internally).
+ * @returns {TreeNode<T>[]} An array of reconstructed tree nodes (children of the `itemId` node).
+ *                         Returns an empty array if the item has no children or `maxLevels` is reached.
+ */
+export declare function getChildrenRecursively<T>(itemId: string, itemsStore: Map<string, NormalizedNode<T>>, maxLevels?: number, startLevel?: number): TreeNode<T>[];
+/**
+ * Retrieves a single normalized node by its ID from the items store.
+ *
+ * @template T The type of data in the node.
+ * @param {string} itemId - The ID of the node to retrieve.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T> | undefined} The normalized node if found, otherwise undefined.
+ */
+export declare function getNode<T>(itemId: string, itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T> | undefined;
+/**
+ * Retrieves the parent of a given node from the items store.
+ *
+ * @template T The type of data in the nodes.
+ * @param {string} itemId - The ID of the node whose parent is to be retrieved.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T> | undefined} The parent node if found, otherwise undefined.
+ */
+export declare function getParent<T>(itemId: string, itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T> | undefined;
+/**
+ * Retrieves the path (an array of nodes) from the root to a specified node.
+ * The path includes the target node itself as the last element.
+ * Performance optimized using the level property to pre-allocate array size.
+ *
+ * @template T The type of data in the nodes.
+ * @param {string} itemId - The ID of the target node.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T>[]} An array of nodes representing the path from a root to the target node.
+ *                                Returns an empty array if the node is not found.
+ */
+export declare function getPathToNode<T>(itemId: string, itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T>[];
+/**
+ * Finds all nodes in the items store that satisfy a given predicate function.
+ *
+ * @template T The type of data in the nodes.
+ * @param {(node: NormalizedNode<T>) => boolean} predicate - A function that takes a node and returns true if it matches the criteria.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T>[]} An array of nodes that satisfy the predicate.
+ */
+export declare function findNodes<T>(predicate: (node: NormalizedNode<T>) => boolean, itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T>[];
+/**
+ * Checks if a node is a descendant of another node.
+ * Performance optimized using level comparison for early exit.
+ *
+ * @template T The type of data in the nodes.
+ * @param {string} potentialDescendantId - The ID of the node to check if it's a descendant.
+ * @param {string} ancestorId - The ID of the potential ancestor node.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {boolean} True if `potentialDescendantId` is a descendant of `ancestorId`, false otherwise.
+ */
+export declare function isDescendant<T>(potentialDescendantId: string, ancestorId: string, itemsStore: Map<string, NormalizedNode<T>>): boolean;
+/**
+ * Updates the data of a specific node in an immutable way.
+ *
+ * @template T The type of data in the node.
+ * @param {string} itemId - The ID of the node to update.
+ * @param {Partial<T>} newData - An object containing the new data fields to merge into the existing node's data.
+ * @param {NormalizedTreeState<T>} currentState - The current normalized tree state.
+ * @returns {NormalizedTreeState<T>} A new tree state with the specified node's data updated.
+ *                                   Returns the original state if the node is not found.
+ */
+export declare function updateNodeData<T>(itemId: string, newData: Partial<T>, currentState: NormalizedTreeState<T>): NormalizedTreeState<T>;
+/**
+ * Adds a new node to the tree in an immutable way.
+ *
+ * @template T The type of data for the new node.
+ * @param {string} newNodeId - The ID for the new node. Must be unique.
+ * @param {T} nodeData - The data payload for the new node.
+ * @param {string | null} parentId - The ID of the parent node. If null, the new node is added as a root.
+ * @param {NormalizedTreeState<T>} currentState - The current normalized tree state.
+ * @returns {NormalizedTreeState<T>} A new tree state with the new node added.
+ *                                   If `newNodeId` already exists, it logs a warning and returns the original state.
+ *                                   If `parentId` is provided but not found, the node is added as a root.
+ */
+export declare function addNode<T>(newNodeId: string, nodeData: T, parentId: string | null, currentState: NormalizedTreeState<T>): NormalizedTreeState<T>;
+/**
+ * Helper function to recursively get all descendant IDs of a given node,
+ * including the starting node's ID itself.
+ * Uses a Set for efficient addition and lookup, and to avoid reprocessing.
+ *
+ * @template T The type of data in the nodes (not directly used but good for consistency).
+ * @param {string} itemId - The ID of the starting node.
+ * @param {Map<string, NormalizedNode<T>>} itemsMap - The map of all normalized nodes.
+ * @param {Set<string>} [idsFound=new Set()] - Accumulator for descendant IDs (used internally for recursion).
+ * @returns {Set<string>} A Set containing the IDs of the starting node and all its descendants.
+ */
+export declare function getAllDescendantIdsRecursive<T>(itemId: string, itemsMap: Map<string, NormalizedNode<T>>, idsFound?: Set<string>): Set<string>;
+/**
+ * Removes a node and all its descendants from the tree in an immutable way.
+ *
+ * @template T The type of data in the nodes.
+ * @param {string} itemIdToRemove - The ID of the node to remove.
+ * @param {NormalizedTreeState<T>} currentState - The current normalized tree state.
+ * @returns {NormalizedTreeState<T>} A new tree state with the specified node and its descendants removed.
+ *                                   Returns the original state if the node to remove is not found.
+ */
+export declare function removeNode<T>(itemIdToRemove: string, currentState: NormalizedTreeState<T>): NormalizedTreeState<T>;
+/**
+ * Gets all nodes at a specific level in the tree.
+ * Performance optimized using the level property.
+ *
+ * @template T The type of data in the nodes.
+ * @param {number} targetLevel - The level to retrieve nodes from (0 for root nodes).
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T>[]} An array of nodes at the specified level.
+ */
+export declare function getNodesAtLevel<T>(targetLevel: number, itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T>[];
+/**
+ * Gets the maximum depth/level of the tree.
+ * Performance optimized using the level property.
+ *
+ * @template T The type of data in the nodes.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {number} The maximum level in the tree, or -1 if the tree is empty.
+ */
+export declare function getTreeDepth<T>(itemsStore: Map<string, NormalizedNode<T>>): number;
+/**
+ * Gets all nodes within a specified level range (inclusive).
+ * Performance optimized using the level property.
+ *
+ * @template T The type of data in the nodes.
+ * @param {number} minLevel - The minimum level (inclusive).
+ * @param {number} maxLevel - The maximum level (inclusive).
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T>[]} An array of nodes within the specified level range.
+ */
+export declare function getNodesInLevelRange<T>(minLevel: number, maxLevel: number, itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T>[];
+/**
+ * Gets all ancestor nodes of a specified node.
+ * Performance optimized using the level property for early termination.
+ *
+ * @template T The type of data in the nodes.
+ * @param {string} itemId - The ID of the node to get ancestors for.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {NormalizedNode<T>[]} An array of ancestor nodes, ordered from root to immediate parent.
+ */
+export declare function getAncestors<T>(itemId: string, itemsStore: Map<string, NormalizedNode<T>>): NormalizedNode<T>[];
+/**
+ * Checks if a node is at a leaf level (has no children).
+ * This is a convenience function that leverages the existing childIds property.
+ *
+ * @template T The type of data in the nodes.
+ * @param {string} itemId - The ID of the node to check.
+ * @param {Map<string, NormalizedNode<T>>} itemsStore - The map of normalized nodes.
+ * @returns {boolean} True if the node is a leaf (has no children), false otherwise.
+ */
+export declare function isLeafNode<T>(itemId: string, itemsStore: Map<string, NormalizedNode<T>>): boolean;