@luzmo/ngx-lucero 2.4.2 → 2.5.0

package/esm/components/table-head-cell.js

@@ -0,0 +1,155 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-head-cell>
+ *
+ * @slot (default) - Column header content.
+ */
+export class LuzmoTableHeadCell {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    role;
+    /** Pressed state while Space is held on a sortable header. */
+    active;
+    /** Whether activating the header sorts the table. */
+    sortable;
+    /** Current sort direction. Unset when the column is not sorted. */
+    sortDirection;
+    /** Item key the column sorts by. Sent as `sortKey` in `luzmo-table-sorted`. */
+    sortKey;
+    /** Stable column identifier. Defaults to `sortKey`, then the column index. */
+    columnId;
+    /** Fixed column width, in pixels. */
+    width;
+    /** Minimum column width, in pixels. */
+    minWidth;
+    /** Maximum column width, in pixels. */
+    maxWidth;
+    /** Whether the header shows a resize handle. */
+    resizable;
+    /** Maximum number of header lines before the text truncates. Unset wraps. Also the default clamp for the column's cells. */
+    lineClamp;
+    /** A sortable header was activated. `detail` is `{ sortKey, sortDirection }`. Cancel it in data mode to skip the client sort. Cancel it on this header to keep sibling sort directions unchanged. */
+    luzmoTableSorted = output({ alias: 'luzmo-table-sorted' });
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'role':
+                    this.setHostProperty('role', changes['role'].currentValue);
+                    break;
+                case 'active':
+                    this.setHostProperty('active', changes['active'].currentValue);
+                    break;
+                case 'sortable':
+                    this.setHostProperty('sortable', changes['sortable'].currentValue);
+                    break;
+                case 'sortDirection':
+                    this.setHostProperty('sortDirection', changes['sortDirection'].currentValue);
+                    break;
+                case 'sortKey':
+                    this.setHostProperty('sortKey', changes['sortKey'].currentValue);
+                    break;
+                case 'columnId':
+                    this.setHostProperty('columnId', changes['columnId'].currentValue);
+                    break;
+                case 'width':
+                    this.setHostProperty('width', changes['width'].currentValue);
+                    break;
+                case 'minWidth':
+                    this.setHostProperty('minWidth', changes['minWidth'].currentValue);
+                    break;
+                case 'maxWidth':
+                    this.setHostProperty('maxWidth', changes['maxWidth'].currentValue);
+                    break;
+                case 'resizable':
+                    this.setHostProperty('resizable', changes['resizable'].currentValue);
+                    break;
+                case 'lineClamp':
+                    this.setHostProperty('lineClamp', changes['lineClamp'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-table-sorted', (event) => {
+            this.luzmoTableSorted.emit(event);
+        }));
+    }
+    static ɵfac = function LuzmoTableHeadCell_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableHeadCell)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableHeadCell, selectors: [["luzmo-table-head-cell"]], inputs: { role: "role", active: "active", sortable: "sortable", sortDirection: "sortDirection", sortKey: "sortKey", columnId: "columnId", width: "width", minWidth: "minWidth", maxWidth: "maxWidth", resizable: "resizable", lineClamp: "lineClamp" }, outputs: { luzmoTableSorted: "luzmo-table-sorted" }, exportAs: ["luzmoTableHeadCell"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableHeadCell_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableHeadCell, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-head-cell',
+                exportAs: 'luzmoTableHeadCell',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], active: [{
+            type: Input,
+            args: [{ alias: 'active' }]
+        }], sortable: [{
+            type: Input,
+            args: [{ alias: 'sortable' }]
+        }], sortDirection: [{
+            type: Input,
+            args: [{ alias: 'sortDirection' }]
+        }], sortKey: [{
+            type: Input,
+            args: [{ alias: 'sortKey' }]
+        }], columnId: [{
+            type: Input,
+            args: [{ alias: 'columnId' }]
+        }], width: [{
+            type: Input,
+            args: [{ alias: 'width' }]
+        }], minWidth: [{
+            type: Input,
+            args: [{ alias: 'minWidth' }]
+        }], maxWidth: [{
+            type: Input,
+            args: [{ alias: 'maxWidth' }]
+        }], resizable: [{
+            type: Input,
+            args: [{ alias: 'resizable' }]
+        }], lineClamp: [{
+            type: Input,
+            args: [{ alias: 'lineClamp' }]
+        }], luzmoTableSorted: [{ type: i0.Output, args: ["luzmo-table-sorted"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableHeadCell, { className: "LuzmoTableHeadCell", filePath: "components/table-head-cell.ts", lineNumber: 17 }); })();

