@ticatec/uniface-element 0.3.18 → 0.3.19

package/dist/lib/TreeNodes.js

@@ -10,12 +10,6 @@ export function compareNumber(a, b) {
 /**
  * 节点视图配置类 - 定义节点的显示方式
  * @template T 节点数据的类型
- *
- * @example
- * const options = new NodeViewOptions<MyData>({
- *   keyField: 'id',
- *   textField: 'name'
- * });
  */
 export class NodeViewOptions {
     /**
@@ -56,8 +50,9 @@ export class NodeViewOptions {
     }
 }
 /**
- * TreeNode 类 - 树节点，包含数据和方法
+ * TreeNode 类 - 树节点，包含数据和方法（内部类）
  * @template T 节点数据的类型
+ * @internal
  *
  * @description
  * TreeNode 是树结构的基本单元，每个节点包含：
@@ -68,8 +63,10 @@ export class NodeViewOptions {
  * - 加载状态（loading）
  *
  * 节点提供了丰富的操作方法，可以直接在节点上进行增删改查操作。
+ *
+ * 注意：此类为内部实现，外部应使用 ITreeNode 接口
  */
-export class TreeNode {
+class TreeNode {
     /**
      * 节点数据（私有，只读）
      * @private
@@ -97,21 +94,17 @@ export class TreeNode {
      * @private
      */
     _children = null;
+    nodes;
     /**
      * 创建树节点
      * @param item 节点数据
+     * @param nodes
      * @param parent 父节点（可选）
      * @param children 子节点列表（可选）
-     *
-     * @example
-     * // 创建根节点
-     * const rootNode = new TreeNode({ id: 1, name: "根节点" });
-     *
-     * // 创建子节点
-     * const childNode = new TreeNode({ id: 2, name: "子节点" }, rootNode);
      */
-    constructor(item, parent = null, children = null) {
+    constructor(item, nodes, parent = null, children = null) {
         this._item = item;
+        this.nodes = nodes;
         this._level = parent ? parent._level + 1 : 0;
         this.parent = parent;
         this._children = children;
@@ -134,32 +127,33 @@ export class TreeNode {
     /**
      * 获取子节点列表（只读）
      * @returns 子节点数组的浅拷贝，如果没有子节点返回 null
-     *
-     * @example
-     * const children = node.children;
-     * if (children) {
-     *   children.forEach(child => console.log(child.item));
-     * }
      */
     get children() {
         return this._children ? [...this._children] : null;
     }
+    set children(value) {
+        this._children = value;
+    }
     /**
      * 添加子节点
      * @param childItem 子节点数据
      * @returns 新创建的子节点
-     *
-     * @example
-     * const childNode = parentNode.append({ id: 1, name: "子节点" });
      */
     append(childItem) {
-        return new TreeNode(childItem, this);
+        if (Array.isArray(childItem)) {
+            let list = [];
+            this._children = [];
+            childItem.forEach(item => {
+                list.push(new TreeNode(item, this.nodes, this));
+            });
+            return list;
+        }
+        else {
+            return new TreeNode(childItem, this.nodes, this);
+        }
     }
     /**
      * 从父节点中分离（删除当前节点）
-     *
-     * @example
-     * node.detach();
      */
     detach() {
         if (!this.parent) {
@@ -191,19 +185,13 @@ export class TreeNode {
      * 移动到另一个父节点下
      * @param newParent 新的父节点
      * @returns 新创建的节点（注意：返回的是新节点，不是原节点）
-     *
-     * @example
-     * node.moveTo(newParentNode);
      */
     moveTo(newParent) {
-        return new TreeNode(this._item, newParent, this._children);
+        return new TreeNode(this._item, this.nodes, newParent, this._children);
     }
     /**
      * 替换当前节点的数据
      * @param newItem 新的数据对象
-     *
-     * @example
-     * node.replace({ id: 1, name: "新名称", ...otherFields });
      */
     replace(newItem) {
         this._item = newItem;
@@ -217,9 +205,6 @@ export class TreeNode {
     }
     /**
      * 删除所有子节点
-     *
-     * @example
-     * node.removeChildren();
      */
     removeChildren() {
         this._children = [];
@@ -267,28 +252,6 @@ export class TreeNode {
  * - 节点的映射和查找
  * - 版本管理（用于响应式更新）
  * - 层级展开控制
- *
- * @example
- * interface MyData {
- *   id: number;
- *   name: string;
- *   parentId: number | null;
- * }
- *
- * const treeNodes = new TreeNodes<MyData>({
- *   keyField: 'id',
- *   textField: 'name',
- *   parentKeyField: 'parentId',
- *   checkIsRoot: (item) => item.parentId === null,
- *   checkIsDirectory: (node) => node.children !== null,
- *   expendDepth: 2
- * });
- *
- * treeNodes.setData([
- *   { id: 1, name: "根节点", parentId: null },
- *   { id: 2, name: "子节点1", parentId: 1 },
- *   { id: 3, name: "子节点2", parentId: 1 }
- * ]);
  */
 export default class TreeNodes {
     checkIsRoot;
@@ -326,13 +289,6 @@ export default class TreeNodes {
      * 3. 根据 parentKeyField 建立父子关系
      * 4. 应用展开深度设置
      * 5. 触发版本更新
-     *
-     * @example
-     * treeNodes.setData([
-     *   { id: 1, name: "根节点", parentId: null },
-     *   { id: 2, name: "子节点1", parentId: 1 },
-     *   { id: 3, name: "子节点2", parentId: 1 }
-     * ]);
      */
     setData(list) {
         this.nodeMap = new Map();
@@ -340,7 +296,7 @@ export default class TreeNodes {
         // 第一遍：创建所有节点（不设置父子关系）
         for (const item of list) {
             const key = item[this.keyField];
-            const node = new TreeNode(item); // 创建节点时不设置 parent
+            const node = new TreeNode(item, this); // 创建节点时不设置 parent
             this.nodeMap.set(key, node);
         }
         // 第二遍：建立父子关系
@@ -402,12 +358,19 @@ export default class TreeNodes {
     }
     /**
      * 获取展开的展示列表
+     * @returns 展开的所有节点（按层级顺序）
      */
     getHierarchyList() {
         let arr = [];
-        this.addExpandNodesToList(this.nodes, arr);
+        this.addExpandNodesToList(this._nodes, arr);
         return arr;
     }
+    /**
+     * 将展开的节点添加到列表
+     * @param nodes 节点数组
+     * @param list 结果列表
+     * @private
+     */
     addExpandNodesToList(nodes, list) {
         for (let node of nodes) {
             list.push(node);
@@ -416,16 +379,6 @@ export default class TreeNodes {
             }
         }
     }
-    /**
-     * 不检测匹配情况，在指定的父节点下添加子节点
-     */
-    batchAttachToParent(parent, list) {
-        let nodes = [];
-        for (let item of list) {
-            nodes.push(new TreeNode(item, parent));
-        }
-        return nodes;
-    }
     /**
      * 增加一个新节点（便捷方法，会自动根据 parentKeyField 找到父节点）
      * @param item 要添加的节点数据
@@ -433,7 +386,7 @@ export default class TreeNodes {
     append(item) {
         if (parent) {
             if (this.checkIsRoot(item)) {
-                let node = new TreeNode(item);
+                let node = new TreeNode(item, this);
                 this._nodes.push(node);
                 this._version++;
                 return node;
@@ -443,9 +396,9 @@ export default class TreeNodes {
             }
         }
         else {
-            let parent = this.findParent(this.nodes, item);
+            let parent = this._findNodeFromList(this.nodes, item, this.parentKeyField);
             if (!parent) {
-                let node = new TreeNode(item, parent);
+                let node = new TreeNode(item, this, parent);
                 this._version++;
                 return node;
             }
@@ -454,18 +407,76 @@ export default class TreeNodes {
             }
         }
     }
-    findParent(nodes, item) {
+    replace(item) {
+        let node = this._findNodeFromList(this.nodes, item, this.keyField);
+        if (node) {
+            node.replace(item);
+            this._version++;
+        }
+        return node;
+    }
+    remove(item) {
+        let node = this._findNodeFromList(this.nodes, item, this.keyField);
+        if (node) {
+            if (node.parent) {
+                node.detach();
+            }
+            else {
+                let pos = this.nodes.indexOf(node);
+                if (pos > -1) {
+                    this.nodes.splice(pos, 1);
+                }
+            }
+            this._version++;
+        }
+        return node;
+    }
+    /**
+     * 从节点列表中查找节点
+     * @param nodes 节点数组
+     * @param item 要查找的数据项
+     * @param matchedKey 匹配的字段名
+     * @returns 找到的节点或 null
+     * @private
+     */
+    _findNodeFromList(nodes, item, matchedKey) {
         let found = null;
         for (const node of nodes) {
             if (!found) {
-                if (node.item[this.keyField] == item[this.parentKeyField]) {
+                if (node.item[this.keyField] == item[matchedKey]) {
                     found = node;
                 }
                 else {
-                    found = node.children && node.children.length > 0 ? this.findParent(node.children, item) : null;
+                    found = node.children && node.children.length > 0 ? this._findNodeFromList(node.children, item, matchedKey) : null;
                 }
             }
         }
         return found;
     }
 }
+export class MenuNodes extends TreeNodes {
+    /**
+     * 删除所有属于分支但没有子节点的节点
+     */
+    cleanEmptyDirectories() {
+        console.log("原始菜单", this._nodes);
+        this._nodes = this._nodes.filter(n => this.pruneEmptyDirs(n) !== null);
+    }
+    pruneEmptyDirs(node) {
+        if (!node)
+            return null;
+        // 先递归处理子节点
+        if (node.children) {
+            node.children = node.children
+                .map((sn) => this.pruneEmptyDirs(sn))
+                .filter((child) => child !== null);
+        }
+        const isDir = this.checkIsDirectory?.(node);
+        const hasNoChildren = !node.children || node.children.length === 0;
+        // 如果是目录且没有子节点，则删除该节点
+        if (isDir && hasNoChildren) {
+            return null;
+        }
+        return node;
+    }
+}

package/dist/lib/index.d.ts

@@ -1,8 +1,10 @@
 import TreeNodes from "./TreeNodes";
 import type { ITreeNode } from "./TreeNodes";
 import type { CheckIsRoot, CompareFun, GetText, CheckIsDirectory, TreeNodeOptions } from "./TreeNodes";
+import { MenuNodes } from "./TreeNodes";
 import { compareNumber } from "./TreeNodes";
 export default TreeNodes;
 export { compareNumber };
+export { MenuNodes };
 export type { ITreeNode };
 export type { CheckIsRoot, CompareFun, GetText, CheckIsDirectory, TreeNodeOptions };

package/dist/lib/index.js

@@ -1,4 +1,6 @@
 import TreeNodes from "./TreeNodes";
+import { MenuNodes } from "./TreeNodes";
 import { compareNumber } from "./TreeNodes";
 export default TreeNodes;
 export { compareNumber };
+export { MenuNodes };

package/dist/nav-menu/MenuItem.d.ts

@@ -1,7 +1,7 @@
-import type { TreeNode } from "../lib";
+import type { ITreeNode } from "../lib";
 export default interface MenuItem {
     [key: string]: any;
 }
-export interface MenuNode extends TreeNode<MenuItem> {
+export interface MenuNode extends ITreeNode<MenuItem> {
 }
 export type OnMenuClick = (item: MenuItem) => void;