@luzmo/ngx-lucero 1.0.1-alpha.78

package/esm/components/text-field.js

@@ -0,0 +1,308 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, forwardRef, inject, Input, output, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import '@luzmo/lucero/text-field';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-text-field>
+ *
+ * @slot help-text - default or non-negative help text to associate to your form element
+ * @slot negative-help-text - negative help text to associate to your form element when `invalid`
+ */
+export class LuzmoTextField {
+    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;
+    }
+    /** The value held by the form control */
+    value;
+    helpTextManager;
+    /** A regular expression outlining the keys that will be allowed to update the value of the form control. */
+    allowedKeys;
+    /** Whether the `value` held by the form control is invalid. */
+    invalid;
+    /** A string applied via `aria-label` to the form control when a user visible label is not provided. */
+    label;
+    /** Name of the form control. */
+    name;
+    /** Text that appears in the form control when it has no value set */
+    placeholder;
+    type;
+    /** Pattern the `value` must match to be valid */
+    pattern;
+    /** Whether a form control delivered with the `multiline` attribute will change size vertically to accomodate longer input */
+    grows;
+    /** Defines the maximum string length that the user can enter */
+    maxlength;
+    /** Defines the minimum string length that the user can enter */
+    minlength;
+    /** Whether the form control should accept a value longer than one line */
+    multiline;
+    /** Whether a user can interact with the value of the form control */
+    readonly;
+    /** The specific number of rows the form control should provide in the user interface */
+    rows;
+    /** The maximum number of rows the form control should grow to when `grows` is enabled. When content exceeds this limit, the textarea will show a scrollbar. A value of -1 means no maximum (unlimited growth). When set, the value must be >= 1; values < 1 will be disregarded. */
+    maxRows;
+    /** Whether the `value` held by the form control is valid. */
+    valid;
+    /** Whether to hide the validation state icons (valid/invalid icons). */
+    hideValidationIcons;
+    /** Whether to display the form control with no visible background */
+    quiet;
+    /** Whether the form control will be found to be invalid when it holds no `value` */
+    required;
+    /** What form of assistance should be provided when attempting to supply a value to the form control */
+    autocomplete;
+    /** An alteration to the value of the element has been committed by the user. */
+    changeEvent = output({ alias: 'change' });
+    /** The value of the element has changed. */
+    inputEvent = output({ alias: 'input' });
+    /** A key has been pressed. */
+    keypressEvent = output({ alias: 'keypress' });
+    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 'value':
+                    this.setHostProperty('value', changes['value'].currentValue);
+                    break;
+                case 'helpTextManager':
+                    this.setHostProperty('helpTextManager', changes['helpTextManager'].currentValue);
+                    break;
+                case 'allowedKeys':
+                    this.setHostProperty('allowedKeys', changes['allowedKeys'].currentValue);
+                    break;
+                case 'invalid':
+                    this.setHostProperty('invalid', changes['invalid'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].currentValue);
+                    break;
+                case 'name':
+                    this.setHostProperty('name', changes['name'].currentValue);
+                    break;
+                case 'placeholder':
+                    this.setHostProperty('placeholder', changes['placeholder'].currentValue);
+                    break;
+                case 'type':
+                    this.setHostProperty('type', changes['type'].currentValue);
+                    break;
+                case 'pattern':
+                    this.setHostProperty('pattern', changes['pattern'].currentValue);
+                    break;
+                case 'grows':
+                    this.setHostProperty('grows', changes['grows'].currentValue);
+                    break;
+                case 'maxlength':
+                    this.setHostProperty('maxlength', changes['maxlength'].currentValue);
+                    break;
+                case 'minlength':
+                    this.setHostProperty('minlength', changes['minlength'].currentValue);
+                    break;
+                case 'multiline':
+                    this.setHostProperty('multiline', changes['multiline'].currentValue);
+                    break;
+                case 'readonly':
+                    this.setHostProperty('readonly', changes['readonly'].currentValue);
+                    break;
+                case 'rows':
+                    this.setHostProperty('rows', changes['rows'].currentValue);
+                    break;
+                case 'maxRows':
+                    this.setHostProperty('maxRows', changes['maxRows'].currentValue);
+                    break;
+                case 'valid':
+                    this.setHostProperty('valid', changes['valid'].currentValue);
+                    break;
+                case 'hideValidationIcons':
+                    this.setHostProperty('hideValidationIcons', changes['hideValidationIcons'].currentValue);
+                    break;
+                case 'quiet':
+                    this.setHostProperty('quiet', changes['quiet'].currentValue);
+                    break;
+                case 'required':
+                    this.setHostProperty('required', changes['required'].currentValue);
+                    break;
+                case 'autocomplete':
+                    this.setHostProperty('autocomplete', changes['autocomplete'].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, 'change', (event) => {
+            this.changeEvent.emit(event);
+            if (!this.isWritingValue) {
+                const eventWithDetail = event;
+                const eventTarget = event.target;
+                const detail = 'detail' in eventWithDetail ? eventWithDetail.detail : undefined;
+                const hostRecord = this.host;
+                const nextValue = (detail
+                    ?? eventTarget?.['value']
+                    ?? hostRecord['value']);
+                if (Object.is(this.lastCvaValue, nextValue)) {
+                    return;
+                }
+                this.lastCvaValue = nextValue;
+                this.setHostProperty('value', nextValue);
+                this.onChange(nextValue);
+            }
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'input', (event) => {
+            this.inputEvent.emit(event);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'keypress', (event) => {
+            this.keypressEvent.emit(event);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'blur', () => {
+            this.onTouched();
+        }));
+    }
+    onChange = () => { };
+    onTouched = () => { };
+    isWritingValue = false;
+    lastCvaValue;
+    writeValue(value) {
+        this.isWritingValue = true;
+        this.lastCvaValue = value;
+        this.setHostProperty('value', value);
+        this.isWritingValue = false;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        // Underlying element does not declare a 'disabled' field; nothing to do.
+        void isDisabled;
+    }
+    /** Sets the start and end positions of the current selection. */
+    setSelectionRange(selectionStart, selectionEnd, selectionDirection) {
+        return this.host.setSelectionRange(selectionStart, selectionEnd, selectionDirection);
+    }
+    /** Selects all the text. */
+    select() {
+        return this.host.select();
+    }
+    checkValidity() {
+        return this.host.checkValidity();
+    }
+    static ɵfac = function LuzmoTextField_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTextField)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTextField, selectors: [["luzmo-text-field"]], inputs: { value: "value", helpTextManager: [0, "help-text-manager", "helpTextManager"], allowedKeys: [0, "allowed-keys", "allowedKeys"], invalid: "invalid", label: "label", name: "name", placeholder: "placeholder", type: "type", pattern: "pattern", grows: "grows", maxlength: "maxlength", minlength: "minlength", multiline: "multiline", readonly: "readonly", rows: "rows", maxRows: [0, "max-rows", "maxRows"], valid: "valid", hideValidationIcons: [0, "hide-validation-icons", "hideValidationIcons"], quiet: "quiet", required: "required", autocomplete: "autocomplete" }, outputs: { changeEvent: "change", inputEvent: "input", keypressEvent: "keypress" }, exportAs: ["luzmoTextField"], features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(() => LuzmoTextField),
+                    multi: true
+                }
+            ]), i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTextField_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTextField, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-text-field',
+                exportAs: 'luzmoTextField',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />',
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => LuzmoTextField),
+                        multi: true
+                    }
+                ]
+            }]
+    }], () => [], { value: [{
+            type: Input,
+            args: [{ alias: 'value' }]
+        }], helpTextManager: [{
+            type: Input,
+            args: [{ alias: 'help-text-manager' }]
+        }], allowedKeys: [{
+            type: Input,
+            args: [{ alias: 'allowed-keys' }]
+        }], invalid: [{
+            type: Input,
+            args: [{ alias: 'invalid' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], name: [{
+            type: Input,
+            args: [{ alias: 'name' }]
+        }], placeholder: [{
+            type: Input,
+            args: [{ alias: 'placeholder' }]
+        }], type: [{
+            type: Input,
+            args: [{ alias: 'type' }]
+        }], pattern: [{
+            type: Input,
+            args: [{ alias: 'pattern' }]
+        }], grows: [{
+            type: Input,
+            args: [{ alias: 'grows' }]
+        }], maxlength: [{
+            type: Input,
+            args: [{ alias: 'maxlength' }]
+        }], minlength: [{
+            type: Input,
+            args: [{ alias: 'minlength' }]
+        }], multiline: [{
+            type: Input,
+            args: [{ alias: 'multiline' }]
+        }], readonly: [{
+            type: Input,
+            args: [{ alias: 'readonly' }]
+        }], rows: [{
+            type: Input,
+            args: [{ alias: 'rows' }]
+        }], maxRows: [{
+            type: Input,
+            args: [{ alias: 'max-rows' }]
+        }], valid: [{
+            type: Input,
+            args: [{ alias: 'valid' }]
+        }], hideValidationIcons: [{
+            type: Input,
+            args: [{ alias: 'hide-validation-icons' }]
+        }], quiet: [{
+            type: Input,
+            args: [{ alias: 'quiet' }]
+        }], required: [{
+            type: Input,
+            args: [{ alias: 'required' }]
+        }], autocomplete: [{
+            type: Input,
+            args: [{ alias: 'autocomplete' }]
+        }], changeEvent: [{ type: i0.Output, args: ["change"] }], inputEvent: [{ type: i0.Output, args: ["input"] }], keypressEvent: [{ type: i0.Output, args: ["keypress"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTextField, { className: "LuzmoTextField", filePath: "components/text-field.ts", lineNumber: 26 }); })();

package/esm/components/toast.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/toast';
+import type { LuzmoToast as LuzmoToastHostElement } from '@luzmo/lucero/toast';
+import * as i0 from "@angular/core";
+export declare class LuzmoToast 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(): LuzmoToastHostElement;
+    /** Announces that the Toast has been closed by the user or by its timeout. */
+    readonly closeEvent: 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;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoToast, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoToast, "luzmo-toast", ["luzmoToast"], {}, { "closeEvent": "close"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoToast */
+export type LuzmoToastElement = LuzmoToastHostElement;

package/esm/components/toast.js

@@ -0,0 +1,68 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, output, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/toast';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-toast>
+ *
+ * @slot (default) - The toast content
+ * @slot action - button element surfacing an action in the Toast
+ */
+export class LuzmoToast {
+    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;
+    }
+    /** Announces that the Toast has been closed by the user or by its timeout. */
+    closeEvent = output({ alias: 'close' });
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        // No mapped inputs for this wrapper.
+        void changes;
+    }
+    /**
+     * 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, 'close', (event) => {
+            this.closeEvent.emit(event);
+        }));
+    }
+    close() {
+        return this.host.close();
+    }
+    static ɵfac = function LuzmoToast_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoToast)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoToast, selectors: [["luzmo-toast"]], outputs: { closeEvent: "close" }, exportAs: ["luzmoToast"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoToast_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoToast, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-toast',
+                exportAs: 'luzmoToast',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { closeEvent: [{ type: i0.Output, args: ["close"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoToast, { className: "LuzmoToast", filePath: "components/toast.ts", lineNumber: 18 }); })();

package/esm/components/tooltip.d.ts

@@ -0,0 +1,44 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/tooltip';
+import type { LuzmoTooltip as LuzmoTooltipHostElement } from '@luzmo/lucero/tooltip';
+import * as i0 from "@angular/core";
+export declare class LuzmoTooltip 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(): LuzmoTooltipHostElement;
+    /** A Tooltip that is `delayed` will its Overlay wait until a warm-up period of 1000ms has completed before opening. Once the warmup period has completed, all subsequent Overlays will open immediately. When no Overlays are opened, a cooldown period of 1000ms will begin. Once the cooldown has completed, the next Overlay to be opened will be subject to the warm-up period if provided that option. */
+    delayed?: boolean;
+    /** Whether to prevent a self-managed Tooltip from responding to user input. */
+    disabled?: boolean;
+    /** Whether to show the tooltip only if the content is truncated. */
+    showOnlyIfTruncated?: boolean;
+    /** The selector of the element to check for truncation. */
+    truncatedElementSelector?: string;
+    /** Automatically bind to the parent element of the assigned `slot` or the parent element of the `luzmo-tooltip`. Without this, you must provide your own `overlay-trigger`. */
+    selfManaged?: boolean;
+    offset?: number;
+    open?: boolean;
+    overlayElement?: unknown;
+    placement?: "top" | "top-start" | "top-end" | "right" | "right-start" | "right-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end";
+    tipElement?: unknown;
+    tipPadding?: number;
+    variant?: 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<LuzmoTooltip, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTooltip, "luzmo-tooltip", ["luzmoTooltip"], { "delayed": { "alias": "delayed"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showOnlyIfTruncated": { "alias": "show-only-if-truncated"; "required": false; }; "truncatedElementSelector": { "alias": "truncated-element-selector"; "required": false; }; "selfManaged": { "alias": "self-managed"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "open": { "alias": "open"; "required": false; }; "overlayElement": { "alias": "overlay-element"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "tipElement": { "alias": "tip-element"; "required": false; }; "tipPadding": { "alias": "tip-padding"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTooltip */
+export type LuzmoTooltipElement = LuzmoTooltipHostElement;

package/esm/components/tooltip.js

@@ -0,0 +1,154 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/tooltip';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-tooltip>
+ *
+ * @slot icon - the icon element appearing at the start of the label
+ * @slot (default) - the text label of the Tooltip
+ */
+export class LuzmoTooltip {
+    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;
+    }
+    /** A Tooltip that is `delayed` will its Overlay wait until a warm-up period of 1000ms has completed before opening. Once the warmup period has completed, all subsequent Overlays will open immediately. When no Overlays are opened, a cooldown period of 1000ms will begin. Once the cooldown has completed, the next Overlay to be opened will be subject to the warm-up period if provided that option. */
+    delayed;
+    /** Whether to prevent a self-managed Tooltip from responding to user input. */
+    disabled;
+    /** Whether to show the tooltip only if the content is truncated. */
+    showOnlyIfTruncated;
+    /** The selector of the element to check for truncation. */
+    truncatedElementSelector;
+    /** Automatically bind to the parent element of the assigned `slot` or the parent element of the `luzmo-tooltip`. Without this, you must provide your own `overlay-trigger`. */
+    selfManaged;
+    offset;
+    open;
+    overlayElement;
+    placement;
+    tipElement;
+    tipPadding;
+    variant;
+    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 'delayed':
+                    this.setHostProperty('delayed', changes['delayed'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'showOnlyIfTruncated':
+                    this.setHostProperty('showOnlyIfTruncated', changes['showOnlyIfTruncated'].currentValue);
+                    break;
+                case 'truncatedElementSelector':
+                    this.setHostProperty('truncatedElementSelector', changes['truncatedElementSelector'].currentValue);
+                    break;
+                case 'selfManaged':
+                    this.setHostProperty('selfManaged', changes['selfManaged'].currentValue);
+                    break;
+                case 'offset':
+                    this.setHostProperty('offset', changes['offset'].currentValue);
+                    break;
+                case 'open':
+                    this.setHostProperty('open', changes['open'].currentValue);
+                    break;
+                case 'overlayElement':
+                    this.setHostProperty('overlayElement', changes['overlayElement'].currentValue);
+                    break;
+                case 'placement':
+                    this.setHostProperty('placement', changes['placement'].currentValue);
+                    break;
+                case 'tipElement':
+                    this.setHostProperty('tipElement', changes['tipElement'].currentValue);
+                    break;
+                case 'tipPadding':
+                    this.setHostProperty('tipPadding', changes['tipPadding'].currentValue);
+                    break;
+                case 'variant':
+                    this.setHostProperty('variant', changes['variant'].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 LuzmoTooltip_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTooltip)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTooltip, selectors: [["luzmo-tooltip"]], inputs: { delayed: "delayed", disabled: "disabled", showOnlyIfTruncated: [0, "show-only-if-truncated", "showOnlyIfTruncated"], truncatedElementSelector: [0, "truncated-element-selector", "truncatedElementSelector"], selfManaged: [0, "self-managed", "selfManaged"], offset: "offset", open: "open", overlayElement: [0, "overlay-element", "overlayElement"], placement: "placement", tipElement: [0, "tip-element", "tipElement"], tipPadding: [0, "tip-padding", "tipPadding"], variant: "variant" }, exportAs: ["luzmoTooltip"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTooltip_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTooltip, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-tooltip',
+                exportAs: 'luzmoTooltip',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { delayed: [{
+            type: Input,
+            args: [{ alias: 'delayed' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled' }]
+        }], showOnlyIfTruncated: [{
+            type: Input,
+            args: [{ alias: 'show-only-if-truncated' }]
+        }], truncatedElementSelector: [{
+            type: Input,
+            args: [{ alias: 'truncated-element-selector' }]
+        }], selfManaged: [{
+            type: Input,
+            args: [{ alias: 'self-managed' }]
+        }], offset: [{
+            type: Input,
+            args: [{ alias: 'offset' }]
+        }], open: [{
+            type: Input,
+            args: [{ alias: 'open' }]
+        }], overlayElement: [{
+            type: Input,
+            args: [{ alias: 'overlay-element' }]
+        }], placement: [{
+            type: Input,
+            args: [{ alias: 'placement' }]
+        }], tipElement: [{
+            type: Input,
+            args: [{ alias: 'tip-element' }]
+        }], tipPadding: [{
+            type: Input,
+            args: [{ alias: 'tip-padding' }]
+        }], variant: [{
+            type: Input,
+            args: [{ alias: 'variant' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTooltip, { className: "LuzmoTooltip", filePath: "components/tooltip.ts", lineNumber: 18 }); })();

package/esm/components/top-nav-item.d.ts

@@ -0,0 +1,35 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/top-nav';
+import type { LuzmoTopNavItem as LuzmoTopNavItemHostElement } from '@luzmo/lucero/top-nav';
+import * as i0 from "@angular/core";
+export declare class LuzmoTopNavItem 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(): LuzmoTopNavItemHostElement;
+    href?: string;
+    target?: string;
+    download?: string;
+    rel?: string;
+    label?: string;
+    selected?: boolean;
+    disabled?: boolean;
+    value?: 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<LuzmoTopNavItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTopNavItem, "luzmo-top-nav-item", ["luzmoTopNavItem"], { "href": { "alias": "href"; "required": false; }; "target": { "alias": "target"; "required": false; }; "download": { "alias": "download"; "required": false; }; "rel": { "alias": "rel"; "required": false; }; "label": { "alias": "label"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTopNavItem */
+export type LuzmoTopNavItemElement = LuzmoTopNavItemHostElement;