@ng-nest/ui 15.0.20 → 16.0.1

package/esm2022/tree/tree.module.mjs

@@ -0,0 +1,55 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { XTreeComponent } from './tree.component';
+import { XTreeNodeComponent } from './tree-node.component';
+import { XIconModule } from '@ng-nest/ui/icon';
+import { XCheckboxModule } from '@ng-nest/ui/checkbox';
+import { XOutletModule } from '@ng-nest/ui/outlet';
+import { XLinkModule } from '@ng-nest/ui/link';
+import { XTreeProperty, XTreeNodeProperty } from './tree.property';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+import { XKeywordModule } from '@ng-nest/ui/keyword';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import * as i0 from "@angular/core";
+class XTreeModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: XTreeModule, declarations: [XTreeComponent, XTreeNodeComponent, XTreeProperty, XTreeNodeProperty], imports: [CommonModule,
+            FormsModule,
+            DragDropModule,
+            XIconModule,
+            XCheckboxModule,
+            XOutletModule,
+            XLinkModule,
+            ScrollingModule,
+            XKeywordModule], exports: [XTreeComponent, XTreeNodeComponent] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeModule, imports: [CommonModule,
+            FormsModule,
+            DragDropModule,
+            XIconModule,
+            XCheckboxModule,
+            XOutletModule,
+            XLinkModule,
+            ScrollingModule,
+            XKeywordModule] }); }
+}
+export { XTreeModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [XTreeComponent, XTreeNodeComponent, XTreeProperty, XTreeNodeProperty],
+                    exports: [XTreeComponent, XTreeNodeComponent],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        DragDropModule,
+                        XIconModule,
+                        XCheckboxModule,
+                        XOutletModule,
+                        XLinkModule,
+                        ScrollingModule,
+                        XKeywordModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tree/tree.property.mjs

@@ -0,0 +1,337 @@
+import { __decorate } from "tslib";
+import { XDataConvert, XProperty, XInputBoolean, XInputNumber, XWithConfig } from '@ng-nest/ui/core';
+import { Input, Output, EventEmitter, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Tree
+ * @selector x-tree
+ * @decorator component
+ */
+export const XTreePrefix = 'x-tree';
+const X_CONFIG_NAME = 'tree';
+/**
+ * Tree Property
+ */
+class XTreeProperty extends XProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 节点数据
+         * @en_US Node data
+         */
+        this.data = [];
+        /**
+         * @zh_CN 展开的节点
+         * @en_US Expanded node
+         */
+        this.expanded = [];
+        /**
+         * @zh_CN checkbox 选中的节点
+         * @en_US Checkbox selected node
+         */
+        this.checked = [];
+        /**
+         * @zh_CN 默认展开的层级
+         * @en_US Default expanded level
+         */
+        this.expandedLevel = -1;
+        /**
+         * @zh_CN 当前点击选中的节点变化的事件
+         * @en_US The event of the currently clicked node change
+         */
+        this.activatedChange = new EventEmitter();
+        /**
+         * @zh_CN 使用 checkedbox 选中变化的事件
+         * @en_US Use checkedbox to select changed events
+         */
+        this.checkboxChange = new EventEmitter();
+        /**
+         * @zh_CN 如果 data 是函数类型，可以通过此参数控制请求，常用于弹框中的表格，弹出后再请求
+         * @en_US If data is a function type, you can use this parameter to control the request, which is often used in the form in the pop-up box, and then request it after it pops up
+         */
+        this.manual = true;
+        /**
+         * @zh_CN checkbox 状态改变触发层级检查
+         * @en_US Checkbox status changes trigger level checks
+         */
+        this.levelCheck = true;
+        /**
+         * @zh_CN 节点内容不换行显示省略号
+         * @en_US Show ellipsis without wrapping
+         */
+        this.nodeNowrap = true;
+        /**
+         * @zh_CN 树节点操作按钮
+         * @en_US Tree node operation buttons
+         */
+        this.actions = [];
+        /**
+         * @zh_CN 超出可视窗口缓冲区的最小值，对应 cdk scroll 中的参数，开启虚拟滚动才生效
+         * @en_US Exceed the minimum value of the visible window buffer, corresponding to the parameters in cdk scroll
+         */
+        this.minBufferPx = 100;
+        /**
+         * @zh_CN 渲染新数据缓冲区的像素，对应 cdk scroll 中的参数，开启虚拟滚动才生效
+         * @en_US Render the pixels of the new data buffer, corresponding to the parameters in cdk scroll
+         */
+        this.maxBufferPx = 200;
+        /**
+         * @zh_CN 参数控制请求改变事件
+         * @en_US Parameter control request change event
+         */
+        this.manualChange = new EventEmitter();
+        /**
+         * @zh_CN 节点点击事件
+         * @en_US Node click event
+         */
+        this.nodeClick = new EventEmitter();
+        /**
+         * @zh_CN 节点点击事件
+         * @en_US Node click event
+         */
+        this.activatedIdChange = new EventEmitter();
+        /**
+         * @zh_CN 节点开始拖动事件
+         * @en_US Node drag started
+         */
+        this.nodeDragStarted = new EventEmitter();
+        /**
+         * @zh_CN 节点结束拖动事件
+         * @en_US Node drag ended
+         */
+        this.nodeDragEnded = new EventEmitter();
+        /**
+         * @zh_CN 节点正在拖动事件
+         * @en_US Node drag moved
+         */
+        this.nodeDragMoved = new EventEmitter();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeProperty, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XTreeProperty, selector: "x-tree-property", inputs: { data: "data", checkbox: "checkbox", lazy: "lazy", activatedId: "activatedId", expanded: "expanded", checked: "checked", expandedAll: "expandedAll", expandedLevel: "expandedLevel", nodeOpen: "nodeOpen", spacing: "spacing", labelTpl: "labelTpl", nodeHeight: "nodeHeight", allowManyActivated: "allowManyActivated", drag: "drag", manual: "manual", levelCheck: "levelCheck", nodeNowrap: "nodeNowrap", nodeAlignItems: "nodeAlignItems", actions: "actions", scrollElement: "scrollElement", virtualScroll: "virtualScroll", virtualScrollHeight: "virtualScrollHeight", heightAdaption: "heightAdaption", itemSize: "itemSize", minBufferPx: "minBufferPx", maxBufferPx: "maxBufferPx", multiple: "multiple", objectArray: "objectArray", keywordText: "keywordText", caseSensitive: "caseSensitive", onlyLeaf: "onlyLeaf", expandedIcon: "expandedIcon", showLine: "showLine" }, outputs: { activatedChange: "activatedChange", checkboxChange: "checkboxChange", manualChange: "manualChange", nodeClick: "nodeClick", activatedIdChange: "activatedIdChange", nodeDragStarted: "nodeDragStarted", nodeDragEnded: "nodeDragEnded", nodeDragMoved: "nodeDragMoved" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+__decorate([
+    XDataConvert()
+], XTreeProperty.prototype, "data", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "checkbox", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "lazy", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "expandedAll", void 0);
+__decorate([
+    XInputNumber()
+], XTreeProperty.prototype, "expandedLevel", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "nodeOpen", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 1.5),
+    XInputNumber()
+], XTreeProperty.prototype, "spacing", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 0),
+    XInputNumber()
+], XTreeProperty.prototype, "nodeHeight", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "allowManyActivated", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "drag", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "manual", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "levelCheck", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "nodeNowrap", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 'center')
+], XTreeProperty.prototype, "nodeAlignItems", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME),
+    XInputBoolean()
+], XTreeProperty.prototype, "virtualScroll", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 400),
+    XInputNumber()
+], XTreeProperty.prototype, "virtualScrollHeight", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 26),
+    XInputNumber()
+], XTreeProperty.prototype, "itemSize", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "multiple", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeProperty.prototype, "objectArray", void 0);
+__decorate([
+    XInputBoolean(),
+    XWithConfig(X_CONFIG_NAME, true)
+], XTreeProperty.prototype, "caseSensitive", void 0);
+__decorate([
+    XInputBoolean(),
+    XWithConfig(X_CONFIG_NAME, false)
+], XTreeProperty.prototype, "onlyLeaf", void 0);
+__decorate([
+    XInputBoolean(),
+    XWithConfig(X_CONFIG_NAME, false)
+], XTreeProperty.prototype, "showLine", void 0);
+export { XTreeProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeProperty, decorators: [{
+            type: Component,
+            args: [{ selector: `${XTreePrefix}-property`, template: '' }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], checkbox: [{
+                type: Input
+            }], lazy: [{
+                type: Input
+            }], activatedId: [{
+                type: Input
+            }], expanded: [{
+                type: Input
+            }], checked: [{
+                type: Input
+            }], expandedAll: [{
+                type: Input
+            }], expandedLevel: [{
+                type: Input
+            }], nodeOpen: [{
+                type: Input
+            }], spacing: [{
+                type: Input
+            }], labelTpl: [{
+                type: Input
+            }], nodeHeight: [{
+                type: Input
+            }], allowManyActivated: [{
+                type: Input
+            }], drag: [{
+                type: Input
+            }], activatedChange: [{
+                type: Output
+            }], checkboxChange: [{
+                type: Output
+            }], manual: [{
+                type: Input
+            }], levelCheck: [{
+                type: Input
+            }], nodeNowrap: [{
+                type: Input
+            }], nodeAlignItems: [{
+                type: Input
+            }], actions: [{
+                type: Input
+            }], scrollElement: [{
+                type: Input
+            }], virtualScroll: [{
+                type: Input
+            }], virtualScrollHeight: [{
+                type: Input
+            }], heightAdaption: [{
+                type: Input
+            }], itemSize: [{
+                type: Input
+            }], minBufferPx: [{
+                type: Input
+            }], maxBufferPx: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], objectArray: [{
+                type: Input
+            }], keywordText: [{
+                type: Input
+            }], caseSensitive: [{
+                type: Input
+            }], onlyLeaf: [{
+                type: Input
+            }], expandedIcon: [{
+                type: Input
+            }], showLine: [{
+                type: Input
+            }], manualChange: [{
+                type: Output
+            }], nodeClick: [{
+                type: Output
+            }], activatedIdChange: [{
+                type: Output
+            }], nodeDragStarted: [{
+                type: Output
+            }], nodeDragEnded: [{
+                type: Output
+            }], nodeDragMoved: [{
+                type: Output
+            }] } });
+/**
+ * TreeNode
+ * @selector x-tree-node
+ * @decorator directive
+ */
+export const XTreeNodePrefix = 'x-tree-node';
+/**
+ * TreeNode Property
+ */
+class XTreeNodeProperty extends XProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 节点数据
+         * @en_US Node data
+         */
+        this.node = {};
+        /**
+         * @zh_CN 节点的高度，单位 rem
+         * @en_US The height of the node in rem
+         */
+        this.nodeHeight = 0;
+        /**
+         * @zh_CN 节点垂直对齐方式
+         * @en_US Show ellipsis without wrapping
+         */
+        this.nodeAlignItems = 'center';
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeNodeProperty, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XTreeNodeProperty, selector: "x-tree-node-property", inputs: { node: "node", level: "level", lazy: "lazy", nodeHeight: "nodeHeight", nodeNowrap: "nodeNowrap", nodeAlignItems: "nodeAlignItems", lazyData: "lazyData", virtualScroll: "virtualScroll" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+__decorate([
+    XInputBoolean()
+], XTreeNodeProperty.prototype, "lazy", void 0);
+__decorate([
+    XInputNumber()
+], XTreeNodeProperty.prototype, "nodeHeight", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeNodeProperty.prototype, "nodeNowrap", void 0);
+__decorate([
+    XInputBoolean()
+], XTreeNodeProperty.prototype, "virtualScroll", void 0);
+export { XTreeNodeProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeNodeProperty, decorators: [{
+            type: Component,
+            args: [{ selector: `${XTreeNodePrefix}-property`, template: '' }]
+        }], propDecorators: { node: [{
+                type: Input
+            }], level: [{
+                type: Input
+            }], lazy: [{
+                type: Input
+            }], nodeHeight: [{
+                type: Input
+            }], nodeNowrap: [{
+                type: Input
+            }], nodeAlignItems: [{
+                type: Input
+            }], lazyData: [{
+                type: Input
+            }], virtualScroll: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.property.js","sourceRoot":"","sources":["../../../../../lib/ng-nest/ui/tree/tree.property.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  XDataConvert,\r\n  XProperty,\r\n  XData,\r\n  XInputBoolean,\r\n  XParentIdentityProperty,\r\n  XNumber,\r\n  XBoolean,\r\n  XInputNumber,\r\n  XIdentityProperty,\r\n  XWithConfig,\r\n  XAlign\r\n} from '@ng-nest/ui/core';\r\nimport { Input, TemplateRef, Output, EventEmitter, Component, ElementRef } from '@angular/core';\r\nimport { CdkDragEnd, CdkDragMove, CdkDragStart } from '@angular/cdk/drag-drop';\r\n\r\n/**\r\n * Tree\r\n * @selector x-tree\r\n * @decorator component\r\n */\r\nexport const XTreePrefix = 'x-tree';\r\nconst X_CONFIG_NAME = 'tree';\r\n\r\n/**\r\n * Tree Property\r\n */\r\n@Component({ selector: `${XTreePrefix}-property`, template: '' })\r\nexport class XTreeProperty extends XProperty {\r\n  /**\r\n   * @zh_CN 节点数据\r\n   * @en_US Node data\r\n   */\r\n  @Input() @XDataConvert() data: XData<XTreeNode> = [];\r\n  /**\r\n   * @zh_CN 显示多选框\r\n   * @en_US Show checkbox\r\n   */\r\n  @Input() @XInputBoolean() checkbox?: XBoolean;\r\n  /**\r\n   * @zh_CN 开启懒加载节点，data 必须设置成函数类型\r\n   * @en_US Open lazy loading node, data must be set to function type\r\n   */\r\n  @Input() @XInputBoolean() lazy?: XBoolean;\r\n  /**\r\n   * @zh_CN 当前激活的节点 Id, 当 multiple 为 true 时，值为数组（默认是 Id 数组，objectArray 为 true，对象数组）\r\n   * @en_US Currently active node Id. When Multiple is true, the value is the Id array\r\n   */\r\n  @Input() activatedId: any;\r\n  /**\r\n   * @zh_CN 展开的节点\r\n   * @en_US Expanded node\r\n   */\r\n  @Input() expanded: any[] = [];\r\n  /**\r\n   * @zh_CN checkbox 选中的节点\r\n   * @en_US Checkbox selected node\r\n   */\r\n  @Input() checked: any[] = [];\r\n  /**\r\n   * @zh_CN 展开所有节点\r\n   * @en_US Expand all nodes\r\n   */\r\n  @Input() @XInputBoolean() expandedAll?: XBoolean;\r\n  /**\r\n   * @zh_CN 默认展开的层级\r\n   * @en_US Default expanded level\r\n   */\r\n  @Input() @XInputNumber() expandedLevel: XNumber = -1;\r\n  /**\r\n   * @zh_CN 点击节点就触发展开/收起的操作，请确保节点上没有其它操作（checkbox、自定义的操作按钮）\r\n   * @en_US Click the node to trigger the expand/collapse operation, please make sure that there are no other operations on the node (checkbox, custom operation button)\r\n   */\r\n  @Input() @XInputBoolean() nodeOpen?: XBoolean;\r\n  /**\r\n   * @zh_CN 单位间距，这个与层级的乘积算出节点的左边距，单位 rem\r\n   * @en_US Unit spacing, the product of this and the level calculates the left margin of the node, the unit is rem\r\n   */\r\n  @Input() @XWithConfig<XNumber>(X_CONFIG_NAME, 1.5) @XInputNumber() spacing?: XNumber;\r\n  /**\r\n   * @zh_CN 标签自定义模板\r\n   * @en_US Label custom template\r\n   */\r\n  @Input() labelTpl?: TemplateRef<void>;\r\n  /**\r\n   * @zh_CN 节点的高度，单位 rem, 默认 0 是自适应高度\r\n   * @en_US The height of the node in rem\r\n   */\r\n  @Input() @XWithConfig<XNumber>(X_CONFIG_NAME, 0) @XInputNumber() nodeHeight!: XNumber;\r\n  /**\r\n   * @zh_CN 是否允许多次点击一个节点触发多次事件\r\n   * @en_US Whether to allow multiple clicks on a node to trigger multiple events\r\n   */\r\n  @Input() @XInputBoolean() allowManyActivated?: XBoolean;\r\n  /**\r\n   * @zh_CN 拖动节点\r\n   * @en_US Drag node\r\n   */\r\n  @Input() @XInputBoolean() drag?: XBoolean;\r\n  /**\r\n   * @zh_CN 当前点击选中的节点变化的事件\r\n   * @en_US The event of the currently clicked node change\r\n   */\r\n  @Output() activatedChange = new EventEmitter<XTreeNode>();\r\n  /**\r\n   * @zh_CN 使用 checkedbox 选中变化的事件\r\n   * @en_US Use checkedbox to select changed events\r\n   */\r\n  @Output() checkboxChange = new EventEmitter<XTreeNode>();\r\n  /**\r\n   * @zh_CN 如果 data 是函数类型，可以通过此参数控制请求，常用于弹框中的表格，弹出后再请求\r\n   * @en_US If data is a function type, you can use this parameter to control the request, which is often used in the form in the pop-up box, and then request it after it pops up\r\n   */\r\n  @Input() @XInputBoolean() manual: boolean = true;\r\n  /**\r\n   * @zh_CN checkbox 状态改变触发层级检查\r\n   * @en_US Checkbox status changes trigger level checks\r\n   */\r\n  @Input() @XInputBoolean() levelCheck: XBoolean = true;\r\n  /**\r\n   * @zh_CN 节点内容不换行显示省略号\r\n   * @en_US Show ellipsis without wrapping\r\n   */\r\n  @Input() @XInputBoolean() nodeNowrap: XBoolean = true;\r\n  /**\r\n   * @zh_CN 节点垂直对齐方式\r\n   * @en_US Show ellipsis without wrapping\r\n   */\r\n  @Input() @XWithConfig<XAlign>(X_CONFIG_NAME, 'center') nodeAlignItems!: XAlign;\r\n  /**\r\n   * @zh_CN 树节点操作按钮\r\n   * @en_US Tree node operation buttons\r\n   */\r\n  @Input() actions: XTreeAction[] = [];\r\n  /**\r\n   * @zh_CN 滚动区域元素\r\n   * @en_US Rolling area element\r\n   */\r\n  @Input() scrollElement?: HTMLElement;\r\n  /**\r\n   * @zh_CN 开启虚拟滚动\r\n   * @en_US Turn on virtual scrolling\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME) @XInputBoolean() virtualScroll!: XBoolean;\r\n  /**\r\n   * @zh_CN 滚动区域高度，开启虚拟滚动的时候生效\r\n   * @en_US Rolling area height\r\n   */\r\n  @Input() @XWithConfig<number>(X_CONFIG_NAME, 400) @XInputNumber() virtualScrollHeight!: number;\r\n  /**\r\n   * @zh_CN 虚拟滚动高度自适应指定元素\r\n   * @en_US virtual rolling height follows the specified object\r\n   */\r\n  @Input() heightAdaption!: ElementRef<HTMLElement> | HTMLElement;\r\n  /**\r\n   * @zh_CN itemSize，对应 cdk scroll 中的参数，开启虚拟滚动才生效\r\n   * @en_US itemSize，corresponding to the parameters in cdk scroll\r\n   */\r\n  @Input() @XWithConfig<number>(X_CONFIG_NAME, 26) @XInputNumber() itemSize!: number;\r\n  /**\r\n   * @zh_CN 超出可视窗口缓冲区的最小值，对应 cdk scroll 中的参数，开启虚拟滚动才生效\r\n   * @en_US Exceed the minimum value of the visible window buffer, corresponding to the parameters in cdk scroll\r\n   */\r\n  @Input() minBufferPx: number = 100;\r\n  /**\r\n   * @zh_CN 渲染新数据缓冲区的像素，对应 cdk scroll 中的参数，开启虚拟滚动才生效\r\n   * @en_US Render the pixels of the new data buffer, corresponding to the parameters in cdk scroll\r\n   */\r\n  @Input() maxBufferPx: number = 200;\r\n  /**\r\n   * @zh_CN 多选功能，当前激活的节点可以是多个\r\n   * @en_US Multiple choice\r\n   */\r\n  @Input() @XInputBoolean() multiple?: XBoolean;\r\n  /**\r\n   * @zh_CN 当开启多选的时候，activatedId 的值为对象数组\r\n   * @en_US When multiple selection is enabled, the value of activatedId is an array of objects\r\n   */\r\n  @Input() @XInputBoolean() objectArray?: XBoolean;\r\n  /**\r\n   * @zh_CN 关键字高亮，针对下拉树搜索\r\n   * @en_US Keyword highlighting\r\n   */\r\n  @Input() keywordText!: string | string[];\r\n  /**\r\n   * @zh_CN 匹配关键字区分大小写，针对下拉树搜索\r\n   * @en_US Case-sensitive\r\n   */\r\n  @Input() @XInputBoolean() @XWithConfig<XBoolean>(X_CONFIG_NAME, true) caseSensitive!: XBoolean;\r\n  /**\r\n   * @zh_CN 只能选择叶子节点\r\n   * @en_US Only leaf nodes can be selected\r\n   */\r\n  @Input() @XInputBoolean() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) onlyLeaf!: XBoolean;\r\n  /**\r\n   * @zh_CN 展开收起的图标自定义模版\r\n   * @en_US Expand the folded icon custom template\r\n   */\r\n  @Input() expandedIcon?: TemplateRef<void>;\r\n  /**\r\n   * @zh_CN 显示连接线\r\n   * @en_US Show line\r\n   */\r\n  @Input() @XInputBoolean() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) showLine!: XBoolean;\r\n  /**\r\n   * @zh_CN 参数控制请求改变事件\r\n   * @en_US Parameter control request change event\r\n   */\r\n  @Output() manualChange = new EventEmitter<boolean>();\r\n  /**\r\n   * @zh_CN 节点点击事件\r\n   * @en_US Node click event\r\n   */\r\n  @Output() nodeClick = new EventEmitter<XTreeNode>();\r\n  /**\r\n   * @zh_CN 节点点击事件\r\n   * @en_US Node click event\r\n   */\r\n  @Output() activatedIdChange = new EventEmitter<any>();\r\n  /**\r\n   * @zh_CN 节点开始拖动事件\r\n   * @en_US Node drag started\r\n   */\r\n  @Output() nodeDragStarted = new EventEmitter<XTreeNodeDragEvent>();\r\n  /**\r\n   * @zh_CN 节点结束拖动事件\r\n   * @en_US Node drag ended\r\n   */\r\n  @Output() nodeDragEnded = new EventEmitter<XTreeNodeDragEvent>();\r\n  /**\r\n   * @zh_CN 节点正在拖动事件\r\n   * @en_US Node drag moved\r\n   */\r\n  @Output() nodeDragMoved = new EventEmitter<XTreeNodeDragEvent>();\r\n}\r\n\r\n/**\r\n * @zh_CN Tree 数据对象\r\n * @en_US Tree data object\r\n */\r\nexport interface XTreeNode extends XParentIdentityProperty<XTreeNode> {\r\n  /**\r\n   * @zh_CN 激活的\r\n   * @en_US active\r\n   */\r\n  activated?: boolean;\r\n  /**\r\n   * @zh_CN 检查更新\r\n   * @en_US Check for updates\r\n   */\r\n  change?: Function;\r\n  /**\r\n   * @zh_CN checkbox 是否选中\r\n   * @en_US whether checkbox is selected\r\n   */\r\n  checked?: boolean;\r\n  /**\r\n   * @zh_CN 禁用checkbox\r\n   * @en_US Disable checkbox\r\n   */\r\n  disabled?: boolean;\r\n  /**\r\n   * @zh_CN checkbox 子节点是否有选中的状态\r\n   * @en_US Whether the child node of checkbox is selected\r\n   */\r\n  indeterminate?: boolean;\r\n  /**\r\n   * @zh_CN 节点高度，优先级高于 tree 参数，单位 rem\r\n   * @en_US Node height in rem, highest priority\r\n   */\r\n  height?: number;\r\n  /**\r\n   * @zh_CN 节点内容不换行显示省略号，优先级高于 tree 参数\r\n   * @en_US Show ellipsis without wrapping, highest priority\r\n   */\r\n  nowrap?: boolean;\r\n  /**\r\n   * @zh_CN 节点垂直对齐方式，优先级高于 tree 参数\r\n   * @en_US Show ellipsis without wrapping, highest priority\r\n   */\r\n  alignItems?: XAlign;\r\n  /**\r\n   * @zh_CN 节点懒加载中\r\n   * @en_US Node lazy loading\r\n   */\r\n  loading?: boolean;\r\n  /**\r\n   * @zh_CN 显示拖动指示器\r\n   * @en_US Show drag indicator\r\n   */\r\n  showDragIndicator?: boolean;\r\n  /**\r\n   * @zh_CN 自定义属性\r\n   * @en_US Custom attributes\r\n   */\r\n  [property: string]: any;\r\n}\r\n\r\n/**\r\n * @zh_CN Tree 节点操作\r\n * @en_US Tree node operation\r\n */\r\nexport interface XTreeAction extends XIdentityProperty {\r\n  /**\r\n   * @zh_CN 操作\r\n   * @en_US Operating\r\n   */\r\n  handler?: Function;\r\n  /**\r\n   * @zh_CN 图标\r\n   * @en_US Icon\r\n   */\r\n  icon?: string;\r\n}\r\n\r\n/**\r\n * @zh_CN Tree 节点拖动事件\r\n * @en_US Tree node drag event\r\n */\r\nexport interface XTreeNodeDragEvent {\r\n  /**\r\n   * @zh_CN 对应 cdk 中的事件\r\n   * @en_US drag cdk event\r\n   */\r\n  event?: CdkDragStart | CdkDragEnd | CdkDragMove<XTreeNode>;\r\n  /**\r\n   * @zh_CN 拖动的节点\r\n   * @en_US drag node\r\n   */\r\n  from?: XTreeNode;\r\n  /**\r\n   * @zh_CN 要拖动到的位置对应的节点\r\n   * @en_US Node corresponding to the position to drag\r\n   */\r\n  to?: XTreeNode;\r\n  /**\r\n   * @zh_CN 对应节点的前面还是后面\r\n   * @en_US The front or back of the corresponding node\r\n   */\r\n  position?: -1 | 1;\r\n}\r\n\r\n/**\r\n * TreeNode\r\n * @selector x-tree-node\r\n * @decorator directive\r\n */\r\nexport const XTreeNodePrefix = 'x-tree-node';\r\n\r\n/**\r\n * TreeNode Property\r\n */\r\n@Component({ selector: `${XTreeNodePrefix}-property`, template: '' })\r\nexport class XTreeNodeProperty extends XProperty {\r\n  /**\r\n   * @zh_CN 节点数据\r\n   * @en_US Node data\r\n   */\r\n  @Input() node: XTreeNode = {};\r\n  /**\r\n   * @zh_CN 层级\r\n   * @en_US Level\r\n   */\r\n  @Input() level?: XNumber;\r\n  /**\r\n   * @zh_CN 懒加载子节点\r\n   * @en_US Lazy loading of child nodes\r\n   */\r\n  @Input() @XInputBoolean() lazy?: XBoolean;\r\n  /**\r\n   * @zh_CN 节点的高度，单位 rem\r\n   * @en_US The height of the node in rem\r\n   */\r\n  @Input() @XInputNumber() nodeHeight: XNumber = 0;\r\n  /**\r\n   * @zh_CN 节点内容不换行显示省略号\r\n   * @en_US Show ellipsis without wrapping\r\n   */\r\n  @Input() @XInputBoolean() nodeNowrap?: XBoolean;\r\n  /**\r\n   * @zh_CN 节点垂直对齐方式\r\n   * @en_US Show ellipsis without wrapping\r\n   */\r\n  @Input() nodeAlignItems: XAlign = 'center';\r\n  /**\r\n   * @zh_CN 懒加载函数\r\n   * @en_US Lazy loading function\r\n   */\r\n  @Input() lazyData!: XData<XTreeNode[]>;\r\n  /**\r\n   * @zh_CN 标记为虚拟滚动的节点\r\n   * @en_US Mark as a node of virtual rolling\r\n   */\r\n  @Input() @XInputBoolean() virtualScroll?: XBoolean;\r\n}\r\n"]}

