@ng-nest/ui 15.0.20 → 16.0.0

package/esm2022/table/table.property.mjs

@@ -0,0 +1,546 @@
+import { __decorate } from "tslib";
+import { XProperty, XInputNumber, XInputBoolean, XWithConfig } from '@ng-nest/ui/core';
+import { Input, Component, EventEmitter, Output } from '@angular/core';
+import { XPaginationProperty } from '@ng-nest/ui/pagination';
+import * as i0 from "@angular/core";
+/**
+ * Table
+ * @selector x-table
+ * @decorator component
+ */
+export const XTablePrefix = 'x-table';
+const X_CONFIG_NAME = 'table';
+/**
+ * Table Property
+ */
+class XTableProperty extends XPaginationProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 行数据
+         * @en_US Row data
+         */
+        this.data = [];
+        /**
+         * @zh_CN 列集合
+         * @en_US Column set
+         */
+        this.columns = [];
+        /**
+         * @zh_CN 当前选中行改变
+         * @en_US The currently selected row changes
+         */
+        this.activatedRowChange = new EventEmitter();
+        /**
+         * @zh_CN 列头自定义模板，通过 key-value 的方式指定每列的模版
+         * @en_US Column header custom template
+         */
+        this.headColumnTpl = {};
+        /**
+         * @zh_CN 列内容自定义模板，通过 key-value 的方式指定每列的模版
+         * @en_US Column content custom template
+         */
+        this.bodyColumnTpl = {};
+        /**
+         * @zh_CN 排序点击的事件
+         * @en_US Sort click events
+         */
+        this.sortChange = new EventEmitter();
+        /**
+         * @zh_CN 列头 checkbox 事件
+         * @en_US head checkbox event
+         */
+        this.headCheckboxChange = new EventEmitter();
+        /**
+         * @zh_CN body checkbox 事件
+         * @en_US head checkbox event
+         */
+        this.bodyCheckboxChange = new EventEmitter();
+        /**
+         * @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 Document height percentage, used by pop-up window percentage height
+         */
+        this.docPercent = 1;
+        /**
+         * @zh_CN checkbox 列初始选中的数据，列中激活 checkbox
+         * @en_US Checkbox column initially selected data, checkbox is activated in column
+         */
+        this.checkedRow = {};
+        /**
+         * @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 参数控制请求改变事件
+         * @en_US Parameter control request change event
+         */
+        this.manualChange = new EventEmitter();
+        /**
+         * @zh_CN 分页器位置
+         * @en_US Pagination position
+         */
+        this.paginationPosition = 'bottom-left';
+        /**
+         * @zh_CN 展开的节点
+         * @en_US Expanded node
+         */
+        this.expanded = [];
+        /**
+         * @zh_CN 列头拖动开始事件，返回拖动的列
+         * @en_US Column Header Drag End Event
+         */
+        this.columnDragStarted = new EventEmitter();
+        /**
+         * @zh_CN 列头拖动结束事件，返回拖动的列
+         * @en_US The column header is dragging, and the event is triggered when the order is changed
+         */
+        this.columnDragEnded = new EventEmitter();
+        /**
+         * @zh_CN 当用户把一个条目投放进该容器时就会触发，拖动放开的事件，返回拖动排序后的列数据
+         * @en_US The column header is dragging, and the event is triggered when the order is changed
+         */
+        this.columnDropListDropped = new EventEmitter();
+        /**
+         * @zh_CN 开始拖动列宽的事件
+         * @en_US Event to started drag column width
+         */
+        this.columnDragWidthStarted = new EventEmitter();
+        /**
+         * @zh_CN 正在拖动列宽时的事件
+         * @en_US Event to moved drag column width
+         */
+        this.columnDragWidthMoved = new EventEmitter();
+        /**
+         * @zh_CN 结束拖动列宽的事件
+         * @en_US Event to ended drag column width
+         */
+        this.columnDragWidthEnded = new EventEmitter();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableProperty, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XTableProperty, selector: "x-table-property", inputs: { data: "data", columns: "columns", rowHeight: "rowHeight", loading: "loading", bordered: "bordered", showHeader: "showHeader", headerPosition: "headerPosition", activatedRow: "activatedRow", headColumnTpl: "headColumnTpl", bodyColumnTpl: "bodyColumnTpl", bodyTdTpl: "bodyTdTpl", rowClass: "rowClass", headSearchTpl: "headSearchTpl", allowSelectRow: "allowSelectRow", allowCheckRow: "allowCheckRow", virtualScroll: "virtualScroll", bodyHeight: "bodyHeight", itemSize: "itemSize", minBufferPx: "minBufferPx", maxBufferPx: "maxBufferPx", adaptionHeight: "adaptionHeight", docPercent: "docPercent", checkedRow: "checkedRow", manual: "manual", scroll: "scroll", header: "header", footer: "footer", cellConfig: "cellConfig", rowSize: "rowSize", paginationPosition: "paginationPosition", hiddenWrapBorder: "hiddenWrapBorder", hiddenPaginationBorder: "hiddenPaginationBorder", showPagination: "showPagination", treeTable: "treeTable", expandedAll: "expandedAll", expandedLevel: "expandedLevel", expanded: "expanded", expandTpl: "expandTpl", showEmpty: "showEmpty", emptyImg: "emptyImg", emptyContent: "emptyContent" }, outputs: { activatedRowChange: "activatedRowChange", sortChange: "sortChange", headCheckboxChange: "headCheckboxChange", bodyCheckboxChange: "bodyCheckboxChange", manualChange: "manualChange", columnDragStarted: "columnDragStarted", columnDragEnded: "columnDragEnded", columnDropListDropped: "columnDropListDropped", columnDragWidthStarted: "columnDragWidthStarted", columnDragWidthMoved: "columnDragWidthMoved", columnDragWidthEnded: "columnDragWidthEnded" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 42),
+    XInputNumber()
+], XTableProperty.prototype, "rowHeight", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, false),
+    XInputBoolean()
+], XTableProperty.prototype, "loading", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, false),
+    XInputBoolean()
+], XTableProperty.prototype, "bordered", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, true),
+    XInputBoolean()
+], XTableProperty.prototype, "showHeader", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 'top')
+], XTableProperty.prototype, "headerPosition", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, true),
+    XInputBoolean()
+], XTableProperty.prototype, "allowSelectRow", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, true),
+    XInputBoolean()
+], XTableProperty.prototype, "allowCheckRow", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME),
+    XInputBoolean()
+], XTableProperty.prototype, "virtualScroll", void 0);
+__decorate([
+    XInputNumber()
+], XTableProperty.prototype, "bodyHeight", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 42),
+    XInputNumber()
+], XTableProperty.prototype, "itemSize", void 0);
+__decorate([
+    XInputNumber()
+], XTableProperty.prototype, "adaptionHeight", void 0);
+__decorate([
+    XInputNumber()
+], XTableProperty.prototype, "docPercent", void 0);
+__decorate([
+    XInputBoolean()
+], XTableProperty.prototype, "manual", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 'medium')
+], XTableProperty.prototype, "rowSize", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, false),
+    XInputBoolean()
+], XTableProperty.prototype, "hiddenWrapBorder", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, false),
+    XInputBoolean()
+], XTableProperty.prototype, "hiddenPaginationBorder", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, true),
+    XInputBoolean()
+], XTableProperty.prototype, "showPagination", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, false),
+    XInputBoolean()
+], XTableProperty.prototype, "treeTable", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, false),
+    XInputBoolean()
+], XTableProperty.prototype, "expandedAll", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, -1),
+    XInputNumber()
+], XTableProperty.prototype, "expandedLevel", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, true),
+    XInputBoolean()
+], XTableProperty.prototype, "showEmpty", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME)
+], XTableProperty.prototype, "emptyImg", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME)
+], XTableProperty.prototype, "emptyContent", void 0);
+export { XTableProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableProperty, decorators: [{
+            type: Component,
+            args: [{ selector: `${XTablePrefix}-property`, template: '' }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], bordered: [{
+                type: Input
+            }], showHeader: [{
+                type: Input
+            }], headerPosition: [{
+                type: Input
+            }], activatedRow: [{
+                type: Input
+            }], activatedRowChange: [{
+                type: Output
+            }], headColumnTpl: [{
+                type: Input
+            }], bodyColumnTpl: [{
+                type: Input
+            }], bodyTdTpl: [{
+                type: Input
+            }], rowClass: [{
+                type: Input
+            }], headSearchTpl: [{
+                type: Input
+            }], sortChange: [{
+                type: Output
+            }], headCheckboxChange: [{
+                type: Output
+            }], bodyCheckboxChange: [{
+                type: Output
+            }], allowSelectRow: [{
+                type: Input
+            }], allowCheckRow: [{
+                type: Input
+            }], virtualScroll: [{
+                type: Input
+            }], bodyHeight: [{
+                type: Input
+            }], itemSize: [{
+                type: Input
+            }], minBufferPx: [{
+                type: Input
+            }], maxBufferPx: [{
+                type: Input
+            }], adaptionHeight: [{
+                type: Input
+            }], docPercent: [{
+                type: Input
+            }], checkedRow: [{
+                type: Input
+            }], manual: [{
+                type: Input
+            }], scroll: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], footer: [{
+                type: Input
+            }], manualChange: [{
+                type: Output
+            }], cellConfig: [{
+                type: Input
+            }], rowSize: [{
+                type: Input
+            }], paginationPosition: [{
+                type: Input
+            }], hiddenWrapBorder: [{
+                type: Input
+            }], hiddenPaginationBorder: [{
+                type: Input
+            }], showPagination: [{
+                type: Input
+            }], treeTable: [{
+                type: Input
+            }], expandedAll: [{
+                type: Input
+            }], expandedLevel: [{
+                type: Input
+            }], expanded: [{
+                type: Input
+            }], expandTpl: [{
+                type: Input
+            }], showEmpty: [{
+                type: Input
+            }], emptyImg: [{
+                type: Input
+            }], emptyContent: [{
+                type: Input
+            }], columnDragStarted: [{
+                type: Output
+            }], columnDragEnded: [{
+                type: Output
+            }], columnDropListDropped: [{
+                type: Output
+            }], columnDragWidthStarted: [{
+                type: Output
+            }], columnDragWidthMoved: [{
+                type: Output
+            }], columnDragWidthEnded: [{
+                type: Output
+            }] } });
+/**
+ * Table Head
+ * @selector x-table-head
+ * @decorator component
+ */
+export const XTableHeadPrefix = 'x-table-head';
+/**
+ * Table Head Property
+ */
+class XTableHeadProperty extends XProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 列集合
+         * @en_US Column set
+         */
+        this.columns = [];
+        /**
+         * @zh_CN 高度，单位 px
+         * @en_US Height in px
+         */
+        this.rowHeight = 42;
+        /**
+         * @zh_CN 自定义模板
+         * @en_US Custom template
+         */
+        this.columnTpl = {};
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableHeadProperty, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XTableHeadProperty, selector: "x-table-head-property", inputs: { columns: "columns", rowHeight: "rowHeight", columnTpl: "columnTpl", scrollYWidth: "scrollYWidth", scrollXWidth: "scrollXWidth", cellConfig: "cellConfig", position: "position" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+__decorate([
+    XInputNumber()
+], XTableHeadProperty.prototype, "rowHeight", void 0);
+export { XTableHeadProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableHeadProperty, decorators: [{
+            type: Component,
+            args: [{ selector: `${XTableHeadPrefix}-property`, template: '' }]
+        }], propDecorators: { columns: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], columnTpl: [{
+                type: Input
+            }], scrollYWidth: [{
+                type: Input
+            }], scrollXWidth: [{
+                type: Input
+            }], cellConfig: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }] } });
+/**
+ * Table Body
+ * @selector x-table-body
+ * @decorator component
+ */
+export const XTableBodyPrefix = 'x-table-body';
+/**
+ * Table Body Property
+ */
+class XTableBodyProperty extends XProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 行数据
+         * @en_US Row data
+         */
+        this.data = [];
+        /**
+         * @zh_CN 列集合
+         * @en_US Column set
+         */
+        this.columns = [];
+        /**
+         * @zh_CN 自定义模板
+         * @en_US Custom template
+         */
+        this.columnTpl = {};
+        /**
+         * @zh_CN 当前选中行改变
+         * @en_US The currently selected row changes
+         */
+        this.activatedRowChange = new EventEmitter();
+        /**
+         * @zh_CN 高度，单位 px。设置为 0 表示行高自适应内容高度。
+         * @en_US Height in px. set to 0 means that the row height is adaptive to the content height
+         */
+        this.rowHeight = 42;
+        /**
+         * @zh_CN 允许行点击选中
+         * @en_US Allow row click to select
+         */
+        this.allowSelectRow = true;
+        /**
+         * @zh_CN 开启虚拟滚动
+         * @en_US Turn on virtual scrolling
+         */
+        this.virtualScroll = false;
+        /**
+         * @zh_CN itemSize，对应 cdk scroll 中的参数
+         * @en_US itemSize，corresponding to the parameters in cdk scroll
+         */
+        this.itemSize = 42;
+        /**
+         * @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 Document height percentage, used by pop-up window percentage height
+         */
+        this.docPercent = 1;
+        /**
+         * @zh_CN 树形表格下的层级
+         * @en_US The level under the tree table
+         */
+        this.level = 0;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableBodyProperty, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XTableBodyProperty, selector: "x-table-body-property", inputs: { data: "data", columns: "columns", columnTpl: "columnTpl", activatedRow: "activatedRow", rowHeight: "rowHeight", bodyHeight: "bodyHeight", allowSelectRow: "allowSelectRow", virtualScroll: "virtualScroll", itemSize: "itemSize", minBufferPx: "minBufferPx", maxBufferPx: "maxBufferPx", adaptionHeight: "adaptionHeight", docPercent: "docPercent", scroll: "scroll", cellConfig: "cellConfig", rowClass: "rowClass", level: "level", expandedAll: "expandedAll", expandTpl: "expandTpl" }, outputs: { activatedRowChange: "activatedRowChange" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+__decorate([
+    XInputNumber()
+], XTableBodyProperty.prototype, "rowHeight", void 0);
+__decorate([
+    XInputNumber()
+], XTableBodyProperty.prototype, "bodyHeight", void 0);
+__decorate([
+    XInputBoolean()
+], XTableBodyProperty.prototype, "allowSelectRow", void 0);
+__decorate([
+    XInputBoolean()
+], XTableBodyProperty.prototype, "virtualScroll", void 0);
+__decorate([
+    XInputNumber()
+], XTableBodyProperty.prototype, "itemSize", void 0);
+__decorate([
+    XInputNumber()
+], XTableBodyProperty.prototype, "adaptionHeight", void 0);
+__decorate([
+    XInputNumber()
+], XTableBodyProperty.prototype, "docPercent", void 0);
+__decorate([
+    XInputBoolean()
+], XTableBodyProperty.prototype, "expandedAll", void 0);
+export { XTableBodyProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableBodyProperty, decorators: [{
+            type: Component,
+            args: [{ selector: `${XTableBodyPrefix}-property`, template: '' }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], columnTpl: [{
+                type: Input
+            }], activatedRow: [{
+                type: Input
+            }], activatedRowChange: [{
+                type: Output
+            }], rowHeight: [{
+                type: Input
+            }], bodyHeight: [{
+                type: Input
+            }], allowSelectRow: [{
+                type: Input
+            }], virtualScroll: [{
+                type: Input
+            }], itemSize: [{
+                type: Input
+            }], minBufferPx: [{
+                type: Input
+            }], maxBufferPx: [{
+                type: Input
+            }], adaptionHeight: [{
+                type: Input
+            }], docPercent: [{
+                type: Input
+            }], scroll: [{
+                type: Input
+            }], cellConfig: [{
+                type: Input
+            }], rowClass: [{
+                type: Input
+            }], level: [{
+                type: Input
+            }], expandedAll: [{
+                type: Input
+            }], expandTpl: [{
+                type: Input
+            }] } });
+/**
+ * Table Foot
+ * @selector x-table-foot
+ * @decorator component
+ */
+export const XTableFootPrefix = 'x-table-foot';
+/**
+ * Table Foot Property
+ */
+class XTableFootProperty extends XProperty {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableFootProperty, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XTableFootProperty, selector: "x-table-foot-property", inputs: { footer: "footer", rowHeight: "rowHeight" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+export { XTableFootProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XTableFootProperty, decorators: [{
+            type: Component,
+            args: [{ selector: `${XTableFootPrefix}-property`, template: '' }]
+        }], propDecorators: { footer: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.property.js","sourceRoot":"","sources":["../../../../../lib/ng-nest/ui/table/table.property.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  XProperty,\r\n  XNumber,\r\n  XInputNumber,\r\n  XSort,\r\n  XInputBoolean,\r\n  XBoolean,\r\n  XData,\r\n  XWithConfig,\r\n  XTextAlign,\r\n  XSize,\r\n  XParentIdentityProperty,\r\n  XIdentityProperty,\r\n  XTemplate\r\n} from '@ng-nest/ui/core';\r\nimport { Input, Component, EventEmitter, TemplateRef, Output } from '@angular/core';\r\nimport { XPaginationProperty, XPaginationOption } from '@ng-nest/ui/pagination';\r\n\r\n/**\r\n * Table\r\n * @selector x-table\r\n * @decorator component\r\n */\r\nexport const XTablePrefix = 'x-table';\r\nconst X_CONFIG_NAME = 'table';\r\n\r\n/**\r\n * Table Property\r\n */\r\n@Component({ selector: `${XTablePrefix}-property`, template: '' })\r\nexport class XTableProperty extends XPaginationProperty implements XTableOption {\r\n  /**\r\n   * @zh_CN 行数据\r\n   * @en_US Row data\r\n   */\r\n  @Input() data: XData<XTableRow> = [];\r\n  /**\r\n   * @zh_CN 列集合\r\n   * @en_US Column set\r\n   */\r\n  @Input() columns: XTableColumn[] = [];\r\n  /**\r\n   * @zh_CN 表头和行高，单位 px\r\n   * @en_US Header and row height, unit px\r\n   */\r\n  @Input() @XWithConfig<number>(X_CONFIG_NAME, 42) @XInputNumber() rowHeight!: number;\r\n  /**\r\n   * @zh_CN 是否启用加载 loading\r\n   * @en_US Whether to enable loading\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) @XInputBoolean() loading!: XBoolean;\r\n  /**\r\n   * @zh_CN 是否展示列边框\r\n   * @en_US Whether to show column borders\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) @XInputBoolean() bordered!: XBoolean;\r\n  /**\r\n   * @zh_CN 是否显示列头\r\n   * @en_US Whether to display the column headers\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, true) @XInputBoolean() showHeader!: XBoolean;\r\n  /**\r\n   * @zh_CN 列头显示位置\r\n   * @en_US Whether to display the column headers\r\n   */\r\n  @Input() @XWithConfig<XTableHeaderPosition>(X_CONFIG_NAME, 'top') headerPosition!: XTableHeaderPosition;\r\n  /**\r\n   * @zh_CN 当前选中行数据\r\n   * @en_US Currently selected row data\r\n   */\r\n  @Input() activatedRow?: XTableRow;\r\n  /**\r\n   * @zh_CN 当前选中行改变\r\n   * @en_US The currently selected row changes\r\n   */\r\n  @Output() activatedRowChange = new EventEmitter<XTableRow>();\r\n  /**\r\n   * @zh_CN 列头自定义模板，通过 key-value 的方式指定每列的模版\r\n   * @en_US Column header custom template\r\n   */\r\n  @Input() headColumnTpl: XTableTemplate = {};\r\n  /**\r\n   * @zh_CN 列内容自定义模板，通过 key-value 的方式指定每列的模版\r\n   * @en_US Column content custom template\r\n   */\r\n  @Input() bodyColumnTpl: XTableTemplate = {};\r\n  /**\r\n   * @zh_CN 单元格的自定义模板，优先级低于列内容自定义模板\r\n   * @en_US Custom template of cells\r\n   */\r\n  @Input() bodyTdTpl?: XTemplate;\r\n  /**\r\n   * @zh_CN 行条件样式\r\n   * @en_US Row condition class\r\n   */\r\n  @Input() rowClass?: (row: XTableRow, index: number) => { [className: string]: boolean };\r\n  /**\r\n   * @zh_CN 列头搜索自定义模板\r\n   * @en_US Line head search custom template\r\n   */\r\n  @Input() headSearchTpl?: XTemplate;\r\n  /**\r\n   * @zh_CN 排序点击的事件\r\n   * @en_US Sort click events\r\n   */\r\n  @Output() sortChange = new EventEmitter<XSort[]>();\r\n  /**\r\n   * @zh_CN 列头 checkbox 事件\r\n   * @en_US head checkbox event\r\n   */\r\n  @Output() headCheckboxChange = new EventEmitter<XTableHeadCheckbox>();\r\n  /**\r\n   * @zh_CN body checkbox 事件\r\n   * @en_US head checkbox event\r\n   */\r\n  @Output() bodyCheckboxChange = new EventEmitter<XTableRow>();\r\n  /**\r\n   * @zh_CN 允许行点击选中当前行\r\n   * @en_US Allow row click to select\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, true) @XInputBoolean() allowSelectRow!: XBoolean;\r\n  /**\r\n   * @zh_CN 允许行点击选中 checkbox\r\n   * @en_US Allow lines to click checkbox\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, true) @XInputBoolean() allowCheckRow!: XBoolean;\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 body 数据高度\r\n   * @en_US body data height\r\n   */\r\n  @Input() @XInputNumber() bodyHeight?: number;\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, 42) @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 自适应高度，table 高度等于屏幕高度减掉此处设置的数值\r\n   * @en_US Adaptive height, table height is equal to the screen height minus the value set here\r\n   */\r\n  @Input() @XInputNumber() adaptionHeight?: XNumber;\r\n  /**\r\n   * @zh_CN 文档高度百分比，弹窗百分比高度用到\r\n   * @en_US Document height percentage, used by pop-up window percentage height\r\n   */\r\n  @Input() @XInputNumber() docPercent: XNumber = 1;\r\n  /**\r\n   * @zh_CN checkbox 列初始选中的数据，列中激活 checkbox\r\n   * @en_US Checkbox column initially selected data, checkbox is activated in column\r\n   */\r\n  @Input() checkedRow: { [property: string]: any[] } = {};\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: XBoolean = true;\r\n  /**\r\n   * @zh_CN 滚动区域高宽\r\n   * @en_US Height and width of rolling area\r\n   */\r\n  @Input() scroll?: { x: number; y: number };\r\n  /**\r\n   * @zh_CN 表格页头\r\n   * @en_US Table header\r\n   */\r\n  @Input() header?: XTemplate;\r\n  /**\r\n   * @zh_CN 表格页尾\r\n   * @en_US Table footer\r\n   */\r\n  @Input() footer?: XTemplate;\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 Cell config\r\n   */\r\n  @Input() cellConfig?: XTableCellConfig;\r\n  /**\r\n   * @zh_CN 尺寸\r\n   * @en_US Size\r\n   */\r\n  @Input() @XWithConfig<XSize>(X_CONFIG_NAME, 'medium') rowSize?: XSize;\r\n  /**\r\n   * @zh_CN 分页器位置\r\n   * @en_US Pagination position\r\n   */\r\n  @Input() paginationPosition: XPaginationPosition = 'bottom-left';\r\n  /**\r\n   * @zh_CN 隐藏表格外边框\r\n   * @en_US Hidden table wrap border\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) @XInputBoolean() hiddenWrapBorder?: XBoolean;\r\n  /**\r\n   * @zh_CN 隐藏分页器按钮边框\r\n   * @en_US Hidden pagination button border\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) @XInputBoolean() hiddenPaginationBorder?: XBoolean;\r\n  /**\r\n   * @zh_CN 显示分页器\r\n   * @en_US Pagination position\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, true) @XInputBoolean() showPagination?: XBoolean;\r\n  /**\r\n   * @zh_CN 树形表格\r\n   * @en_US Tree table\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) @XInputBoolean() treeTable?: XBoolean;\r\n  /**\r\n   * @zh_CN 树形表格展开所有节点\r\n   * @en_US Tree table\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, false) @XInputBoolean() expandedAll?: XBoolean;\r\n  /**\r\n   * @zh_CN 默认展开的层级，-1 不展开\r\n   * @en_US Default expanded level\r\n   */\r\n  @Input() @XWithConfig<XNumber>(X_CONFIG_NAME, -1) @XInputNumber() expandedLevel!: XNumber;\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 自定义展开内容\r\n   * @en_US Customized expansion content\r\n   */\r\n  @Input() expandTpl?: XTemplate;\r\n  /**\r\n   * @zh_CN 显示数据为空的提示\r\n   * @en_US Display a prompt with empty data\r\n   */\r\n  @Input() @XWithConfig<XBoolean>(X_CONFIG_NAME, true) @XInputBoolean() showEmpty?: XBoolean;\r\n\r\n  /**\r\n   * @zh_CN 数据为空的提示图片地址或自定义模板\r\n   * @en_US Picture address or custom template\r\n   */\r\n  @Input() @XWithConfig<XTemplate>(X_CONFIG_NAME) emptyImg?: XTemplate;\r\n  /**\r\n   * @zh_CN 数据为空的提示内容或自定义模板\r\n   * @en_US Content or custom template\r\n   */\r\n  @Input() @XWithConfig<XTemplate>(X_CONFIG_NAME) emptyContent?: XTemplate;\r\n  /**\r\n   * @zh_CN 列头拖动开始事件，返回拖动的列\r\n   * @en_US Column Header Drag End Event\r\n   */\r\n  @Output() columnDragStarted = new EventEmitter<XTableColumn>();\r\n  /**\r\n   * @zh_CN 列头拖动结束事件，返回拖动的列\r\n   * @en_US The column header is dragging, and the event is triggered when the order is changed\r\n   */\r\n  @Output() columnDragEnded = new EventEmitter<XTableColumn>();\r\n  /**\r\n   * @zh_CN 当用户把一个条目投放进该容器时就会触发，拖动放开的事件，返回拖动排序后的列数据\r\n   * @en_US The column header is dragging, and the event is triggered when the order is changed\r\n   */\r\n  @Output() columnDropListDropped = new EventEmitter<XTableColumn[]>();\r\n  /**\r\n   * @zh_CN 开始拖动列宽的事件\r\n   * @en_US Event to started drag column width\r\n   */\r\n  @Output() columnDragWidthStarted = new EventEmitter<XTableDragWidthEvent>();\r\n  /**\r\n   * @zh_CN 正在拖动列宽时的事件\r\n   * @en_US Event to moved drag column width\r\n   */\r\n  @Output() columnDragWidthMoved = new EventEmitter<XTableDragWidthEvent>();\r\n  /**\r\n   * @zh_CN 结束拖动列宽的事件\r\n   * @en_US Event to ended drag column width\r\n   */\r\n  @Output() columnDragWidthEnded = new EventEmitter<XTableDragWidthEvent>();\r\n}\r\n\r\n/**\r\n * Table Option\r\n * @undocument true\r\n */\r\nexport interface XTableOption extends XPaginationOption {\r\n  /**\r\n   * @zh_CN 行数据\r\n   * @en_US Row data\r\n   */\r\n  data?: XData<XTableRow>;\r\n  /**\r\n   * @zh_CN 列集合\r\n   * @en_US Column set\r\n   */\r\n  columns?: XTableColumn[];\r\n  /**\r\n   * @zh_CN 表头和行高，单位 px\r\n   * @en_US Header and row height, unit px\r\n   */\r\n  rowHeight?: number;\r\n  /**\r\n   * @zh_CN 是否启用加载 loading\r\n   * @en_US Whether to enable loading\r\n   */\r\n  loading?: XBoolean;\r\n  /**\r\n   * @zh_CN 当前选中行数据\r\n   * @en_US Currently selected row data\r\n   */\r\n  activatedRow?: XTableRow;\r\n  /**\r\n   * @zh_CN 列头自定义模板\r\n   * @en_US Column header custom template\r\n   */\r\n  headColumnTpl?: XTableTemplate;\r\n  /**\r\n   * @zh_CN 列内容自定义模板\r\n   * @en_US Column content custom template\r\n   */\r\n  bodyColumnTpl?: XTableTemplate;\r\n  /**\r\n   * @zh_CN 行条件样式\r\n   * @en_US Row condition class\r\n   */\r\n  rowClass?: (row: XTableRow, index: number) => { [className: string]: boolean };\r\n  /**\r\n   * @zh_CN 开启虚拟滚动\r\n   * @en_US Turn on virtual scrolling\r\n   */\r\n  virtualScroll?: XBoolean;\r\n  /**\r\n   * @zh_CN body 数据高度\r\n   * @en_US body data height\r\n   */\r\n  bodyHeight?: 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  minBufferPx?: number;\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  maxBufferPx?: number;\r\n  /**\r\n   * @zh_CN 自适应高度，table 高度等于屏幕高度减掉此处设置的数值\r\n   * @en_US Adaptive height, table height is equal to the screen height minus the value set here\r\n   */\r\n  adaptionHeight?: XNumber;\r\n  /**\r\n   * @zh_CN 文档高度百分比，弹窗百分比高度用到\r\n   * @en_US Document height percentage, used by pop-up window percentage height\r\n   */\r\n  docPercent?: XNumber;\r\n  /**\r\n   * @zh_CN 单元格配置\r\n   * @en_US Cell config\r\n   */\r\n  cellConfig?: XTableCellConfig;\r\n  /**\r\n   * @zh_CN 尺寸\r\n   * @en_US Size\r\n   */\r\n  rowSize?: XSize;\r\n}\r\n\r\n/**\r\n * @zh_CN 数据\r\n * @en_US Data\r\n */\r\nexport interface XTableRow extends XParentIdentityProperty<XTableRow> {\r\n  /**\r\n   * @zh_CN 展开\r\n   * @en_US Unfold\r\n   */\r\n  expanded?: 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 列参数\r\n * @en_US Column parameter\r\n */\r\nexport interface XTableColumn extends XIdentityProperty {\r\n  /**\r\n   * @zh_CN 类型\r\n   * @en_US Types of\r\n   */\r\n  type?: XColumnType;\r\n  /**\r\n   * @zh_CN 宽度\r\n   * @en_US Width\r\n   */\r\n  width?: number;\r\n  /**\r\n   * @zh_CN flex 布局宽度\r\n   * @en_US Flex layout width\r\n   */\r\n  flex?: number;\r\n  /**\r\n   * @zh_CN 查询字段\r\n   * @en_US Query field\r\n   */\r\n  search?: boolean;\r\n  /**\r\n   * @zh_CN 排序字段\r\n   * @en_US Sort field\r\n   */\r\n  sort?: boolean;\r\n  /**\r\n   * @zh_CN 固定列，距离左边的距离\r\n   * @en_US Fixed column, distance from left\r\n   */\r\n  left?: number;\r\n  /**\r\n   * @zh_CN 固定列，距离右边的距离\r\n   * @en_US Fixed column, distance from right\r\n   */\r\n  right?: number;\r\n  /**\r\n   * @zh_CN 操作按钮\r\n   * @en_US Operation button\r\n   */\r\n  action?: boolean;\r\n  /**\r\n   * @zh_CN type 为 checkbox 时绑定行点击选中事件\r\n   * @en_US Bind row click selection event when type is checkbox\r\n   */\r\n  rowChecked?: boolean;\r\n  /**\r\n   * @zh_CN type 为 expand 时绑定行点击展开事件\r\n   * @en_US Bind row click selection event when type is expand\r\n   */\r\n  rowExpand?: boolean;\r\n  /**\r\n   * @zh_CN 文字对齐方式\r\n   * @en_US Text alignment\r\n   */\r\n  textAlign?: XTextAlign;\r\n  /**\r\n   * @zh_CN 拖动列宽，需要设置列的初始宽度 width\r\n   * @en_US Drag the column width, you need to set the initial width of the column width\r\n   */\r\n  dragWidth?: boolean;\r\n  /**\r\n   * @zh_CN 正在拖动列宽\r\n   * @en_US Dragging width\r\n   */\r\n  draggingWidth?: boolean;\r\n  /**\r\n   * @zh_CN 开始拖动列宽的事件\r\n   * @en_US Event to started drag column width\r\n   */\r\n  dragWidthStarted?: (event: XTableDragWidthEvent) => void;\r\n  /**\r\n   * @zh_CN 正在拖动列宽时的事件\r\n   * @en_US Event to moved drag column width\r\n   */\r\n  dragWidthMoved?: (event: XTableDragWidthEvent) => void;\r\n  /**\r\n   * @zh_CN 结束拖动列宽的事件\r\n   * @en_US Event to ended drag column width\r\n   */\r\n  dragWidthEnded?: (event: XTableDragWidthEvent) => void;\r\n  /**\r\n   * @zh_CN 拖动列\r\n   * @en_US Drag the column\r\n   */\r\n  dragColumn?: boolean;\r\n  /**\r\n   * @zh_CN 正在拖动列\r\n   * @en_US Dragging column\r\n   */\r\n  dragging?: boolean;\r\n  /**\r\n   * @zh_CN 头部显示 checkbox\r\n   * @en_US Head shows checkbox\r\n   */\r\n  headChecked?: boolean;\r\n  /**\r\n   * @zh_CN 头部显示 expand\r\n   * @en_US Head shows expand\r\n   */\r\n  headExpand?: 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 列头宽度拖动事件\r\n * @en_US Column header width drag event\r\n */\r\nexport interface XTableDragWidthEvent {\r\n  /**\r\n   * @zh_CN 拖动的列\r\n   * @en_US Dragged column\r\n   */\r\n  column: XTableColumn;\r\n  /**\r\n   * @zh_CN 列位置，正在拖动的时候指偏移位置\r\n   * @en_US The column position refers to the offset position when dragging\r\n   */\r\n  position: { x: number; y: number };\r\n}\r\n\r\n/**\r\n * @zh_CN 列头 checkbox 事件数据\r\n * @en_US Column header checkbox event data\r\n */\r\nexport interface XTableHeadCheckbox {\r\n  /**\r\n   * @zh_CN 行数据\r\n   * @en_US Row data\r\n   */\r\n  rows: XTableRow[];\r\n  /**\r\n   * @zh_CN checkbox 数据\r\n   * @en_US Checkbox data\r\n   */\r\n  checkbox: { [property: string]: boolean };\r\n}\r\n\r\n/**\r\n * @zh_CN 单元格配置\r\n * @en_US Cell config\r\n */\r\nexport interface XTableCellConfig {\r\n  /**\r\n   * @zh_CN 列单元格配置\r\n   * @en_US Column cell config\r\n   */\r\n  thead?: XTableCellConfigRule;\r\n  /**\r\n   * @zh_CN 行单元格配置\r\n   * @en_US Row config\r\n   */\r\n  tbody?: XTableCellConfigRule;\r\n}\r\n\r\n/**\r\n * @zh_CN 单元格配置规则\r\n * @en_US Cell config rules\r\n */\r\nexport interface XTableCellConfigRule {\r\n  /**\r\n   * @zh_CN grid 布局下定义列宽度\r\n   * @en_US Define column width under grid layout\r\n   */\r\n  gridTemplateColumns?: string;\r\n  /**\r\n   * @zh_CN 单元格配置\r\n   * @en_US Cell merge rules\r\n   */\r\n  cells?: XTableCell[];\r\n}\r\n\r\n/**\r\n * @zh_CN 单元格合并配置\r\n * @en_US Cell merge rules\r\n */\r\nexport interface XTableCell {\r\n  /**\r\n   * @zh_CN 使用 grid 布局来合并单元格\r\n   * @en_US Use grid layout to merge cells\r\n   */\r\n  gridArea?: string;\r\n  /**\r\n   * @zh_CN 名称\r\n   * @en_US Name\r\n   */\r\n  label?: string;\r\n  /**\r\n   * @zh_CN 宽度\r\n   * @en_US Width\r\n   */\r\n  width?: number;\r\n  /**\r\n   * @zh_CN 固定列，距离左边的距离\r\n   * @en_US Fixed column, distance from left\r\n   */\r\n  left?: number;\r\n  /**\r\n   * @zh_CN 固定列，距离右边的距离\r\n   * @en_US Fixed column, distance from right\r\n   */\r\n  right?: number;\r\n  /**\r\n   * @zh_CN 对应列的 id\r\n   * @en_US The id of the corresponding column\r\n   */\r\n  id?: string;\r\n  /**\r\n   * @zh_CN 拖动列宽\r\n   * @en_US Drag the column width\r\n   */\r\n  dragWidth?: 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 列类型\r\n * @en_US Column type\r\n */\r\nexport type XColumnType = 'label' | 'index' | 'checkbox' | 'expand';\r\n\r\n/**\r\n * @zh_CN 列头显示位置\r\n * @en_US Line head display position\r\n */\r\nexport type XTableHeaderPosition = 'top' | 'bottom' | 'top-bottom';\r\n\r\n/**\r\n * @zh_CN 分页器位置\r\n * @en_US Paging position\r\n */\r\nexport type XPaginationPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';\r\n\r\n/**\r\n * @zh_CN 模板\r\n * @en_US Template\r\n */\r\nexport type XTableTemplate = { [property: string]: TemplateRef<any> };\r\n\r\n/**\r\n * Table Head\r\n * @selector x-table-head\r\n * @decorator component\r\n */\r\nexport const XTableHeadPrefix = 'x-table-head';\r\n\r\n/**\r\n * Table Head Property\r\n */\r\n@Component({ selector: `${XTableHeadPrefix}-property`, template: '' })\r\nexport class XTableHeadProperty extends XProperty {\r\n  /**\r\n   * @zh_CN 列集合\r\n   * @en_US Column set\r\n   */\r\n  @Input() columns: XTableColumn[] = [];\r\n  /**\r\n   * @zh_CN 高度，单位 px\r\n   * @en_US Height in px\r\n   */\r\n  @Input() @XInputNumber() rowHeight: XNumber = 42;\r\n  /**\r\n   * @zh_CN 自定义模板\r\n   * @en_US Custom template\r\n   */\r\n  @Input() columnTpl: XTableTemplate = {};\r\n  /**\r\n   * @zh_CN 竖向滚动条宽度\r\n   * @en_US Vertical scroll bar width\r\n   */\r\n  @Input() scrollYWidth?: number;\r\n  /**\r\n   * @zh_CN 横向滚动条宽度\r\n   * @en_US Horizontal scroll bar width\r\n   */\r\n  @Input() scrollXWidth?: number | null;\r\n  /**\r\n   * @zh_CN 单元格配置\r\n   * @en_US Cell merge rules\r\n   */\r\n  @Input() cellConfig?: XTableCellConfigRule;\r\n  /**\r\n   * @zh_CN 显示的位置\r\n   * @en_US Display position\r\n   */\r\n  @Input() position?: string;\r\n}\r\n\r\n/**\r\n * Table Body\r\n * @selector x-table-body\r\n * @decorator component\r\n */\r\nexport const XTableBodyPrefix = 'x-table-body';\r\n\r\n/**\r\n * Table Body Property\r\n */\r\n@Component({ selector: `${XTableBodyPrefix}-property`, template: '' })\r\nexport class XTableBodyProperty extends XProperty {\r\n  /**\r\n   * @zh_CN 行数据\r\n   * @en_US Row data\r\n   */\r\n  @Input() data: XTableRow[] = [];\r\n  /**\r\n   * @zh_CN 列集合\r\n   * @en_US Column set\r\n   */\r\n  @Input() columns: XTableColumn[] = [];\r\n  /**\r\n   * @zh_CN 自定义模板\r\n   * @en_US Custom template\r\n   */\r\n  @Input() columnTpl: XTableTemplate = {};\r\n  /**\r\n   * @zh_CN 当前选中行数据\r\n   * @en_US Currently selected row data\r\n   */\r\n  @Input() activatedRow?: XTableRow;\r\n  /**\r\n   * @zh_CN 当前选中行改变\r\n   * @en_US The currently selected row changes\r\n   */\r\n  @Output() activatedRowChange = new EventEmitter<XTableRow>();\r\n  /**\r\n   * @zh_CN 高度，单位 px。设置为 0 表示行高自适应内容高度。\r\n   * @en_US Height in px. set to 0 means that the row height is adaptive to the content height\r\n   */\r\n  @Input() @XInputNumber() rowHeight: XNumber = 42;\r\n  /**\r\n   * @zh_CN body 数据高度\r\n   * @en_US body data height\r\n   */\r\n  @Input() @XInputNumber() bodyHeight?: number;\r\n  /**\r\n   * @zh_CN 允许行点击选中\r\n   * @en_US Allow row click to select\r\n   */\r\n  @Input() @XInputBoolean() allowSelectRow: XBoolean = true;\r\n  /**\r\n   * @zh_CN 开启虚拟滚动\r\n   * @en_US Turn on virtual scrolling\r\n   */\r\n  @Input() @XInputBoolean() virtualScroll: XBoolean = false;\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() @XInputNumber() itemSize: number = 42;\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 自适应高度，table 高度等于屏幕高度减掉此处设置的数值\r\n   * @en_US Adaptive height, table height is equal to the screen height minus the value set here\r\n   */\r\n  @Input() @XInputNumber() adaptionHeight?: XNumber;\r\n  /**\r\n   * @zh_CN 文档高度百分比，弹窗百分比高度用到\r\n   * @en_US Document height percentage, used by pop-up window percentage height\r\n   */\r\n  @Input() @XInputNumber() docPercent: XNumber = 1;\r\n  /**\r\n   * @zh_CN 滚动区域高宽\r\n   * @en_US Height and width of rolling area\r\n   */\r\n  @Input() scroll?: { x: number; y: number };\r\n  /**\r\n   * @zh_CN 单元格配置规则\r\n   * @en_US Cell config rules\r\n   */\r\n  @Input() cellConfig?: XTableCellConfigRule;\r\n  /**\r\n   * @zh_CN 行条件样式\r\n   * @en_US Row condition class\r\n   */\r\n  @Input() rowClass?: (row: XTableRow, index: number) => { [className: string]: boolean };\r\n  /**\r\n   * @zh_CN 树形表格下的层级\r\n   * @en_US The level under the tree table\r\n   */\r\n  @Input() level: number = 0;\r\n  /**\r\n   * @zh_CN 树形表格展开所有节点\r\n   * @en_US Tree table\r\n   */\r\n  @Input() @XInputBoolean() expandedAll?: XBoolean;\r\n  /**\r\n   * @zh_CN 自定义展开内容\r\n   * @en_US Customized expansion content\r\n   */\r\n  @Input() expandTpl?: XTemplate;\r\n}\r\n\r\n/**\r\n * Table Foot\r\n * @selector x-table-foot\r\n * @decorator component\r\n */\r\nexport const XTableFootPrefix = 'x-table-foot';\r\n\r\n/**\r\n * Table Foot Property\r\n */\r\n@Component({ selector: `${XTableFootPrefix}-property`, template: '' })\r\nexport class XTableFootProperty extends XProperty {\r\n  /**\r\n   * @zh_CN 表格页尾\r\n   * @en_US Table footer\r\n   */\r\n  @Input() footer?: XTemplate;\r\n  /**\r\n   * @zh_CN 表头和行高，单位 px\r\n   * @en_US Header and row height, unit px\r\n   */\r\n  @Input() rowHeight!: number;\r\n}\r\n"]}

package/esm2022/tabs/ng-nest-ui-tabs.mjs

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

package/esm2022/tabs/public-api.mjs

@@ -0,0 +1,7 @@
+export * from './tabs.component';
+export * from './tab.component';
+export * from './tab-content.component';
+export * from './tab-link.directive';
+export * from './tabs.module';
+export * from './tabs.property';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3RhYnMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RhYnMuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi90YWIuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi90YWItY29udGVudC5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RhYi1saW5rLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdGFicy5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RhYnMucHJvcGVydHknO1xyXG4iXX0=