package/esm/components/table-head.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableHead as LuzmoTableHeadHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableHead implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoTableHeadHostElement;
+    role?: string;
+    /** Whether any row is selected. Mirrored from the table. */
+    selected?: boolean;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoTableHead, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableHead, "luzmo-table-head", ["luzmoTableHead"], { "role": { "alias": "role"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableHead */
+export type LuzmoTableHeadElement = LuzmoTableHeadHostElement;

package/esm/components/table-head.js

@@ -0,0 +1,79 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-head>
+ *
+ * @slot (default) - `luzmo-table-head-cell` elements.
+ */
+export class LuzmoTableHead {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    role;
+    /** Whether any row is selected. Mirrored from the table. */
+    selected;
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'role':
+                    this.setHostProperty('role', changes['role'].currentValue);
+                    break;
+                case 'selected':
+                    this.setHostProperty('selected', changes['selected'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        // No custom events for this wrapper.
+    }
+    static ɵfac = function LuzmoTableHead_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableHead)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableHead, selectors: [["luzmo-table-head"]], inputs: { role: "role", selected: "selected" }, exportAs: ["luzmoTableHead"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableHead_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableHead, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-head',
+                exportAs: 'luzmoTableHead',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], selected: [{
+            type: Input,
+            args: [{ alias: 'selected' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableHead, { className: "LuzmoTableHead", filePath: "components/table-head.ts", lineNumber: 17 }); })();

package/esm/components/table-row-details.d.ts

@@ -0,0 +1,32 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableRowDetails as LuzmoTableRowDetailsHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableRowDetails implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoTableRowDetailsHostElement;
+    role?: string;
+    /** Whether the details row is shown. Set by the table from the owning row. */
+    open?: boolean;
+    /** The closing animation finished and the details row is hidden. */
+    readonly luzmoTableDetailsCollapsed: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoTableRowDetails, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableRowDetails, "luzmo-table-row-details", ["luzmoTableRowDetails"], { "role": { "alias": "role"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "luzmoTableDetailsCollapsed": "luzmo-table-details-collapsed"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableRowDetails */
+export type LuzmoTableRowDetailsElement = LuzmoTableRowDetailsHostElement;

package/esm/components/table-row-details.js

@@ -0,0 +1,83 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-row-details>
+ *
+ * @slot (default) - Details content. A nested `luzmo-table` needs its own accessible name.
+ */
+export class LuzmoTableRowDetails {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    role;
+    /** Whether the details row is shown. Set by the table from the owning row. */
+    open;
+    /** The closing animation finished and the details row is hidden. */
+    luzmoTableDetailsCollapsed = output({ alias: 'luzmo-table-details-collapsed' });
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'role':
+                    this.setHostProperty('role', changes['role'].currentValue);
+                    break;
+                case 'open':
+                    this.setHostProperty('open', changes['open'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-table-details-collapsed', (event) => {
+            this.luzmoTableDetailsCollapsed.emit(event);
+        }));
+    }
+    static ɵfac = function LuzmoTableRowDetails_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableRowDetails)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableRowDetails, selectors: [["luzmo-table-row-details"]], inputs: { role: "role", open: "open" }, outputs: { luzmoTableDetailsCollapsed: "luzmo-table-details-collapsed" }, exportAs: ["luzmoTableRowDetails"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableRowDetails_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableRowDetails, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-row-details',
+                exportAs: 'luzmoTableRowDetails',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], open: [{
+            type: Input,
+            args: [{ alias: 'open' }]
+        }], luzmoTableDetailsCollapsed: [{ type: i0.Output, args: ["luzmo-table-details-collapsed"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableRowDetails, { className: "LuzmoTableRowDetails", filePath: "components/table-row-details.ts", lineNumber: 17 }); })();

package/esm/components/table-row.d.ts

@@ -0,0 +1,38 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableRow as LuzmoTableRowHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableRow implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoTableRowHostElement;
+    role?: string;
+    /** Selection value. Defaults to the row's position when empty. */
+    value?: string;
+    /** Whether the row is selected. Mirrored from the table's `selected`. */
+    selected?: boolean;
+    /** Whether the row can be selected. Set by the table while it `selects`. */
+    selectable?: boolean;
+    /** Whether the row's details are shown. */
+    expanded?: boolean;
+    /** Whether the row has a details sibling or data-mode details renderer. */
+    expandable?: boolean;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoTableRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableRow, "luzmo-table-row", ["luzmoTableRow"], { "role": { "alias": "role"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableRow */
+export type LuzmoTableRowElement = LuzmoTableRowHostElement;

package/esm/components/table-row.js

@@ -0,0 +1,111 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-row>
+ *
+ * @slot (default) - `luzmo-table-cell` elements of the row.
+ */
+export class LuzmoTableRow {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    role;
+    /** Selection value. Defaults to the row's position when empty. */
+    value;
+    /** Whether the row is selected. Mirrored from the table's `selected`. */
+    selected;
+    /** Whether the row can be selected. Set by the table while it `selects`. */
+    selectable;
+    /** Whether the row's details are shown. */
+    expanded;
+    /** Whether the row has a details sibling or data-mode details renderer. */
+    expandable;
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'role':
+                    this.setHostProperty('role', changes['role'].currentValue);
+                    break;
+                case 'value':
+                    this.setHostProperty('value', changes['value'].currentValue);
+                    break;
+                case 'selected':
+                    this.setHostProperty('selected', changes['selected'].currentValue);
+                    break;
+                case 'selectable':
+                    this.setHostProperty('selectable', changes['selectable'].currentValue);
+                    break;
+                case 'expanded':
+                    this.setHostProperty('expanded', changes['expanded'].currentValue);
+                    break;
+                case 'expandable':
+                    this.setHostProperty('expandable', changes['expandable'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        // No custom events for this wrapper.
+    }
+    static ɵfac = function LuzmoTableRow_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableRow)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableRow, selectors: [["luzmo-table-row"]], inputs: { role: "role", value: "value", selected: "selected", selectable: "selectable", expanded: "expanded", expandable: "expandable" }, exportAs: ["luzmoTableRow"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableRow_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableRow, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-row',
+                exportAs: 'luzmoTableRow',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], value: [{
+            type: Input,
+            args: [{ alias: 'value' }]
+        }], selected: [{
+            type: Input,
+            args: [{ alias: 'selected' }]
+        }], selectable: [{
+            type: Input,
+            args: [{ alias: 'selectable' }]
+        }], expanded: [{
+            type: Input,
+            args: [{ alias: 'expanded' }]
+        }], expandable: [{
+            type: Input,
+            args: [{ alias: 'expandable' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableRow, { className: "LuzmoTableRow", filePath: "components/table-row.ts", lineNumber: 17 }); })();

package/esm/components/table.d.ts

@@ -0,0 +1,75 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTable as LuzmoTableHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTable implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoTableHostElement;
+    role?: string;
+    /** Row density. Unset is regular. */
+    density?: ('compact' | 'spacious');
+    /** Use the accent color for selected rows and checkboxes. */
+    emphasized?: boolean;
+    /** Remove the outer border and background. */
+    quiet?: boolean;
+    /** Scroll the body inside the table's block size, keeping the head in view. */
+    scroller?: boolean;
+    /** Row selection mode. Unset disables selection. */
+    selects?: ('single' | 'multiple');
+    /** Selected row values. */
+    selected?: string[];
+    /** Accessible name of the select-all checkbox. Overrides `labels.selectAll`. */
+    selectAllLabel?: string;
+    /** Row records. Setting an array switches the table to data mode. */
+    items?: (Record<string, unknown>)[];
+    /** Stable, unique selection value of a data-mode row. Defaults to the item index. */
+    itemValue?: unknown;
+    /** Accessible name of a data-mode row checkbox. Defaults to the first column's text, then `labels.selectRow`. */
+    itemLabel?: unknown;
+    /** Cell content of a data-mode row. Return `luzmo-table-cell` elements. */
+    renderItem?: unknown;
+    /** Expanded row values. Setting `renderDetails` enables data-mode disclosure. */
+    expanded?: string[];
+    /** Details content of a data-mode row. Its presence enables row disclosure for every non-information row. */
+    renderDetails?: unknown;
+    /** Resized column widths, in pixels, keyed by column id. A resize updates this map without changing `columns`. */
+    columnWidths?: Record<string, number>;
+    /** Data-mode columns, used when no `luzmo-table-head` is slotted. */
+    columns?: unknown;
+    /** Mount only the visible rows. Data mode only; needs a bounded block size. */
+    virtualized?: boolean;
+    /** Translatable copy. */
+    labels?: unknown;
+    size?: ('xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl');
+    /** `selected` changed. Cancel it to keep the previous selection. */
+    readonly changeEvent: import("@angular/core").OutputEmitterRef<Event>;
+    /** A sortable header was activated. `detail` is `{ sortKey, sortDirection }`. Cancel it in data mode to skip the client sort. */
+    readonly luzmoTableSorted: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    /** A row's details were expanded or collapsed. `detail` is `{ value, expanded }`. Cancel it to keep the previous state. */
+    readonly luzmoTableRowToggle: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    /** A column resize committed. `detail` is `{ columnId, width, columnWidths }`. */
+    readonly luzmoColumnResized: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    /** The mounted window of a virtualized table changed. `detail` is `{ first, last }`. */
+    readonly luzmoRangeChanged: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    /** Moves focus to the grid's current cell. */
+    focus(options?: FocusOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoTable, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTable, "luzmo-table", ["luzmoTable"], { "role": { "alias": "role"; "required": false; }; "density": { "alias": "density"; "required": false; }; "emphasized": { "alias": "emphasized"; "required": false; }; "quiet": { "alias": "quiet"; "required": false; }; "scroller": { "alias": "scroller"; "required": false; }; "selects": { "alias": "selects"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; }; "items": { "alias": "items"; "required": false; }; "itemValue": { "alias": "itemValue"; "required": false; }; "itemLabel": { "alias": "itemLabel"; "required": false; }; "renderItem": { "alias": "renderItem"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "renderDetails": { "alias": "renderDetails"; "required": false; }; "columnWidths": { "alias": "columnWidths"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "virtualized": { "alias": "virtualized"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "changeEvent": "changeEvent"; "luzmoTableSorted": "luzmo-table-sorted"; "luzmoTableRowToggle": "luzmo-table-row-toggle"; "luzmoColumnResized": "luzmo-column-resized"; "luzmoRangeChanged": "luzmo-range-changed"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTable */
+export type LuzmoTableElement = LuzmoTableHostElement;