@spartan-ng/brain 0.0.1-alpha.373 → 0.0.1-alpha.379

package/esm2022/table/lib/brn-paginator.directive.mjs

@@ -0,0 +1,109 @@
+import { Directive, Input, TemplateRef, ViewContainerRef, computed, effect, inject, numberAttribute, signal, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BrnPaginatorDirective {
+    static ngTemplateContextGuard(_directive, _context) {
+        return true;
+    }
+    _vcr = inject(ViewContainerRef);
+    _template = inject((TemplateRef));
+    _state = signal({
+        currentPage: 0,
+        startIndex: 0,
+        endIndex: 0,
+        pageSize: 10,
+        totalPages: 0,
+        totalElements: null,
+    });
+    _decrementable = computed(() => 0 < this._state().startIndex);
+    _incrementable = computed(() => this._state().endIndex < (this._state().totalElements ?? 0) - 1);
+    set totalElements(value) {
+        this.calculateNewState({ newTotalElements: value, newPage: 0 });
+    }
+    set currentPage(value) {
+        this.calculateNewState({ newPage: value });
+    }
+    set pageSize(value) {
+        this.calculateNewState({ newPageSize: value, newPage: 0 });
+    }
+    onStateChange;
+    constructor() {
+        effect(() => {
+            const state = this._state();
+            Promise.resolve().then(() => {
+                if (this.onStateChange) {
+                    this.onStateChange(state);
+                }
+            });
+        }, { allowSignalWrites: true });
+    }
+    ngOnInit() {
+        this._vcr.createEmbeddedView(this._template, {
+            $implicit: {
+                state: this._state,
+                increment: () => this.incrementPage(),
+                decrement: () => this.decrementPage(),
+                incrementable: this._incrementable,
+                decrementable: this._decrementable,
+            },
+        });
+    }
+    decrementPage() {
+        const { currentPage } = this._state();
+        if (0 < currentPage) {
+            this.calculateNewState({ newPage: currentPage - 1 });
+        }
+    }
+    incrementPage() {
+        const { currentPage, totalPages } = this._state();
+        if (totalPages > currentPage) {
+            this.calculateNewState({ newPage: currentPage + 1 });
+        }
+    }
+    reset() {
+        this.currentPage = 0;
+    }
+    calculateNewState({ newPage, newPageSize, newTotalElements, }) {
+        const previousState = this._state();
+        let currentPage = newPage ?? previousState.currentPage;
+        const pageSize = newPageSize ?? previousState.pageSize;
+        const totalElements = newTotalElements ?? previousState.totalElements ?? 0;
+        const newTotalPages = totalElements ? Math.floor(totalElements / pageSize) : 0;
+        if (newTotalPages < currentPage - 1) {
+            currentPage = newTotalPages - 1;
+        }
+        const newStartIndex = totalElements === 0 ? 0 : Math.min(totalElements - 1, currentPage * pageSize);
+        const newEndIndex = Math.min((currentPage + 1) * pageSize - 1, totalElements - 1);
+        const newState = {
+            currentPage: currentPage,
+            startIndex: newStartIndex,
+            endIndex: newEndIndex,
+            pageSize: pageSize,
+            totalPages: newTotalPages,
+            totalElements: totalElements,
+        };
+        this._state.set(newState);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnPaginatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "18.2.5", type: BrnPaginatorDirective, isStandalone: true, selector: "[brnPaginator]", inputs: { totalElements: ["brnPaginatorTotalElements", "totalElements"], currentPage: ["brnPaginatorCurrentPage", "currentPage", numberAttribute], pageSize: ["brnPaginatorPageSize", "pageSize", numberAttribute], onStateChange: ["brnPaginatorOnStateChange", "onStateChange"] }, exportAs: ["brnPaginator"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnPaginatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[brnPaginator]',
+                    exportAs: 'brnPaginator',
+                }]
+        }], ctorParameters: () => [], propDecorators: { totalElements: [{
+                type: Input,
+                args: [{ alias: 'brnPaginatorTotalElements' }]
+            }], currentPage: [{
+                type: Input,
+                args: [{ alias: 'brnPaginatorCurrentPage', transform: numberAttribute }]
+            }], pageSize: [{
+                type: Input,
+                args: [{ alias: 'brnPaginatorPageSize', transform: numberAttribute }]
+            }], onStateChange: [{
+                type: Input,
+                args: [{ alias: 'brnPaginatorOnStateChange' }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-paginator.directive.js","sourceRoot":"","sources":["../../../../../../libs/brain/table/src/lib/brn-paginator.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tDirective,\n\tInput,\n\ttype OnInit,\n\ttype Signal,\n\tTemplateRef,\n\tViewContainerRef,\n\tcomputed,\n\teffect,\n\tinject,\n\tnumberAttribute,\n\tsignal,\n} from '@angular/core';\n\nexport type PaginatorState = {\n\tcurrentPage: number;\n\tstartIndex: number;\n\tendIndex: number;\n\tpageSize: number;\n\ttotalPages: number;\n\ttotalElements: number | null | undefined;\n};\n\nexport type PaginatorContext = {\n\t$implicit: {\n\t\tstate: Signal<PaginatorState>;\n\t\tincrementable: Signal<boolean>;\n\t\tdecrementable: Signal<boolean>;\n\t\tincrement: () => void;\n\t\tdecrement: () => void;\n\t};\n};\n\n@Directive({\n\tstandalone: true,\n\tselector: '[brnPaginator]',\n\texportAs: 'brnPaginator',\n})\nexport class BrnPaginatorDirective implements OnInit {\n\tstatic ngTemplateContextGuard(_directive: BrnPaginatorDirective, _context: unknown): _context is PaginatorContext {\n\t\treturn true;\n\t}\n\n\tprivate readonly _vcr = inject(ViewContainerRef);\n\tprivate readonly _template = inject(TemplateRef<unknown>);\n\n\tprivate readonly _state = signal<PaginatorState>({\n\t\tcurrentPage: 0,\n\t\tstartIndex: 0,\n\t\tendIndex: 0,\n\t\tpageSize: 10,\n\t\ttotalPages: 0,\n\t\ttotalElements: null,\n\t});\n\tprivate readonly _decrementable = computed(() => 0 < this._state().startIndex);\n\tprivate readonly _incrementable = computed(() => this._state().endIndex < (this._state().totalElements ?? 0) - 1);\n\n\t@Input({ alias: 'brnPaginatorTotalElements' })\n\tpublic set totalElements(value: number | null | undefined) {\n\t\tthis.calculateNewState({ newTotalElements: value, newPage: 0 });\n\t}\n\n\t@Input({ alias: 'brnPaginatorCurrentPage', transform: numberAttribute })\n\tpublic set currentPage(value: number) {\n\t\tthis.calculateNewState({ newPage: value });\n\t}\n\n\t@Input({ alias: 'brnPaginatorPageSize', transform: numberAttribute })\n\tpublic set pageSize(value: number) {\n\t\tthis.calculateNewState({ newPageSize: value, newPage: 0 });\n\t}\n\n\t@Input({ alias: 'brnPaginatorOnStateChange' })\n\tpublic onStateChange?: (state: PaginatorState) => void;\n\n\tconstructor() {\n\t\teffect(\n\t\t\t() => {\n\t\t\t\tconst state = this._state();\n\t\t\t\tPromise.resolve().then(() => {\n\t\t\t\t\tif (this.onStateChange) {\n\t\t\t\t\t\tthis.onStateChange(state);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t},\n\t\t\t{ allowSignalWrites: true },\n\t\t);\n\t}\n\n\tpublic ngOnInit() {\n\t\tthis._vcr.createEmbeddedView<PaginatorContext>(this._template, {\n\t\t\t$implicit: {\n\t\t\t\tstate: this._state,\n\t\t\t\tincrement: () => this.incrementPage(),\n\t\t\t\tdecrement: () => this.decrementPage(),\n\t\t\t\tincrementable: this._incrementable,\n\t\t\t\tdecrementable: this._decrementable,\n\t\t\t},\n\t\t});\n\t}\n\n\tpublic decrementPage(): void {\n\t\tconst { currentPage } = this._state();\n\t\tif (0 < currentPage) {\n\t\t\tthis.calculateNewState({ newPage: currentPage - 1 });\n\t\t}\n\t}\n\n\tpublic incrementPage(): void {\n\t\tconst { currentPage, totalPages } = this._state();\n\t\tif (totalPages > currentPage) {\n\t\t\tthis.calculateNewState({ newPage: currentPage + 1 });\n\t\t}\n\t}\n\n\tpublic reset(): void {\n\t\tthis.currentPage = 0;\n\t}\n\n\tprivate calculateNewState({\n\t\tnewPage,\n\t\tnewPageSize,\n\t\tnewTotalElements,\n\t}: Partial<{\n\t\tnewPage: number;\n\t\tnewPageSize: number;\n\t\tnewTotalElements: number | null | undefined;\n\t}>) {\n\t\tconst previousState = this._state();\n\n\t\tlet currentPage = newPage ?? previousState.currentPage;\n\t\tconst pageSize = newPageSize ?? previousState.pageSize;\n\t\tconst totalElements = newTotalElements ?? previousState.totalElements ?? 0;\n\n\t\tconst newTotalPages = totalElements ? Math.floor(totalElements / pageSize) : 0;\n\n\t\tif (newTotalPages < currentPage - 1) {\n\t\t\tcurrentPage = newTotalPages - 1;\n\t\t}\n\n\t\tconst newStartIndex = totalElements === 0 ? 0 : Math.min(totalElements - 1, currentPage * pageSize);\n\t\tconst newEndIndex = Math.min((currentPage + 1) * pageSize - 1, totalElements - 1);\n\n\t\tconst newState = {\n\t\t\tcurrentPage: currentPage,\n\t\t\tstartIndex: newStartIndex,\n\t\t\tendIndex: newEndIndex,\n\t\t\tpageSize: pageSize,\n\t\t\ttotalPages: newTotalPages,\n\t\t\ttotalElements: totalElements,\n\t\t};\n\n\t\tthis._state.set(newState);\n\t}\n}\n"]}

package/esm2022/table/lib/brn-table.component.mjs

@@ -0,0 +1,169 @@
+import { CdkRowDef, CdkTable, CdkTableModule } from '@angular/cdk/table';
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Output, ViewChild, ViewEncapsulation, booleanAttribute, } from '@angular/core';
+import { provideTableClassesSettableExisting } from '@spartan-ng/ui-core';
+import { BrnColumnDefComponent } from './brn-column-def.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/table";
+export class BrnTableComponent {
+    _cdkTable;
+    // Cdk Table Inputs / Outputs
+    dataSource = [];
+    fixedLayout = false;
+    multiTemplateDataRows = false;
+    displayedColumns = [];
+    _trackBy;
+    get trackBy() {
+        return this._trackBy;
+    }
+    set trackBy(value) {
+        this._trackBy = value;
+        if (this._cdkTable) {
+            this._cdkTable.trackBy = this._trackBy;
+        }
+    }
+    contentChanged = new EventEmitter();
+    // Brn Inputs / Outputs
+    customTemplateDataRows = false;
+    onRowClick;
+    stickyHeader = false;
+    tableClasses = '';
+    headerRowClasses = '';
+    bodyRowClasses = '';
+    columnDefComponents;
+    rowDefs;
+    // after the <ng-content> has been initialized, the column definitions are available.
+    // All that's left is to add them to the table ourselves:
+    ngAfterContentInit() {
+        this.columnDefComponents.forEach((component) => {
+            if (!this._cdkTable)
+                return;
+            if (component.cell) {
+                this._cdkTable.addColumnDef(component.columnDef);
+            }
+        });
+        this.rowDefs.forEach((rowDef) => {
+            if (!this._cdkTable)
+                return;
+            this._cdkTable.addRowDef(rowDef);
+        });
+    }
+    setTableClasses({ table, headerRow, bodyRow, }) {
+        if (table) {
+            this.tableClasses = table;
+        }
+        if (headerRow) {
+            this.headerRowClasses = headerRow;
+        }
+        if (bodyRow) {
+            this.bodyRowClasses = bodyRow;
+        }
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    /** @nocollapse */ static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: BrnTableComponent, isStandalone: true, selector: "brn-table", inputs: { dataSource: "dataSource", fixedLayout: ["fixedLayout", "fixedLayout", booleanAttribute], multiTemplateDataRows: ["multiTemplateDataRows", "multiTemplateDataRows", booleanAttribute], displayedColumns: "displayedColumns", trackBy: "trackBy", customTemplateDataRows: ["customTemplateDataRows", "customTemplateDataRows", booleanAttribute], onRowClick: "onRowClick", stickyHeader: ["stickyHeader", "stickyHeader", booleanAttribute], tableClasses: "tableClasses", headerRowClasses: "headerRowClasses", bodyRowClasses: "bodyRowClasses" }, outputs: { contentChanged: "contentChanged" }, providers: [provideTableClassesSettableExisting((() => BrnTableComponent))], queries: [{ propertyName: "columnDefComponents", predicate: BrnColumnDefComponent }, { propertyName: "rowDefs", predicate: CdkRowDef }], viewQueries: [{ propertyName: "_cdkTable", first: true, predicate: ["cdkTable"], descendants: true, read: CdkTable, static: true }], ngImport: i0, template: `
+		<cdk-table
+			#cdkTable
+			[class]="tableClasses"
+			[dataSource]="dataSource"
+			[fixedLayout]="fixedLayout"
+			[multiTemplateDataRows]="multiTemplateDataRows"
+			(contentChanged)="contentChanged.emit()"
+		>
+			<ng-content />
+
+			<cdk-header-row [class]="headerRowClasses" *cdkHeaderRowDef="displayedColumns; sticky: stickyHeader" />
+			@if (!customTemplateDataRows) {
+				<cdk-row
+					[tabindex]="!!onRowClick ? 0 : -1"
+					[attr.role]="!!onRowClick ? 'button' : 'row'"
+					[class.row-interactive]="!!onRowClick"
+					(keydown.enter)="!!onRowClick && onRowClick(row)"
+					(click)="!!onRowClick && onRowClick(row)"
+					[class]="bodyRowClasses"
+					*cdkRowDef="let row; columns: displayedColumns"
+				/>
+			}
+
+			<ng-template cdkNoDataRow>
+				<ng-content select="[brnNoDataRow]" />
+			</ng-template>
+		</cdk-table>
+	`, isInline: true, dependencies: [{ kind: "ngmodule", type: CdkTableModule }, { kind: "component", type: i1.CdkTable, selector: "cdk-table, table[cdk-table]", inputs: ["trackBy", "dataSource", "multiTemplateDataRows", "fixedLayout"], outputs: ["contentChanged"], exportAs: ["cdkTable"] }, { kind: "directive", type: i1.CdkRowDef, selector: "[cdkRowDef]", inputs: ["cdkRowDefColumns", "cdkRowDefWhen"] }, { kind: "component", type: i1.CdkRow, selector: "cdk-row, tr[cdk-row]" }, { kind: "component", type: i1.CdkHeaderRow, selector: "cdk-header-row, tr[cdk-header-row]" }, { kind: "directive", type: i1.CdkHeaderRowDef, selector: "[cdkHeaderRowDef]", inputs: ["cdkHeaderRowDef", "cdkHeaderRowDefSticky"] }, { kind: "directive", type: i1.CdkNoDataRow, selector: "ng-template[cdkNoDataRow]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTableComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'brn-table',
+                    standalone: true,
+                    imports: [CdkTableModule],
+                    providers: [provideTableClassesSettableExisting((() => BrnTableComponent))],
+                    template: `
+		<cdk-table
+			#cdkTable
+			[class]="tableClasses"
+			[dataSource]="dataSource"
+			[fixedLayout]="fixedLayout"
+			[multiTemplateDataRows]="multiTemplateDataRows"
+			(contentChanged)="contentChanged.emit()"
+		>
+			<ng-content />
+
+			<cdk-header-row [class]="headerRowClasses" *cdkHeaderRowDef="displayedColumns; sticky: stickyHeader" />
+			@if (!customTemplateDataRows) {
+				<cdk-row
+					[tabindex]="!!onRowClick ? 0 : -1"
+					[attr.role]="!!onRowClick ? 'button' : 'row'"
+					[class.row-interactive]="!!onRowClick"
+					(keydown.enter)="!!onRowClick && onRowClick(row)"
+					(click)="!!onRowClick && onRowClick(row)"
+					[class]="bodyRowClasses"
+					*cdkRowDef="let row; columns: displayedColumns"
+				/>
+			}
+
+			<ng-template cdkNoDataRow>
+				<ng-content select="[brnNoDataRow]" />
+			</ng-template>
+		</cdk-table>
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], propDecorators: { _cdkTable: [{
+                type: ViewChild,
+                args: ['cdkTable', { read: CdkTable, static: true }]
+            }], dataSource: [{
+                type: Input
+            }], fixedLayout: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], multiTemplateDataRows: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], displayedColumns: [{
+                type: Input
+            }], trackBy: [{
+                type: Input
+            }], contentChanged: [{
+                type: Output
+            }], customTemplateDataRows: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], onRowClick: [{
+                type: Input
+            }], stickyHeader: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], tableClasses: [{
+                type: Input
+            }], headerRowClasses: [{
+                type: Input
+            }], bodyRowClasses: [{
+                type: Input
+            }], columnDefComponents: [{
+                type: ContentChildren,
+                args: [BrnColumnDefComponent]
+            }], rowDefs: [{
+                type: ContentChildren,
+                args: [CdkRowDef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brn-table.component.js","sourceRoot":"","sources":["../../../../../../libs/brain/table/src/lib/brn-table.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkRowDef, CdkTable, type CdkTableDataSourceInput, CdkTableModule } from '@angular/cdk/table';\nimport {\n\ttype AfterContentInit,\n\tChangeDetectionStrategy,\n\tComponent,\n\tContentChildren,\n\tEventEmitter,\n\tInput,\n\tOutput,\n\ttype QueryList,\n\ttype TrackByFunction,\n\tViewChild,\n\tViewEncapsulation,\n\tbooleanAttribute,\n} from '@angular/core';\nimport { type TableClassesSettable, provideTableClassesSettableExisting } from '@spartan-ng/ui-core';\nimport { BrnColumnDefComponent } from './brn-column-def.component';\n\nexport type BrnTableDataSourceInput<T> = CdkTableDataSourceInput<T>;\n\n@Component({\n\tselector: 'brn-table',\n\tstandalone: true,\n\timports: [CdkTableModule],\n\tproviders: [provideTableClassesSettableExisting(<T>() => BrnTableComponent<T>)],\n\ttemplate: `\n\t\t<cdk-table\n\t\t\t#cdkTable\n\t\t\t[class]=\"tableClasses\"\n\t\t\t[dataSource]=\"dataSource\"\n\t\t\t[fixedLayout]=\"fixedLayout\"\n\t\t\t[multiTemplateDataRows]=\"multiTemplateDataRows\"\n\t\t\t(contentChanged)=\"contentChanged.emit()\"\n\t\t>\n\t\t\t<ng-content />\n\n\t\t\t<cdk-header-row [class]=\"headerRowClasses\" *cdkHeaderRowDef=\"displayedColumns; sticky: stickyHeader\" />\n\t\t\t@if (!customTemplateDataRows) {\n\t\t\t\t<cdk-row\n\t\t\t\t\t[tabindex]=\"!!onRowClick ? 0 : -1\"\n\t\t\t\t\t[attr.role]=\"!!onRowClick ? 'button' : 'row'\"\n\t\t\t\t\t[class.row-interactive]=\"!!onRowClick\"\n\t\t\t\t\t(keydown.enter)=\"!!onRowClick && onRowClick(row)\"\n\t\t\t\t\t(click)=\"!!onRowClick && onRowClick(row)\"\n\t\t\t\t\t[class]=\"bodyRowClasses\"\n\t\t\t\t\t*cdkRowDef=\"let row; columns: displayedColumns\"\n\t\t\t\t/>\n\t\t\t}\n\n\t\t\t<ng-template cdkNoDataRow>\n\t\t\t\t<ng-content select=\"[brnNoDataRow]\" />\n\t\t\t</ng-template>\n\t\t</cdk-table>\n\t`,\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\tencapsulation: ViewEncapsulation.None,\n})\nexport class BrnTableComponent<T> implements TableClassesSettable, AfterContentInit {\n\t@ViewChild('cdkTable', { read: CdkTable, static: true })\n\tprivate readonly _cdkTable?: CdkTable<T>;\n\t// Cdk Table Inputs / Outputs\n\t@Input()\n\tpublic dataSource: BrnTableDataSourceInput<T> = [];\n\t@Input({ transform: booleanAttribute })\n\tpublic fixedLayout = false;\n\t@Input({ transform: booleanAttribute })\n\tpublic multiTemplateDataRows = false;\n\t@Input()\n\tpublic displayedColumns: string[] = [];\n\n\tprivate _trackBy?: TrackByFunction<T>;\n\tpublic get trackBy(): TrackByFunction<T> | undefined {\n\t\treturn this._trackBy;\n\t}\n\n\t@Input()\n\tpublic set trackBy(value: TrackByFunction<T>) {\n\t\tthis._trackBy = value;\n\t\tif (this._cdkTable) {\n\t\t\tthis._cdkTable.trackBy = this._trackBy;\n\t\t}\n\t}\n\n\t@Output()\n\tpublic readonly contentChanged: EventEmitter<void> = new EventEmitter<void>();\n\n\t// Brn Inputs / Outputs\n\t@Input({ transform: booleanAttribute })\n\tpublic customTemplateDataRows = false;\n\t@Input()\n\tpublic onRowClick: ((element: T) => void) | undefined;\n\n\t@Input({ transform: booleanAttribute })\n\tpublic stickyHeader = false;\n\t@Input()\n\tpublic tableClasses = '';\n\t@Input()\n\tpublic headerRowClasses = '';\n\t@Input()\n\tpublic bodyRowClasses = '';\n\n\t@ContentChildren(BrnColumnDefComponent) public columnDefComponents!: QueryList<BrnColumnDefComponent>;\n\t@ContentChildren(CdkRowDef) public rowDefs!: QueryList<CdkRowDef<T>>;\n\n\t// after the <ng-content> has been initialized, the column definitions are available.\n\t// All that's left is to add them to the table ourselves:\n\tpublic ngAfterContentInit(): void {\n\t\tthis.columnDefComponents.forEach((component) => {\n\t\t\tif (!this._cdkTable) return;\n\t\t\tif (component.cell) {\n\t\t\t\tthis._cdkTable.addColumnDef(component.columnDef);\n\t\t\t}\n\t\t});\n\t\tthis.rowDefs.forEach((rowDef) => {\n\t\t\tif (!this._cdkTable) return;\n\t\t\tthis._cdkTable.addRowDef(rowDef);\n\t\t});\n\t}\n\n\tpublic setTableClasses({\n\t\ttable,\n\t\theaderRow,\n\t\tbodyRow,\n\t}: Partial<{ table: string; headerRow: string; bodyRow: string }>): void {\n\t\tif (table) {\n\t\t\tthis.tableClasses = table;\n\t\t}\n\t\tif (headerRow) {\n\t\t\tthis.headerRowClasses = headerRow;\n\t\t}\n\t\tif (bodyRow) {\n\t\t\tthis.bodyRowClasses = bodyRow;\n\t\t}\n\t}\n}\n"]}

package/esm2022/table/spartan-ng-brain-table.mjs

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

package/esm2022/tabs/index.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { BrnTabsListDirective } from './lib/brn-tabs-list.directive';
+import { BrnTabsContentDirective, BrnTabsDirective, BrnTabsTriggerDirective } from './lib/brn-tabs-trigger.directive';
+import * as i0 from "@angular/core";
+export * from './lib/brn-tabs-list.directive';
+export * from './lib/brn-tabs-paginated-list.directive';
+export * from './lib/brn-tabs-trigger.directive';
+export const BrnTabsImports = [
+    BrnTabsDirective,
+    BrnTabsListDirective,
+    BrnTabsTriggerDirective,
+    BrnTabsContentDirective,
+];
+export class BrnTabsModule {
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    /** @nocollapse */ static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsModule, imports: [BrnTabsDirective,
+            BrnTabsListDirective,
+            BrnTabsTriggerDirective,
+            BrnTabsContentDirective], exports: [BrnTabsDirective,
+            BrnTabsListDirective,
+            BrnTabsTriggerDirective,
+            BrnTabsContentDirective] });
+    /** @nocollapse */ static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...BrnTabsImports],
+                    exports: [...BrnTabsImports],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2JyYWluL3RhYnMvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDckUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLGdCQUFnQixFQUFFLHVCQUF1QixFQUFFLE1BQU0sa0NBQWtDLENBQUM7O0FBRXRILGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLGtDQUFrQyxDQUFDO0FBRWpELE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRztJQUM3QixnQkFBZ0I7SUFDaEIsb0JBQW9CO0lBQ3BCLHVCQUF1QjtJQUN2Qix1QkFBdUI7Q0FDZCxDQUFDO0FBTVgsTUFBTSxPQUFPLGFBQWE7MEhBQWIsYUFBYTsySEFBYixhQUFhLFlBVnpCLGdCQUFnQjtZQUNoQixvQkFBb0I7WUFDcEIsdUJBQXVCO1lBQ3ZCLHVCQUF1QixhQUh2QixnQkFBZ0I7WUFDaEIsb0JBQW9CO1lBQ3BCLHVCQUF1QjtZQUN2Qix1QkFBdUI7MkhBT1gsYUFBYTs7MkZBQWIsYUFBYTtrQkFKekIsUUFBUTttQkFBQztvQkFDVCxPQUFPLEVBQUUsQ0FBQyxHQUFHLGNBQWMsQ0FBQztvQkFDNUIsT0FBTyxFQUFFLENBQUMsR0FBRyxjQUFjLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQnJuVGFic0xpc3REaXJlY3RpdmUgfSBmcm9tICcuL2xpYi9icm4tdGFicy1saXN0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBCcm5UYWJzQ29udGVudERpcmVjdGl2ZSwgQnJuVGFic0RpcmVjdGl2ZSwgQnJuVGFic1RyaWdnZXJEaXJlY3RpdmUgfSBmcm9tICcuL2xpYi9icm4tdGFicy10cmlnZ2VyLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2Jybi10YWJzLWxpc3QuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2Jybi10YWJzLXBhZ2luYXRlZC1saXN0LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9icm4tdGFicy10cmlnZ2VyLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBCcm5UYWJzSW1wb3J0cyA9IFtcblx0QnJuVGFic0RpcmVjdGl2ZSxcblx0QnJuVGFic0xpc3REaXJlY3RpdmUsXG5cdEJyblRhYnNUcmlnZ2VyRGlyZWN0aXZlLFxuXHRCcm5UYWJzQ29udGVudERpcmVjdGl2ZSxcbl0gYXMgY29uc3Q7XG5cbkBOZ01vZHVsZSh7XG5cdGltcG9ydHM6IFsuLi5Ccm5UYWJzSW1wb3J0c10sXG5cdGV4cG9ydHM6IFsuLi5Ccm5UYWJzSW1wb3J0c10sXG59KVxuZXhwb3J0IGNsYXNzIEJyblRhYnNNb2R1bGUge31cbiJdfQ==

package/esm2022/tabs/lib/brn-tabs-list.directive.mjs

@@ -0,0 +1,65 @@
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { Directive, ElementRef, contentChildren, inject } from '@angular/core';
+import { fromEvent, take } from 'rxjs';
+import { BrnTabsDirective, BrnTabsTriggerDirective } from './brn-tabs-trigger.directive';
+import * as i0 from "@angular/core";
+export class BrnTabsListDirective {
+    _root = inject(BrnTabsDirective);
+    _orientation = this._root.$orientation;
+    _direction = this._root.$direction;
+    _activeTab = this._root.$activeTab;
+    _tabs = this._root.$tabs;
+    _elementRef = inject(ElementRef);
+    _keyDownListener = fromEvent(this._elementRef.nativeElement, 'keydown');
+    _keyManager;
+    triggers = contentChildren(BrnTabsTriggerDirective, { descendants: true });
+    ngAfterContentInit() {
+        this._keyManager = new FocusKeyManager(this.triggers())
+            .withHorizontalOrientation(this._direction())
+            .withHomeAndEnd()
+            .withPageUpDown()
+            .withWrap();
+        // needed because by default the index is set to -1, which means first interaction is skipped
+        this._keyDownListener.pipe(take(1)).subscribe(() => {
+            const currentTabKey = this._activeTab();
+            const tabs = this._tabs();
+            let activeIndex = 0;
+            if (currentTabKey) {
+                const currentTab = tabs[currentTabKey];
+                if (currentTab) {
+                    activeIndex = this.triggers().indexOf(currentTab.trigger);
+                }
+            }
+            this._keyManager?.setActiveItem(activeIndex);
+        });
+        this._keyDownListener.subscribe((event) => {
+            if ('key' in event) {
+                if (this._orientation() === 'horizontal') {
+                    if (event.key === 'ArrowUp' || event.key === 'ArrowDown')
+                        return;
+                }
+                if (this._orientation() === 'vertical') {
+                    if (event.key === 'ArrowLeft' || event.key === 'ArrowRight')
+                        return;
+                }
+            }
+            this._keyManager?.onKeydown(event);
+        });
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.2.5", type: BrnTabsListDirective, isStandalone: true, selector: "[brnTabsList]", host: { attributes: { "role": "tablist" }, properties: { "attr.aria-orientation": "_orientation()", "attr.data-orientation": "_orientation()" } }, queries: [{ propertyName: "triggers", predicate: BrnTabsTriggerDirective, descendants: true, isSignal: true }], exportAs: ["brnTabsList"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BrnTabsListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[brnTabsList]',
+                    standalone: true,
+                    host: {
+                        role: 'tablist',
+                        '[attr.aria-orientation]': '_orientation()',
+                        '[attr.data-orientation]': '_orientation()',
+                    },
+                    exportAs: 'brnTabsList',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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