sculp-js 1.19.3 → 1.19.5

package/dist/esm/tree.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */
@@ -14,10 +14,15 @@ const defaultSearchTreeOptions = {
   removeEmptyChild: false,
   ignoreCase: true
 };
+function getChildNodes(item, childField, isDomNode) {
+  const child = item[childField];
+  if (!child) return null;
+  return isDomNode && isNodeList(child) ? Array.from(child) : Array.isArray(child) ? child : null;
+}
 /**
- * 树遍历函数(支持continue和break操作), 可用于遍历Array和NodeList类型的数据
+ * 深度遍历函数 (支持 continue 和 break 操作), 可用于遍历 Array 和 NodeList 类型的数据
  * @param {ArrayLike<V>} tree  树形数据
- * @param {Function} iterator  迭代函数, 返回值为true时continue, 返回值为false时break
+ * @param {Function} iterator  迭代函数，返回值为 true 时 continue, 返回值为 false 时 break
  * @param {options} options 支持定制子元素名称、反向遍历、广度优先遍历，默认{
     childField: 'children',
     reverse: false,
@@ -44,93 +49,56 @@ function forEachDeep(
   } = isObject(options) ? options : {};
   let isBreak = false;
   const queue = [];
-  const reverseWalk = (arr, parent, level = 0) => {
-    for (let index = arr.length - 1; index >= 0; index--) {
-      if (isBreak) {
-        break;
-      }
-      const item = arr[index];
-      // 广度优先
-      if (breadthFirst) {
-        queue.push({ item, index, array: arr, tree, parent, level });
-      } else {
-        const re = iterator(item, index, arr, tree, parent, level);
-        if (re === false) {
-          isBreak = true;
-          break;
-        } else if (re === true) {
-          continue;
-        }
-        if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
-          reverseWalk(item[childField], item, level + 1);
-        }
-      }
+  const processNode = (item, index, arr, parent, level) => {
+    const re = iterator(item, index, arr, tree, parent, level);
+    if (re === false) {
+      isBreak = true;
+      return;
     }
-    if (breadthFirst) {
-      // Process queue
-      while (queue.length > 0 && !isBreak) {
-        const current = queue.shift();
-        const { item, index, array, tree, parent, level } = current;
-        const re = iterator(item, index, array, tree, parent, level);
-        if (re === false) {
-          isBreak = true;
-          break;
-        } else if (re === true) {
-          continue;
-        }
-        if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
-          reverseWalk(item[childField], item, level + 1);
+    if (re === true) return;
+    const childNodes = getChildNodes(item, childField, isDomNode);
+    if (childNodes) {
+      if (breadthFirst) {
+        // BFS: 将子节点加入队列
+        const childLen = childNodes.length;
+        for (let i = 0; i < childLen; i++) {
+          queue.push({ item: childNodes[i], index: i, array: childNodes, tree, parent: item, level: level + 1 });
         }
+      } else {
+        // DFS: 立即递归处理子节点
+        walk(childNodes, item, level + 1);
       }
     }
   };
-  const walk = (arr, parent, level = 0) => {
-    for (let index = 0, len = arr.length; index < len; index++) {
-      if (isBreak) {
-        break;
-      }
-      const item = arr[index];
-      if (breadthFirst) {
-        // 广度优先
-        queue.push({ item, index: index, array: arr, tree, parent, level });
-      } else {
-        // 深度优先
-        const re = iterator(item, index, arr, tree, parent, level);
-        if (re === false) {
-          isBreak = true;
-          break;
-        } else if (re === true) {
-          continue;
-        }
-        if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
-          walk(item[childField], item, level + 1);
-        }
+  const walk = (arr, parent, level) => {
+    const len = arr.length;
+    if (reverse) {
+      for (let i = len - 1; i >= 0; i--) {
+        if (isBreak) break;
+        processNode(arr[i], i, arr, parent, level);
       }
-    }
-    if (breadthFirst) {
-      while (queue.length > 0 && !isBreak) {
-        const current = queue.shift();
-        if (!current) break;
-        const { item, index, array, tree, parent, level } = current;
-        const re = iterator(item, index, array, tree, parent, level);
-        if (re === false) {
-          isBreak = true;
-          break;
-        } else if (re === true) {
-          continue;
-        }
-        if (item && (isDomNode ? isNodeList(item[childField]) : Array.isArray(item[childField]))) {
-          walk(item[childField], item, level + 1);
-        }
+    } else {
+      for (let i = 0; i < len; i++) {
+        if (isBreak) break;
+        processNode(arr[i], i, arr, parent, level);
       }
     }
   };
-  reverse ? reverseWalk(tree, null, 0) : walk(tree, null, 0);
+  // 先处理根节点
+  walk(tree, null, 0);
+  // BFS: 处理队列中的节点
+  if (breadthFirst) {
+    let queueIndex = 0;
+    while (queueIndex < queue.length && !isBreak) {
+      const { item, index, array, parent, level } = queue[queueIndex++];
+      processNode(item, index, array, parent, level);
+    }
+  }
   // @ts-ignore
   tree = null;
 }
 /**
- * 树查找函数, 可用于查找Array和NodeList类型的数据
+ * 树查找函数，可用于查找 Array 和 NodeList 类型的数据
  * @param {ArrayLike<V>} tree  树形数据
  * @param {Function} predicate  断言函数
  * @param {options} options 支持定制子元素名称、反向遍历、广度优先遍历，默认{
@@ -165,7 +133,7 @@ function findDeep(
   return result;
 }
 /**
- * 树过滤函数, 可用于过滤Array和NodeList类型的数据
+ * 树过滤函数，可用于过滤 Array 和 NodeList 类型的数据
  * @param {ArrayLike<V>} tree  树形数据
  * @param {Function} predicate  断言函数
  * @param {options} options 支持定制子元素名称、反向遍历、广度优先遍历，默认{
@@ -199,11 +167,11 @@ function filterDeep(
   return result;
 }
 /**
- * 创建一个新数组, 深度优先遍历的Map函数(支持continue和break操作), 可用于insert tree item 和 remove tree item
+ * 创建一个新数组，深度优先遍历的 Map 函数 (支持 continue 和 break 操作), 可用于 insert tree item 和 remove tree item
  *
  * 可遍历任何带有 length 属性和数字键的类数组对象
  * @param {ArrayLike<V>} tree  树形数据
- * @param {Function} iterator  迭代函数, 返回值为true时continue, 返回值为false时break
+ * @param {Function} iterator  迭代函数，返回值为 true 时 continue, 返回值为 false 时 break
  * @param {options} options 支持定制子元素名称、反向遍历，默认{
     childField: 'children',
     reverse: false,
@@ -221,54 +189,46 @@ function mapDeep(
   const { childField = 'children', reverse = false } = isObject(options) ? options : {};
   let isBreak = false;
   const newTree = [];
-  const walk = (arr, parent, newTree, level = 0) => {
+  const walk = (arr, parent, output, level) => {
     if (reverse) {
       for (let i = arr.length - 1; i >= 0; i--) {
-        if (isBreak) {
-          break;
-        }
+        if (isBreak) break;
         const item = arr[i];
         const re = iterator(item, i, arr, tree, parent, level);
         if (re === false) {
           isBreak = true;
           break;
-        } else if (re === true) {
-          continue;
         }
-        newTree.push(objectOmit(re, [childField]));
-        if (item && Array.isArray(item[childField])) {
-          newTree[newTree.length - 1][childField] = [];
-          walk(item[childField], item, newTree[newTree.length - 1][childField], level + 1);
-        } else {
-          // children非有效数组时，移除该属性字段
-          delete re[childField];
+        if (re === true) continue;
+        const newItem = objectOmit(re, [childField]);
+        output.push(newItem);
+        const children = item[childField];
+        if (Array.isArray(children)) {
+          newItem[childField] = [];
+          walk(children, item, newItem[childField], level + 1);
         }
       }
     } else {
       for (let i = 0; i < arr.length; i++) {
-        if (isBreak) {
-          break;
-        }
+        if (isBreak) break;
         const item = arr[i];
         const re = iterator(item, i, arr, tree, parent, level);
         if (re === false) {
           isBreak = true;
           break;
-        } else if (re === true) {
-          continue;
         }
-        newTree.push(objectOmit(re, [childField]));
-        if (item && Array.isArray(item[childField])) {
-          newTree[newTree.length - 1][childField] = [];
-          walk(item[childField], item, newTree[newTree.length - 1][childField], level + 1);
-        } else {
-          // children非有效数组时，移除该属性字段
-          delete re[childField];
+        if (re === true) continue;
+        const newItem = objectOmit(re, [childField]);
+        output.push(newItem);
+        const children = item[childField];
+        if (Array.isArray(children)) {
+          newItem[childField] = [];
+          walk(children, item, newItem[childField], level + 1);
         }
       }
     }
   };
-  walk(tree, null, newTree);
+  walk(tree, null, newTree, 0);
   // @ts-ignore
   tree = null;
   return newTree;
@@ -277,40 +237,51 @@ function mapDeep(
  * 在树中找到 id 为某个值的节点，并返回上游的所有父级节点
  *
  * @param {ArrayLike<T>} tree - 树形数据
- * @param {number | string} nodeId - 目标元素ID
- * @param {ITreeConf} options - 迭代配置项, 默认：{ children = 'children', id = 'id' }
- * @returns {[(number | string)[], V[]]} - 由parentId...childId, parentObject-childObject组成的二维数组
+ * @param {number | string} nodeId - 目标元素 ID
+ * @param {ITreeConf} options - 迭代配置项，默认：{ children = 'children', id = 'id' }
+ * @returns {[(number | string)[], V[]]} - 由 parentId...childId, parentObject-childObject 组成的二维数组
  */
 function searchTreeById(tree, nodeId, options = { childField: 'children', keyField: 'id' }) {
   const { childField = 'children', keyField = 'id' } = isObject(options) ? options : {};
-  const toFlatArray = (tree, parentId, parent) => {
-    return tree.reduce((t, _) => {
-      const child = _[childField];
-      return [
-        ...t,
-        parentId ? { ..._, parentId, parent } : _,
-        ...(child && child.length ? toFlatArray(child, _[keyField], _) : [])
-      ];
-    }, []);
-  };
-  const getIds = flatArray => {
-    let child = flatArray.find(_ => _[keyField] === nodeId);
-    const { parent, parentId, ...other } = child;
-    let ids = [nodeId],
-      nodes = [other];
-    while (child && child.parentId) {
-      ids = [child.parentId, ...ids];
-      nodes = [child.parent, ...nodes];
-      child = flatArray.find(_ => _[keyField] === child.parentId); // eslint-disable-line
+  const flatMap = {};
+  // 扁平化 - 使用迭代而非递归，避免栈溢出
+  const stack = [];
+  const len = tree.length;
+  for (let i = 0; i < len; i++) {
+    stack.push({ node: tree[i] });
+  }
+  while (stack.length > 0) {
+    const { node, parentId, parent } = stack.pop();
+    const id = node[keyField];
+    flatMap[id] = { node, parentId, parent };
+    const children = node[childField];
+    if (Array.isArray(children)) {
+      const childLen = children.length;
+      for (let i = 0; i < childLen; i++) {
+        stack.push({ node: children[i], parentId: id, parent: node });
+      }
     }
-    return [ids, nodes];
-  };
-  return getIds(toFlatArray(tree));
+  }
+  // 回溯路径
+  const ids = [];
+  const nodes = [];
+  let current = flatMap[nodeId];
+  if (!current) return [[], []];
+  ids.push(nodeId);
+  nodes.push(current.node);
+  while (current && current.parentId !== undefined) {
+    ids.unshift(current.parentId);
+    const parent = flatMap[current.parentId];
+    if (!parent) break;
+    nodes.unshift(parent.node);
+    current = parent;
+  }
+  return [ids, nodes];
 }
 /**
  * 扁平化数组转换成树
  * @param {any[]} list
- * @param {IFieldOptions} options 定制id字段名，子元素字段名，父元素字段名，默认
+ * @param {IFieldOptions} options 定制 id 字段名，子元素字段名，父元素字段名，默认
  *        { keyField: 'key', childField: 'children', pidField: 'pid' }
  * @returns {any[]}
  */
@@ -318,11 +289,13 @@ function formatTree(list, options = defaultFieldOptions) {
   const { keyField = 'key', childField = 'children', pidField = 'pid' } = isObject(options) ? options : {};
   const treeArr = [];
   const sourceMap = {};
-  for (let i = 0, len = list.length; i < len; i++) {
+  const len = list.length;
+  // 先克隆所有对象，避免修改源数据
+  for (let i = 0; i < len; i++) {
     const item = list[i];
     sourceMap[item[keyField]] = item;
   }
-  for (let i = 0, len = list.length; i < len; i++) {
+  for (let i = 0; i < len; i++) {
     const item = list[i];
     const parent = sourceMap[item[pidField]];
     if (parent) {
@@ -338,29 +311,32 @@ function formatTree(list, options = defaultFieldOptions) {
 /**
  * 树形结构转扁平化
  * @param {any[]} treeList
- * @param {IFieldOptions} options 定制id字段名，子元素字段名，父元素字段名，默认
+ * @param {IFieldOptions} options 定制 id 字段名，子元素字段名，父元素字段名，默认
  *        { keyField: 'key', childField: 'children', pidField: 'pid' }
  * @returns {any[]}
  */
 function flatTree(treeList, options = defaultFieldOptions) {
   const { keyField = 'key', childField = 'children', pidField = 'pid' } = isObject(options) ? options : {};
-  let res = [];
-  for (let i = 0, len = treeList.length; i < len; i++) {
-    const node = treeList[i];
-    const item = {
-      ...node,
-      [childField]: [] // 清空子级
-    };
-    objectHas(item, childField) && delete item[childField];
-    res.push(item);
-    if (node[childField]) {
-      const children = node[childField].map(item => ({
-        ...item,
-        [pidField]: node[keyField] || item.pid // 给子级设置pid
-      }));
-      res = res.concat(flatTree(children, options));
+  const res = [];
+  const walk = nodes => {
+    const len = nodes.length;
+    for (let i = 0; i < len; i++) {
+      const node = nodes[i];
+      const item = { ...node };
+      delete item[childField];
+      res.push(item);
+      const children = node[childField];
+      if (Array.isArray(children)) {
+        // 创建新的子节点数组，不修改原数据
+        const newChildren = children.map(child => ({
+          ...child,
+          [pidField]: node[keyField] !== undefined ? node[keyField] : child.pid
+        }));
+        walk(newChildren);
+      }
     }
-  }
+  };
+  walk(treeList);
   return res;
 }
 /**
@@ -387,41 +363,44 @@ function fuzzySearchTree(nodes, filterCondition, options = defaultSearchTreeOpti
     return nodes;
   }
   const result = [];
+  const { childField, nameField, removeEmptyChild, ignoreCase } = options;
+  const hasFilter = objectHas(filterCondition, 'filter');
+  const filterFn = filterCondition.filter;
+  const keyword = filterCondition.keyword;
   for (let i = 0, len = nodes.length; i < len; i++) {
     const node = nodes[i];
-    // 递归检查子节点是否匹配
-    const matchedChildren =
-      node[options.childField] && node[options.childField].length > 0
-        ? fuzzySearchTree(node[options.childField] || [], filterCondition, options)
-        : [];
-    // 检查当前节点是否匹配或者有匹配的子节点
-    if (
-      (objectHas(filterCondition, 'filter')
-        ? filterCondition.filter(node)
-        : !options.ignoreCase
-        ? node[options.nameField].includes(filterCondition.keyword)
-        : node[options.nameField].toLowerCase().includes(filterCondition.keyword.toLowerCase())) ||
-      matchedChildren.length > 0
-    ) {
-      // 将当前节点加入结果中
-      if (node[options.childField]) {
+    const children = node[childField];
+    // 递归处理子节点
+    const matchedChildren = children && children.length > 0 ? fuzzySearchTree(children, filterCondition, options) : [];
+    // 判断当前节点是否匹配
+    let isMatch = false;
+    if (hasFilter && filterFn) {
+      isMatch = filterFn(node);
+    } else if (keyword !== undefined && keyword !== null) {
+      const nodeValue = String(node[nameField] || '');
+      const searchValue = String(keyword);
+      isMatch = ignoreCase
+        ? nodeValue.toLowerCase().includes(searchValue.toLowerCase())
+        : nodeValue.includes(searchValue);
+    }
+    // 如果当前节点匹配或有匹配的子节点，则加入结果
+    if (isMatch || matchedChildren.length > 0) {
+      if (childField in node) {
+        // 节点有 children 字段
         if (matchedChildren.length > 0) {
-          result.push({
-            ...node,
-            [options.childField]: matchedChildren // 包含匹配的子节点
-          });
-        } else if (options.removeEmptyChild) {
-          const { [options.childField]: _, ...other } = node;
-          result.push(other);
+          // 有匹配的子节点
+          result.push({ ...node, [childField]: matchedChildren });
+        } else if (removeEmptyChild) {
+          // 无匹配子节点且需要移除空 children
+          const { [childField]: _, ...rest } = node;
+          result.push(rest);
         } else {
-          result.push({
-            ...node,
-            [options.childField]: []
-          });
+          // 无匹配子节点但保留 children 字段（设为空数组）
+          result.push({ ...node, [childField]: [] });
         }
       } else {
-        const { [options.childField]: _, ...other } = node;
-        result.push(other);
+        // 节点没有 children 字段，直接返回
+        result.push(node);
       }
     }
   }

package/dist/esm/type.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/dist/esm/unicodeToolkit.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */
@@ -19,12 +19,12 @@ class UnicodeToolkit {
    * UnicodeToolkit.encode('Hi 你好 😀')
    * // => 'Hi \u4F60\u597D \u{1F600}'
    * @example
-   * // 全部Unicode 编码
+   * // 全部 Unicode 编码
    * UnicodeToolkit.encode('Hi 你好 😀','unicode', true)
    * // => '\u0048\u0069\u0020\u4F60\u597D\u0020\u{1F600}'
    * @example
    * // HTML 实体编码
-   * UnicodeToolkit.encode('<script>', 'html',true)
+   * UnicodeToolkit.encode('<scr' + 'ipt>', 'html',true)
    * // => '&lt;&#115;&#99;&#114;&#105;&#112;&#116;&gt;&amp;'
    */
   static encode(str, mode = 'unicode', encodeAll = false) {

package/dist/esm/unique.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/dist/esm/url.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/dist/esm/validator.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/dist/esm/variable.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */

package/dist/esm/watermark.mjs

@@ -1,5 +1,5 @@
 /*!
- * sculp-js v1.19.3
+ * sculp-js v1.19.5
  * (c) 2023-present chandq
  * Released under the MIT License.
  */