@ng-nest/ui 12.0.11 → 13.0.3

package/esm2020/table/table.property.mjs

@@ -0,0 +1,375 @@
+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
+ */
+export 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 列头自定义模板
+         * @en_US Column header custom template
+         */
+        this.headColumnTpl = {};
+        /**
+         * @zh_CN 列内容自定义模板
+         * @en_US Column content custom template
+         */
+        this.bodyColumnTpl = {};
+        /**
+         * @zh_CN 排序点击的事件
+         * @en_US Sort click events
+         */
+        this.sortChange = 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();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XTableProperty.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableProperty, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ XTableProperty.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: XTableProperty, selector: "ng-component", inputs: { data: "data", columns: "columns", rowHeight: "rowHeight", loading: "loading", bordered: "bordered", showHeader: "showHeader", activatedRow: "activatedRow", headColumnTpl: "headColumnTpl", bodyColumnTpl: "bodyColumnTpl", allowSelectRow: "allowSelectRow", virtualScroll: "virtualScroll", bodyHeight: "bodyHeight", itemSize: "itemSize", minBufferPx: "minBufferPx", maxBufferPx: "maxBufferPx", adaptionHeight: "adaptionHeight", docPercent: "docPercent", checkedRow: "checkedRow", manual: "manual", scroll: "scroll", cellConfig: "cellConfig", rowSize: "rowSize" }, outputs: { activatedRowChange: "activatedRowChange", sortChange: "sortChange", manualChange: "manualChange" }, 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, true),
+    XInputBoolean()
+], XTableProperty.prototype, "allowSelectRow", 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);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableProperty, decorators: [{
+            type: Component,
+            args: [{ template: '' }]
+        }], propDecorators: { data: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], bordered: [{
+                type: Input
+            }], showHeader: [{
+                type: Input
+            }], activatedRow: [{
+                type: Input
+            }], activatedRowChange: [{
+                type: Output
+            }], headColumnTpl: [{
+                type: Input
+            }], bodyColumnTpl: [{
+                type: Input
+            }], sortChange: [{
+                type: Output
+            }], allowSelectRow: [{
+                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
+            }], manualChange: [{
+                type: Output
+            }], cellConfig: [{
+                type: Input
+            }], rowSize: [{
+                type: Input
+            }] } });
+/**
+ * Table Head
+ * @selector x-table-head
+ * @decorator component
+ */
+export const XTableHeadPrefix = 'x-table-head';
+/**
+ * Table Head Property
+ */
+export 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 */ /** @nocollapse */ XTableHeadProperty.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableHeadProperty, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ XTableHeadProperty.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: XTableHeadProperty, selector: "ng-component", inputs: { columns: "columns", rowHeight: "rowHeight", columnTpl: "columnTpl", scrollYWidth: "scrollYWidth", scrollXWidth: "scrollXWidth", cellConfig: "cellConfig" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
+__decorate([
+    XInputNumber()
+], XTableHeadProperty.prototype, "rowHeight", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableHeadProperty, decorators: [{
+            type: Component,
+            args: [{ template: '' }]
+        }], propDecorators: { columns: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], columnTpl: [{
+                type: Input
+            }], scrollYWidth: [{
+                type: Input
+            }], scrollXWidth: [{
+                type: Input
+            }], cellConfig: [{
+                type: Input
+            }] } });
+/**
+ * Table Body
+ * @selector x-table-body
+ * @decorator component
+ */
+export const XTableBodyPrefix = 'x-table-body';
+/**
+ * Table Body Property
+ */
+export 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;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XTableBodyProperty.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableBodyProperty, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ XTableBodyProperty.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: XTableBodyProperty, selector: "ng-component", 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" }, 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);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableBodyProperty, decorators: [{
+            type: Component,
+            args: [{ 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
+            }] } });
+/**
+ * Table Foot
+ * @selector x-table-foot
+ * @decorator component
+ */
+export const XTableFootPrefix = 'x-table-foot';
+/**
+ * Table Foot Property
+ */
+export class XTableFootProperty extends XProperty {
+}
+/** @nocollapse */ /** @nocollapse */ XTableFootProperty.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableFootProperty, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ XTableFootProperty.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: XTableFootProperty, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTableFootProperty, decorators: [{
+            type: Component,
+            args: [{ template: '' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.property.js","sourceRoot":"","sources":["../../../../../lib/ng-nest/ui/table/table.property.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,SAAS,EAET,YAAY,EAIZ,aAAa,EAGb,WAAW,EAGZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,YAAY,EAAe,MAAM,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAqB,MAAM,wBAAwB,CAAC;;AAEhF;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,SAAS,CAAC;AACtC,MAAM,aAAa,GAAG,OAAO,CAAC;AAE9B;;GAEG;AAEH,MAAM,OAAO,cAAe,SAAQ,mBAAmB;IADvD;;QAEE;;;WAGG;QACM,SAAI,GAAqB,EAAE,CAAC;QACrC;;;WAGG;QACM,YAAO,GAAmB,EAAE,CAAC;QA0BtC;;;WAGG;QACO,uBAAkB,GAAG,IAAI,YAAY,EAAa,CAAC;QAC7D;;;WAGG;QACM,kBAAa,GAAmB,EAAE,CAAC;QAC5C;;;WAGG;QACM,kBAAa,GAAmB,EAAE,CAAC;QAC5C;;;WAGG;QACO,eAAU,GAAG,IAAI,YAAY,EAAW,CAAC;QAqBnD;;;WAGG;QACM,gBAAW,GAAW,GAAG,CAAC;QACnC;;;WAGG;QACM,gBAAW,GAAW,GAAG,CAAC;QAMnC;;;WAGG;QACsB,eAAU,GAAY,CAAC,CAAC;QACjD;;;WAGG;QACM,eAAU,GAAkC,EAAE,CAAC;QACxD;;;WAGG;QACuB,WAAM,GAAa,IAAI,CAAC;QAMlD;;;WAGG;QACO,iBAAY,GAAG,IAAI,YAAY,EAAW,CAAC;KAWtD;;iJA9HY,cAAc;qIAAd,cAAc,ovBADJ,EAAE;AAgB0C;IAAvD,WAAW,CAAS,aAAa,EAAE,EAAE,CAAC;IAAE,YAAY,EAAE;iDAAoB;AAKb;IAA7D,WAAW,CAAW,aAAa,EAAE,KAAK,CAAC;IAAE,aAAa,EAAE;+CAAoB;AAKnB;IAA7D,WAAW,CAAW,aAAa,EAAE,KAAK,CAAC;IAAE,aAAa,EAAE;gDAAqB;AAKrB;IAA5D,WAAW,CAAW,aAAa,EAAE,IAAI,CAAC;IAAE,aAAa,EAAE;kDAAuB;AA8BtB;IAA5D,WAAW,CAAW,aAAa,EAAE,IAAI,CAAC;IAAE,aAAa,EAAE;sDAA2B;AAKhC;IAAtD,WAAW,CAAW,aAAa,CAAC;IAAE,aAAa,EAAE;qDAA0B;AAKhE;IAAf,YAAY,EAAE;kDAAqB;AAKoB;IAAvD,WAAW,CAAS,aAAa,EAAE,EAAE,CAAC;IAAE,YAAY,EAAE;gDAAmB;AAe1D;IAAf,YAAY,EAAE;sDAA0B;AAKzB;IAAf,YAAY,EAAE;kDAAyB;AAUvB;IAAhB,aAAa,EAAE;8CAAyB;AAoBI;IAA5C,WAAW,CAAQ,aAAa,EAAE,QAAQ,CAAC;+CAAiB;2FA7H3D,cAAc;kBAD1B,SAAS;mBAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;8BAMhB,IAAI;sBAAZ,KAAK;gBAKG,OAAO;sBAAf,KAAK;gBAK2D,SAAS;sBAAzE,KAAK;gBAKiE,OAAO;sBAA7E,KAAK;gBAKiE,QAAQ;sBAA9E,KAAK;gBAKgE,UAAU;sBAA/E,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKI,kBAAkB;sBAA3B,MAAM;gBAKE,aAAa;sBAArB,KAAK;gBAKG,aAAa;sBAArB,KAAK;gBAKI,UAAU;sBAAnB,MAAM;gBAK+D,cAAc;sBAAnF,KAAK;gBAK0D,aAAa;sBAA5E,KAAK;gBAKmB,UAAU;sBAAlC,KAAK;gBAK2D,QAAQ;sBAAxE,KAAK;gBAKG,WAAW;sBAAnB,KAAK;gBAKG,WAAW;sBAAnB,KAAK;gBAKmB,cAAc;sBAAtC,KAAK;gBAKmB,UAAU;sBAAlC,KAAK;gBAKG,UAAU;sBAAlB,KAAK;gBAKoB,MAAM;sBAA/B,KAAK;gBAKG,MAAM;sBAAd,KAAK;gBAKI,YAAY;sBAArB,MAAM;gBAKE,UAAU;sBAAlB,KAAK;gBAKgD,OAAO;sBAA5D,KAAK;;AA4PR;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAE/C;;GAEG;AAEH,MAAM,OAAO,kBAAmB,SAAQ,SAAS;IADjD;;QAEE;;;WAGG;QACM,YAAO,GAAmB,EAAE,CAAC;QACtC;;;WAGG;QACsB,cAAS,GAAY,EAAE,CAAC;QACjD;;;WAGG;QACM,cAAS,GAAmB,EAAE,CAAC;KAgBzC;;qJA/BY,kBAAkB;yIAAlB,kBAAkB,iPADR,EAAE;AAWE;IAAf,YAAY,EAAE;qDAAyB;2FAVtC,kBAAkB;kBAD9B,SAAS;mBAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;8BAMhB,OAAO;sBAAf,KAAK;gBAKmB,SAAS;sBAAjC,KAAK;gBAKG,SAAS;sBAAjB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKG,UAAU;sBAAlB,KAAK;;AAGR;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAE/C;;GAEG;AAEH,MAAM,OAAO,kBAAmB,SAAQ,SAAS;IADjD;;QAEE;;;WAGG;QACM,SAAI,GAAgB,EAAE,CAAC;QAChC;;;WAGG;QACM,YAAO,GAAmB,EAAE,CAAC;QACtC;;;WAGG;QACM,cAAS,GAAmB,EAAE,CAAC;QAMxC;;;WAGG;QACO,uBAAkB,GAAG,IAAI,YAAY,EAAa,CAAC;QAC7D;;;WAGG;QACsB,cAAS,GAAY,EAAE,CAAC;QAMjD;;;WAGG;QACuB,mBAAc,GAAa,IAAI,CAAC;QAC1D;;;WAGG;QACuB,kBAAa,GAAa,KAAK,CAAC;QAC1D;;;WAGG;QACsB,aAAQ,GAAW,EAAE,CAAC;QAC/C;;;WAGG;QACM,gBAAW,GAAW,GAAG,CAAC;QACnC;;;WAGG;QACM,gBAAW,GAAW,GAAG,CAAC;QAMnC;;;WAGG;QACsB,eAAU,GAAY,CAAC,CAAC;KAWlD;;qJAjFY,kBAAkB;yIAAlB,kBAAkB,ghBADR,EAAE;AA+BE;IAAf,YAAY,EAAE;qDAAyB;AAKxB;IAAf,YAAY,EAAE;sDAAqB;AAKnB;IAAhB,aAAa,EAAE;0DAAiC;AAKhC;IAAhB,aAAa,EAAE;yDAAiC;AAKjC;IAAf,YAAY,EAAE;oDAAuB;AAetB;IAAf,YAAY,EAAE;0DAA0B;AAKzB;IAAf,YAAY,EAAE;sDAAyB;2FAtEtC,kBAAkB;kBAD9B,SAAS;mBAAC,EAAE,QAAQ,EAAE,EAAE,EAAE;8BAMhB,IAAI;sBAAZ,KAAK;gBAKG,OAAO;sBAAf,KAAK;gBAKG,SAAS;sBAAjB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKI,kBAAkB;sBAA3B,MAAM;gBAKkB,SAAS;sBAAjC,KAAK;gBAKmB,UAAU;sBAAlC,KAAK;gBAKoB,cAAc;sBAAvC,KAAK;gBAKoB,aAAa;sBAAtC,KAAK;gBAKmB,QAAQ;sBAAhC,KAAK;gBAKG,WAAW;sBAAnB,KAAK;gBAKG,WAAW;sBAAnB,KAAK;gBAKmB,cAAc;sBAAtC,KAAK;gBAKmB,UAAU;sBAAlC,KAAK;gBAKG,MAAM;sBAAd,KAAK;gBAKG,UAAU;sBAAlB,KAAK;;AAGR;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAE/C;;GAEG;AAEH,MAAM,OAAO,kBAAmB,SAAQ,SAAS;;qJAApC,kBAAkB;yIAAlB,kBAAkB,2EADR,EAAE;2FACZ,kBAAkB;kBAD9B,SAAS;mBAAC,EAAE,QAAQ,EAAE,EAAE,EAAE","sourcesContent":["import {\r\n  XProperty,\r\n  XNumber,\r\n  XInputNumber,\r\n  XIdentityProperty,\r\n  XId,\r\n  XSort,\r\n  XInputBoolean,\r\n  XBoolean,\r\n  XData,\r\n  XWithConfig,\r\n  XTextAlign,\r\n  XSize\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({ 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 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 列头自定义模板\r\n   * @en_US Column header custom template\r\n   */\r\n  @Input() headColumnTpl: XTableTemplate = {};\r\n  /**\r\n   * @zh_CN 列内容自定义模板\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 Sort click events\r\n   */\r\n  @Output() sortChange = new EventEmitter<XSort[]>();\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 开启虚拟滚动\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 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\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 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 XId {\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 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 文字对齐方式\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 头部显示 checkbox\r\n   * @en_US Head shows checkbox\r\n   */\r\n  headChecked?: 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 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 对应列的 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';\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({ 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\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({ 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\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({ template: '' })\r\nexport class XTableFootProperty extends XProperty {}\r\n"]}

package/esm2020/tabs/tab-content.component.mjs

@@ -0,0 +1,22 @@
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class XTabContentComponent {
+    constructor(elementRef, renderer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.active = false;
+        this.renderer.addClass(this.elementRef.nativeElement, 'x-tab-content');
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XTabContentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTabContentComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ XTabContentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: XTabContentComponent, selector: "x-tab-content", inputs: { content: "content", active: "active" }, ngImport: i0, template: "<ng-container>\r\n  <ng-template [ngTemplateOutlet]=\"content\"></ng-template>\r\n</ng-container>\r\n", directives: [{ type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTabContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'x-tab-content', preserveWhitespaces: false, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-container>\r\n  <ng-template [ngTemplateOutlet]=\"content\"></ng-template>\r\n</ng-container>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { content: [{
+                type: Input
+            }], active: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tabs/tab.component.mjs

@@ -0,0 +1,20 @@
+import { ChangeDetectionStrategy, Component, TemplateRef, ViewChild, ViewEncapsulation } from '@angular/core';
+import { XTabPrefix, XTabProperty } from './tabs.property';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-nest/ui/core";
+export class XTabComponent extends XTabProperty {
+    constructor(configService) {
+        super();
+        this.configService = configService;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XTabComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTabComponent, deps: [{ token: i1.XConfigService }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ XTabComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: XTabComponent, selector: "x-tab", viewQueries: [{ propertyName: "content", first: true, predicate: TemplateRef, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<ng-template>\r\n  <ng-content></ng-content>\r\n</ng-template>\r\n", changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XTabComponent, decorators: [{
+            type: Component,
+            args: [{ selector: `${XTabPrefix}`, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-template>\r\n  <ng-content></ng-content>\r\n</ng-template>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.XConfigService }]; }, propDecorators: { content: [{
+                type: ViewChild,
+                args: [TemplateRef, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3RhYnMvdGFiLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3RhYnMvdGFiLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsV0FBVyxFQUFFLFNBQVMsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM5RyxPQUFPLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDOzs7QUFTM0QsTUFBTSxPQUFPLGFBQWMsU0FBUSxZQUFZO0lBRzdDLFlBQW1CLGFBQTZCO1FBQzlDLEtBQUssRUFBRSxDQUFDO1FBRFMsa0JBQWEsR0FBYixhQUFhLENBQWdCO0lBRWhELENBQUM7O2dKQUxVLGFBQWE7b0lBQWIsYUFBYSxzRkFDYixXQUFXLHFGQ1h4QixvRUFHQTsyRkRPYSxhQUFhO2tCQU56QixTQUFTOytCQUNFLEdBQUcsVUFBVSxFQUFFLGlCQUVWLGlCQUFpQixDQUFDLElBQUksbUJBQ3BCLHVCQUF1QixDQUFDLE1BQU07cUdBR0wsT0FBTztzQkFBaEQsU0FBUzt1QkFBQyxXQUFXLEVBQUUsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgVGVtcGxhdGVSZWYsIFZpZXdDaGlsZCwgVmlld0VuY2Fwc3VsYXRpb24gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgWFRhYlByZWZpeCwgWFRhYlByb3BlcnR5IH0gZnJvbSAnLi90YWJzLnByb3BlcnR5JztcclxuaW1wb3J0IHsgWENvbmZpZ1NlcnZpY2UgfSBmcm9tICdAbmctbmVzdC91aS9jb3JlJztcclxuXHJcbkBDb21wb25lbnQoe1xyXG4gIHNlbGVjdG9yOiBgJHtYVGFiUHJlZml4fWAsXHJcbiAgdGVtcGxhdGVVcmw6ICcuL3RhYi5jb21wb25lbnQuaHRtbCcsXHJcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZSxcclxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaFxyXG59KVxyXG5leHBvcnQgY2xhc3MgWFRhYkNvbXBvbmVudCBleHRlbmRzIFhUYWJQcm9wZXJ0eSB7XHJcbiAgQFZpZXdDaGlsZChUZW1wbGF0ZVJlZiwgeyBzdGF0aWM6IHRydWUgfSkgY29udGVudCE6IFRlbXBsYXRlUmVmPHZvaWQ+O1xyXG5cclxuICBjb25zdHJ1Y3RvcihwdWJsaWMgY29uZmlnU2VydmljZTogWENvbmZpZ1NlcnZpY2UpIHtcclxuICAgIHN1cGVyKCk7XHJcbiAgfVxyXG59XHJcbiIsIjxuZy10ZW1wbGF0ZT5cclxuICA8bmctY29udGVudD48L25nLWNvbnRlbnQ+XHJcbjwvbmctdGVtcGxhdGU+XHJcbiJdfQ==