@luzmo/ngx-lucero 2.4.2 → 2.5.1

package/esm/components/table-disclosure-cell.d.ts

@@ -0,0 +1,31 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableDisclosureCell as LuzmoTableDisclosureCellHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableDisclosureCell 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(): LuzmoTableDisclosureCellHostElement;
+    role?: string;
+    expanded?: boolean;
+    /** Accessible name of the disclosure button. */
+    label?: string;
+    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<LuzmoTableDisclosureCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableDisclosureCell, "luzmo-table-disclosure-cell", ["luzmoTableDisclosureCell"], { "role": { "alias": "role"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableDisclosureCell */
+export type LuzmoTableDisclosureCellElement = LuzmoTableDisclosureCellHostElement;

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

@@ -0,0 +1,84 @@
+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-disclosure-cell>
+ */
+export class LuzmoTableDisclosureCell {
+    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;
+    expanded;
+    /** Accessible name of the disclosure button. */
+    label;
+    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 'expanded':
+                    this.setHostProperty('expanded', changes['expanded'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].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 LuzmoTableDisclosureCell_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableDisclosureCell)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableDisclosureCell, selectors: [["luzmo-table-disclosure-cell"]], inputs: { role: "role", expanded: "expanded", label: "label" }, exportAs: ["luzmoTableDisclosureCell"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableDisclosureCell_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableDisclosureCell, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-disclosure-cell',
+                exportAs: 'luzmoTableDisclosureCell',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], expanded: [{
+            type: Input,
+            args: [{ alias: 'expanded' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableDisclosureCell, { className: "LuzmoTableDisclosureCell", filePath: "components/table-disclosure-cell.ts", lineNumber: 15 }); })();

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

@@ -0,0 +1,50 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableHeadCell as LuzmoTableHeadCellHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableHeadCell 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(): LuzmoTableHeadCellHostElement;
+    role?: string;
+    /** Pressed state while Space is held on a sortable header. */
+    active?: boolean;
+    /** Whether activating the header sorts the table. */
+    sortable?: boolean;
+    /** Current sort direction. Unset when the column is not sorted. */
+    sortDirection?: ('asc' | 'desc');
+    /** Item key the column sorts by. Sent as `sortKey` in `luzmo-table-sorted`. */
+    sortKey?: string;
+    /** Stable column identifier. Defaults to `sortKey`, then the column index. */
+    columnId?: string;
+    /** Fixed column width, in pixels. */
+    width?: number;
+    /** Minimum column width, in pixels. */
+    minWidth?: number;
+    /** Maximum column width, in pixels. */
+    maxWidth?: number;
+    /** Whether the header shows a resize handle. */
+    resizable?: boolean;
+    /** Maximum number of header lines before the text truncates. Unset wraps. Also the default clamp for the column's cells. */
+    lineClamp?: number;
+    /** 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. */
+    readonly luzmoTableSorted: 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<LuzmoTableHeadCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableHeadCell, "luzmo-table-head-cell", ["luzmoTableHeadCell"], { "role": { "alias": "role"; "required": false; }; "active": { "alias": "active"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "sortKey": { "alias": "sortKey"; "required": false; }; "columnId": { "alias": "columnId"; "required": false; }; "width": { "alias": "width"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "lineClamp": { "alias": "lineClamp"; "required": false; }; }, { "luzmoTableSorted": "luzmo-table-sorted"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableHeadCell */
+export type LuzmoTableHeadCellElement = LuzmoTableHeadCellHostElement;

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;