@ticatec/uniface-element 0.3.23 → 5.0.1

package/dist/lib/TreeNodes.js

@@ -1,485 +0,0 @@
-/**
- * 比较两个数字
- * @param a 第一个数字
- * @param b 第二个数字
- * @returns 如果相等返回 0，a > b 返回 1，否则返回 -1
- */
-export function compareNumber(a, b) {
-    return a === b ? 0 : a > b ? 1 : -1;
-}
-/**
- * 节点视图配置类 - 定义节点的显示方式
- * @template T 节点数据的类型
- */
-export class NodeViewOptions {
-    /**
-     * 获取节点的唯一标识字段
-     */
-    keyField;
-    /**
-     * 获取节点的文字
-     * 可以是字段名或函数
-     */
-    textField;
-    /**
-     * 创建节点视图配置
-     * @param options 配置选项
-     */
-    constructor(options) {
-        this.keyField = options.keyField;
-        this.textField = options.textField;
-    }
-    /**
-     * 获取节点的文字
-     * @param data 节点数据
-     * @returns 显示文字
-     */
-    getText(data) {
-        if (typeof this.textField === 'function') {
-            return this.textField(data);
-        }
-        return String(data[this.textField] ?? '');
-    }
-    /**
-     * 获取节点的唯一标识
-     * @param data 节点数据
-     * @returns 唯一标识值
-     */
-    getKey(data) {
-        return data[this.keyField];
-    }
-}
-/**
- * TreeNode 类 - 树节点，包含数据和方法（内部类）
- * @template T 节点数据的类型
- * @internal
- *
- * @description
- * TreeNode 是树结构的基本单元，每个节点包含：
- * - 节点数据（item）
- * - 父节点引用（parent）
- * - 子节点列表（children）
- * - 展开状态（expand）
- * - 加载状态（loading）
- *
- * 节点提供了丰富的操作方法，可以直接在节点上进行增删改查操作。
- *
- * 注意：此类为内部实现，外部应使用 ITreeNode 接口
- */
-class TreeNode {
-    /**
-     * 节点数据（私有，只读）
-     * @private
-     */
-    _item;
-    /**
-     * 节点层级（私有）
-     * @private
-     */
-    _level;
-    /**
-     * 是否展开（显示子节点）
-     */
-    expand = false;
-    /**
-     * 是否正在加载（用于懒加载）
-     */
-    loading = false;
-    /**
-     * 父节点（只读）
-     */
-    parent = null;
-    /**
-     * 子节点数组（私有）
-     * @private
-     */
-    _children = null;
-    nodes;
-    /**
-     * 创建树节点
-     * @param item 节点数据
-     * @param nodes
-     * @param parent 父节点（可选）
-     * @param children 子节点列表（可选）
-     */
-    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;
-        this.expand = false;
-        // 如果有父节点，将自己添加到父节点的 children 中
-        if (parent) {
-            if (!parent._children) {
-                parent._children = [];
-            }
-            parent._children.push(this);
-        }
-    }
-    /**
-     * 获取节点层级
-     * @returns 层级值（根节点为 0）
-     */
-    get level() {
-        return this._level;
-    }
-    /**
-     * 获取子节点列表（只读）
-     * @returns 子节点数组的浅拷贝，如果没有子节点返回 null
-     */
-    get children() {
-        return this._children ? [...this._children] : null;
-    }
-    sort(compareFn) {
-        this._children?.sort((c1, c2) => compareFn(c1.item, c2.item));
-    }
-    set children(value) {
-        this._children = value;
-    }
-    /**
-     * 添加子节点
-     * @param childItem 子节点数据
-     * @returns 新创建的子节点
-     */
-    append(childItem) {
-        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);
-        }
-    }
-    /**
-     * 从父节点中分离（删除当前节点）
-     */
-    detach() {
-        if (!this.parent) {
-            console.warn('TreeNode is not attached to a tree, cannot detach');
-            return;
-        }
-        this.parent.removeNode(this);
-    }
-    /**
-     * 删除指定的子节点
-     * @param node 要删除的子节点
-     * @private
-     */
-    removeNode(node) {
-        if (this._children) {
-            let idx = this._children.indexOf(node);
-            if (idx >= 0) {
-                this._children.splice(idx, 1);
-            }
-            else {
-                console.warn(' The removed node has not been attached to this.');
-            }
-        }
-        else {
-            console.warn(' The removed node has not been attached to this.');
-        }
-    }
-    /**
-     * 移动到另一个父节点下
-     * @param newParent 新的父节点
-     * @returns 新创建的节点（注意：返回的是新节点，不是原节点）
-     */
-    moveTo(newParent) {
-        return new TreeNode(this._item, this.nodes, newParent, this._children);
-    }
-    /**
-     * 替换当前节点的数据
-     * @param newItem 新的数据对象
-     */
-    replace(newItem) {
-        this._item = newItem;
-    }
-    /**
-     * 获取节点数据
-     * @returns 节点数据对象
-     */
-    get item() {
-        return this._item;
-    }
-    /**
-     * 删除所有子节点
-     */
-    removeChildren() {
-        this._children = [];
-    }
-    /**
-     * @internal 仅供 TreeNodes 内部使用
-     * 设置父节点，并将自己添加到父节点的 children 中
-     * @param parent 新的父节点
-     *
-     * @description
-     * 此方法会：
-     * 1. 从原父节点的 children 中移除自己
-     * 2. 更新父节点引用
-     * 3. 重新计算层级
-     * 4. 将自己添加到新父节点的 children 中
-     */
-    _setParent(parent) {
-        // 从原父节点的 children 中移除自己
-        const oldParent = this.parent;
-        if (oldParent && oldParent._children) {
-            const index = oldParent._children.indexOf(this);
-            if (index >= 0) {
-                oldParent._children.splice(index, 1);
-            }
-        }
-        // 设置新父节点
-        this.parent = parent;
-        this._level = parent ? parent._level + 1 : 0;
-        // 将自己添加到新父节点的 children 中
-        if (parent) {
-            if (!parent._children) {
-                parent._children = [];
-            }
-            parent._children.push(this);
-        }
-    }
-}
-/**
- * TreeNodes 类 - 树节点管理器
- * @template T 节点数据的类型
- *
- * @description
- * TreeNodes 负责管理树结构的数据，包括：
- * - 树的构建和初始化
- * - 节点的映射和查找
- * - 版本管理（用于响应式更新）
- * - 层级展开控制
- */
-export default class TreeNodes {
-    checkIsRoot;
-    keyField;
-    parentKeyField;
-    textField;
-    checkIsDirectory;
-    nodeMap;
-    compareFun;
-    expendDepth;
-    _nodes = [];
-    _version = 0;
-    /**
-     * 创建 TreeNodes 实例
-     * @param options 配置选项
-     */
-    constructor(options) {
-        this.checkIsRoot = options.checkIsRoot;
-        this.compareFun = options.compareFun;
-        this.keyField = options.keyField ?? 'id';
-        this.textField = options.textField ?? 'text';
-        this.parentKeyField = options.parentKeyField ?? 'parentId';
-        this.nodeMap = new Map();
-        this.expendDepth = options.expendDepth ?? 1;
-        this.checkIsDirectory = options.checkIsDirectory;
-    }
-    /**
-     * 设置树数据
-     * @param list 扁平化的节点数据数组
-     *
-     * @description
-     * 此方法会：
-     * 1. 清空现有树结构
-     * 2. 创建所有节点
-     * 3. 根据 parentKeyField 建立父子关系
-     * 4. 应用展开深度设置
-     * 5. 触发版本更新
-     */
-    setData(list) {
-        this.nodeMap = new Map();
-        this._nodes = [];
-        // 第一遍：创建所有节点（不设置父子关系）
-        for (const item of list) {
-            const key = item[this.keyField];
-            const node = new TreeNode(item, this); // 创建节点时不设置 parent
-            this.nodeMap.set(key, node);
-        }
-        // 第二遍：建立父子关系
-        for (const item of list) {
-            const key = item[this.keyField];
-            const node = this.nodeMap.get(key);
-            if (this.checkIsRoot(item)) {
-                // 是根节点
-                this._nodes.push(node);
-            }
-            else {
-                // 不是根节点，找到父节点并建立关系
-                const parentKey = item[this.parentKeyField];
-                const parentNode = this.nodeMap.get(parentKey);
-                if (parentNode) {
-                    // 使用 _setParent 方法建立父子关系
-                    node._setParent(parentNode);
-                }
-                else {
-                    console.warn(`Parent node ${parentKey} not found for item ${key}, treating as root node`);
-                    this._nodes.push(node);
-                }
-            }
-        }
-        // 应用展开深度设置
-        if (this.expendDepth > 0) {
-            this.setExpandForDepth(this._nodes, 0);
-        }
-        // 触发版本更新
-        this._version++;
-    }
-    /**
-     * 获取节点
-     */
-    get nodes() {
-        // 通过访问 _version 让 Svelte 检测到变化
-        void this._version;
-        return this._nodes;
-    }
-    /**
-     * 获取版本号，用于触发 Svelte 响应式更新
-     */
-    get version() {
-        return this._version;
-    }
-    /**
-     * 设置展开层级
-     * @param nodes
-     * @param currentLevel
-     * @protected
-     */
-    setExpandForDepth(nodes, currentLevel) {
-        for (const node of nodes) {
-            node.expand = currentLevel < this.expendDepth;
-            // if (node.getInternalChildren().length > 0) {
-            //     this.setExpandForDepth(node.getInternalChildren(), currentLevel + 1);
-            // }
-        }
-    }
-    /**
-     * 获取展开的展示列表
-     * @returns 展开的所有节点（按层级顺序）
-     */
-    getHierarchyList() {
-        let arr = [];
-        this.addExpandNodesToList(this._nodes, arr);
-        return arr;
-    }
-    /**
-     * 将展开的节点添加到列表
-     * @param nodes 节点数组
-     * @param list 结果列表
-     * @private
-     */
-    addExpandNodesToList(nodes, list) {
-        for (let node of nodes) {
-            list.push(node);
-            if (node.expand) {
-                this.addExpandNodesToList(node.children ?? [], list);
-            }
-        }
-    }
-    /**
-     * 增加一个新节点（便捷方法，会自动根据 parentKeyField 找到父节点）
-     * @param item 要添加的节点数据
-     */
-    append(item) {
-        if (parent) {
-            if (this.checkIsRoot(item)) {
-                let node = new TreeNode(item, this);
-                this._nodes.push(node);
-                this._version++;
-                return node;
-            }
-            else {
-                throw new Error(`the entity is not a root data`);
-            }
-        }
-        else {
-            let parent = this._findNodeFromList(this.nodes, item, this.parentKeyField);
-            if (!parent) {
-                let node = new TreeNode(item, this, parent);
-                this._version++;
-                return node;
-            }
-            else {
-                throw new Error(`cannot find the parent.`);
-            }
-        }
-    }
-    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[matchedKey]) {
-                    found = node;
-                }
-                else {
-                    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/forwardAllEvents.d.ts

@@ -1,3 +0,0 @@
-export declare function forwardAllEvents<T extends HTMLElement>(node: T, props: Record<string, any>, internalHandlers?: Partial<Record<string, (e: Event) => void>>): {
-    destroy(): void;
-};

package/dist/lib/forwardAllEvents.js

@@ -1,24 +0,0 @@
-// forwardAllEvents.ts
-export function forwardAllEvents(node, props, internalHandlers = {}) {
-    const removeFns = [];
-    Object.keys(props).forEach(key => {
-        if (key.startsWith("on") && typeof props[key] === "function") {
-            const eventName = key.slice(2).toLowerCase(); // onblur -> blur
-            const externalHandler = props[key];
-            const internalHandler = internalHandlers[eventName];
-            const listener = (e) => {
-                // 先执行内部逻辑
-                internalHandler?.(e);
-                // 再执行外部逻辑
-                externalHandler?.(e);
-            };
-            node.addEventListener(eventName, listener);
-            removeFns.push(() => node.removeEventListener(eventName, listener));
-        }
-    });
-    return {
-        destroy() {
-            removeFns.forEach(fn => fn());
-        }
-    };
-}