package/esm2022/tree/tree.service.mjs

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import { XIsEmpty, XRemove } from '@ng-nest/ui/core';
+import * as i0 from "@angular/core";
+class XTreeService {
+    getChildren(data, node) {
+        const res = [];
+        const gChildren = (nd) => {
+            const children = data.filter((x) => x.pid === nd.id);
+            if (XIsEmpty(children))
+                return;
+            for (let child of children) {
+                res.push(child);
+                gChildren(child);
+            }
+        };
+        gChildren(node);
+        return res;
+    }
+    getParents(data, node) {
+        const res = [];
+        const gParent = (nd) => {
+            if (!nd.pid)
+                return;
+            const parent = data.find((x) => x.id === nd.pid);
+            if (!parent)
+                return;
+            res.push(parent);
+            gParent(parent);
+        };
+        gParent(node);
+        return res;
+    }
+    getOpenChildren(data, node) {
+        const res = [];
+        const gChildren = (nd) => {
+            if (!nd.open)
+                return;
+            const children = data.filter((x) => x.pid === nd.id);
+            if (XIsEmpty(children))
+                return;
+            for (let child of children) {
+                res.push(child);
+                gChildren(child);
+            }
+        };
+        gChildren(node);
+        return res;
+    }
+    moveNode(data, from, to, pos) {
+        if (XIsEmpty(data))
+            return;
+        const formIndex = data.findIndex((x) => x.id === from.id);
+        const toIndex = data.findIndex((x) => x.id === to.id);
+        XRemove(data, (x) => x.id === from.id);
+        if (from.pid === to.pid) {
+            const index = toIndex > formIndex ? toIndex - 1 : toIndex;
+            data.splice(pos === -1 ? index : index + 1, 0, from);
+        }
+        else if (from.pid !== to.pid) {
+            from.pid = to.pid;
+            const diffLevel = to.level - from.level;
+            from.level = to.level;
+            const fromChildren = this.getChildren(data, from);
+            fromChildren.forEach((x) => {
+                x.level = x.level + diffLevel;
+            });
+            const index = toIndex > formIndex ? toIndex - 1 : toIndex;
+            data.splice(pos === -1 ? index : index + 1, 0, from);
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeService }); }
+}
+export { XTreeService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTreeService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/tree-file/ng-nest-ui-tree-file.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctbmVzdC11aS10cmVlLWZpbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvbmctbmVzdC91aS90cmVlLWZpbGUvbmctbmVzdC11aS10cmVlLWZpbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/tree-file/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './tree-file.component';
+export * from './tree-file.module';
+export * from './tree-file.property';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3RyZWUtZmlsZS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90cmVlLWZpbGUuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi90cmVlLWZpbGUubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi90cmVlLWZpbGUucHJvcGVydHknO1xyXG4iXX0=