@luzmo/ngx-lucero 1.0.1-alpha.78

package/esm/components/select.js

@@ -0,0 +1,351 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, forwardRef, inject, Input, output, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import '@luzmo/lucero/select';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-select>
+ *
+ * @slot label - The placeholder content for the Select
+ * @slot description - The description content for the Select
+ * @slot tooltip - Tooltip to to be applied to the the Select Button
+ */
+export class LuzmoSelect {
+    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;
+    }
+    disabled;
+    focused;
+    icons;
+    variant;
+    emphasized;
+    invalid;
+    search;
+    noWrap;
+    retrieving;
+    pending;
+    clearable;
+    hideDropdownIcon;
+    /** Defines a string value that labels the Picker while it is in pending state. */
+    pendingLabel;
+    /** Defines a string value that labels the search input field. */
+    searchLabel;
+    /** Defines a string value that is displayed when no results are found. */
+    noResultsLabel;
+    noDataLabel;
+    multipleLabelTemplate;
+    label;
+    open;
+    readonly;
+    labelAlignment;
+    placement;
+    quiet;
+    /** The value of the select. */
+    value;
+    /** The options of the select. */
+    options;
+    /** Optional icon renderer callback forwarded to luzmo-options. Return null to use the default icon/imgSrc rendering. */
+    optionIconRenderer;
+    selects;
+    /** Announces that the `value` of the element has changed */
+    changeEvent = output({ alias: 'change' });
+    /** Announces that the user has scrolled within the options menu. Only fires when the options menu is virtualized. */
+    luzmoScrolledEvent = output({ alias: 'luzmo-scrolled' });
+    /** Announces that the search has been updated */
+    luzmoSearchEvent = output({ alias: 'luzmo-search' });
+    /** Announces that the overlay has been opened */
+    luzmoOpenedEvent = output({ alias: 'luzmo-opened' });
+    /** Announces that the overlay has been closed */
+    luzmoClosedEvent = output({ alias: 'luzmo-closed' });
+    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 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'focused':
+                    this.setHostProperty('focused', changes['focused'].currentValue);
+                    break;
+                case 'icons':
+                    this.setHostProperty('icons', changes['icons'].currentValue);
+                    break;
+                case 'variant':
+                    this.setHostProperty('variant', changes['variant'].currentValue);
+                    break;
+                case 'emphasized':
+                    this.setHostProperty('emphasized', changes['emphasized'].currentValue);
+                    break;
+                case 'invalid':
+                    this.setHostProperty('invalid', changes['invalid'].currentValue);
+                    break;
+                case 'search':
+                    this.setHostProperty('search', changes['search'].currentValue);
+                    break;
+                case 'noWrap':
+                    this.setHostProperty('noWrap', changes['noWrap'].currentValue);
+                    break;
+                case 'retrieving':
+                    this.setHostProperty('retrieving', changes['retrieving'].currentValue);
+                    break;
+                case 'pending':
+                    this.setHostProperty('pending', changes['pending'].currentValue);
+                    break;
+                case 'clearable':
+                    this.setHostProperty('clearable', changes['clearable'].currentValue);
+                    break;
+                case 'hideDropdownIcon':
+                    this.setHostProperty('hideDropdownIcon', changes['hideDropdownIcon'].currentValue);
+                    break;
+                case 'pendingLabel':
+                    this.setHostProperty('pendingLabel', changes['pendingLabel'].currentValue);
+                    break;
+                case 'searchLabel':
+                    this.setHostProperty('searchLabel', changes['searchLabel'].currentValue);
+                    break;
+                case 'noResultsLabel':
+                    this.setHostProperty('noResultsLabel', changes['noResultsLabel'].currentValue);
+                    break;
+                case 'noDataLabel':
+                    this.setHostProperty('noDataLabel', changes['noDataLabel'].currentValue);
+                    break;
+                case 'multipleLabelTemplate':
+                    this.setHostProperty('multipleLabelTemplate', changes['multipleLabelTemplate'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].currentValue);
+                    break;
+                case 'open':
+                    this.setHostProperty('open', changes['open'].currentValue);
+                    break;
+                case 'readonly':
+                    this.setHostProperty('readonly', changes['readonly'].currentValue);
+                    break;
+                case 'labelAlignment':
+                    this.setHostProperty('labelAlignment', changes['labelAlignment'].currentValue);
+                    break;
+                case 'placement':
+                    this.setHostProperty('placement', changes['placement'].currentValue);
+                    break;
+                case 'quiet':
+                    this.setHostProperty('quiet', changes['quiet'].currentValue);
+                    break;
+                case 'value':
+                    this.setHostProperty('value', changes['value'].currentValue);
+                    break;
+                case 'options':
+                    this.setHostProperty('options', changes['options'].currentValue);
+                    break;
+                case 'optionIconRenderer':
+                    this.setHostProperty('optionIconRenderer', changes['optionIconRenderer'].currentValue);
+                    break;
+                case 'selects':
+                    this.setHostProperty('selects', changes['selects'].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, 'luzmo-scrolled', (event) => {
+            this.luzmoScrolledEvent.emit(event);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-search', (event) => {
+            this.luzmoSearchEvent.emit(event);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-opened', (event) => {
+            this.luzmoOpenedEvent.emit(event);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-closed', (event) => {
+            this.luzmoClosedEvent.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) {
+        this.setHostProperty('disabled', isDisabled);
+        if (isDisabled) {
+            this.renderer.setAttribute(this.host, 'disabled', '');
+        }
+        else {
+            this.renderer.removeAttribute(this.host, 'disabled');
+        }
+    }
+    focus(options) {
+        return this.host.focus(options);
+    }
+    toggle(target) {
+        return this.host.toggle(target);
+    }
+    close() {
+        return this.host.close();
+    }
+    static ɵfac = function LuzmoSelect_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoSelect)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoSelect, selectors: [["luzmo-select"]], inputs: { disabled: "disabled", focused: "focused", icons: "icons", variant: "variant", emphasized: "emphasized", invalid: "invalid", search: "search", noWrap: [0, "no-wrap", "noWrap"], retrieving: "retrieving", pending: "pending", clearable: "clearable", hideDropdownIcon: [0, "hide-dropdown-icon", "hideDropdownIcon"], pendingLabel: [0, "pending-label", "pendingLabel"], searchLabel: [0, "search-label", "searchLabel"], noResultsLabel: [0, "no-results-label", "noResultsLabel"], noDataLabel: [0, "no-data-label", "noDataLabel"], multipleLabelTemplate: [0, "multiple-label-template", "multipleLabelTemplate"], label: "label", open: "open", readonly: "readonly", labelAlignment: [0, "label-alignment", "labelAlignment"], placement: "placement", quiet: "quiet", value: "value", options: "options", optionIconRenderer: [0, "option-icon-renderer", "optionIconRenderer"], selects: "selects" }, outputs: { changeEvent: "change", luzmoScrolledEvent: "luzmo-scrolled", luzmoSearchEvent: "luzmo-search", luzmoOpenedEvent: "luzmo-opened", luzmoClosedEvent: "luzmo-closed" }, exportAs: ["luzmoSelect"], features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(() => LuzmoSelect),
+                    multi: true
+                }
+            ]), i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoSelect_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoSelect, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-select',
+                exportAs: 'luzmoSelect',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />',
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => LuzmoSelect),
+                        multi: true
+                    }
+                ]
+            }]
+    }], () => [], { disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled' }]
+        }], focused: [{
+            type: Input,
+            args: [{ alias: 'focused' }]
+        }], icons: [{
+            type: Input,
+            args: [{ alias: 'icons' }]
+        }], variant: [{
+            type: Input,
+            args: [{ alias: 'variant' }]
+        }], emphasized: [{
+            type: Input,
+            args: [{ alias: 'emphasized' }]
+        }], invalid: [{
+            type: Input,
+            args: [{ alias: 'invalid' }]
+        }], search: [{
+            type: Input,
+            args: [{ alias: 'search' }]
+        }], noWrap: [{
+            type: Input,
+            args: [{ alias: 'no-wrap' }]
+        }], retrieving: [{
+            type: Input,
+            args: [{ alias: 'retrieving' }]
+        }], pending: [{
+            type: Input,
+            args: [{ alias: 'pending' }]
+        }], clearable: [{
+            type: Input,
+            args: [{ alias: 'clearable' }]
+        }], hideDropdownIcon: [{
+            type: Input,
+            args: [{ alias: 'hide-dropdown-icon' }]
+        }], pendingLabel: [{
+            type: Input,
+            args: [{ alias: 'pending-label' }]
+        }], searchLabel: [{
+            type: Input,
+            args: [{ alias: 'search-label' }]
+        }], noResultsLabel: [{
+            type: Input,
+            args: [{ alias: 'no-results-label' }]
+        }], noDataLabel: [{
+            type: Input,
+            args: [{ alias: 'no-data-label' }]
+        }], multipleLabelTemplate: [{
+            type: Input,
+            args: [{ alias: 'multiple-label-template' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], open: [{
+            type: Input,
+            args: [{ alias: 'open' }]
+        }], readonly: [{
+            type: Input,
+            args: [{ alias: 'readonly' }]
+        }], labelAlignment: [{
+            type: Input,
+            args: [{ alias: 'label-alignment' }]
+        }], placement: [{
+            type: Input,
+            args: [{ alias: 'placement' }]
+        }], quiet: [{
+            type: Input,
+            args: [{ alias: 'quiet' }]
+        }], value: [{
+            type: Input,
+            args: [{ alias: 'value' }]
+        }], options: [{
+            type: Input,
+            args: [{ alias: 'options' }]
+        }], optionIconRenderer: [{
+            type: Input,
+            args: [{ alias: 'option-icon-renderer' }]
+        }], selects: [{
+            type: Input,
+            args: [{ alias: 'selects' }]
+        }], changeEvent: [{ type: i0.Output, args: ["change"] }], luzmoScrolledEvent: [{ type: i0.Output, args: ["luzmo-scrolled"] }], luzmoSearchEvent: [{ type: i0.Output, args: ["luzmo-search"] }], luzmoOpenedEvent: [{ type: i0.Output, args: ["luzmo-opened"] }], luzmoClosedEvent: [{ type: i0.Output, args: ["luzmo-closed"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoSelect, { className: "LuzmoSelect", filePath: "components/select.ts", lineNumber: 27 }); })();

package/esm/components/slider.d.ts

@@ -0,0 +1,47 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import '@luzmo/lucero/slider';
+import type { LuzmoSlider as LuzmoSliderHostElement } from '@luzmo/lucero/slider';
+import type { API as __extt_NoUiSlider } from 'nouislider';
+import * as i0 from "@angular/core";
+export declare class LuzmoSlider implements OnChanges, ControlValueAccessor {
+    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(): LuzmoSliderHostElement;
+    label?: string;
+    value?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    debounce?: number;
+    noUiSlider?: __extt_NoUiSlider;
+    debounceTimeout?: any;
+    readonly changeEvent: 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;
+    private onChange;
+    private onTouched;
+    private isWritingValue;
+    private lastCvaValue;
+    writeValue(value: number): void;
+    registerOnChange(fn: (value: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoSlider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoSlider, "luzmo-slider", ["luzmoSlider"], { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; "noUiSlider": { "alias": "no-ui-slider"; "required": false; }; "debounceTimeout": { "alias": "debounce-timeout"; "required": false; }; }, { "changeEvent": "change"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoSlider */
+export type LuzmoSliderElement = LuzmoSliderHostElement;

package/esm/components/slider.js

@@ -0,0 +1,185 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, forwardRef, inject, Input, output, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import '@luzmo/lucero/slider';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-slider>
+ */
+export class LuzmoSlider {
+    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;
+    }
+    label;
+    value;
+    min;
+    max;
+    step;
+    disabled;
+    debounce;
+    noUiSlider;
+    debounceTimeout;
+    changeEvent = output({ alias: 'change' });
+    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 'label':
+                    this.setHostProperty('label', changes['label'].currentValue);
+                    break;
+                case 'value':
+                    this.setHostProperty('value', changes['value'].currentValue);
+                    break;
+                case 'min':
+                    this.setHostProperty('min', changes['min'].currentValue);
+                    break;
+                case 'max':
+                    this.setHostProperty('max', changes['max'].currentValue);
+                    break;
+                case 'step':
+                    this.setHostProperty('step', changes['step'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'debounce':
+                    this.setHostProperty('debounce', changes['debounce'].currentValue);
+                    break;
+                case 'noUiSlider':
+                    this.setHostProperty('noUiSlider', changes['noUiSlider'].currentValue);
+                    break;
+                case 'debounceTimeout':
+                    this.setHostProperty('debounceTimeout', changes['debounceTimeout'].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, '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) {
+        this.setHostProperty('disabled', isDisabled);
+        if (isDisabled) {
+            this.renderer.setAttribute(this.host, 'disabled', '');
+        }
+        else {
+            this.renderer.removeAttribute(this.host, 'disabled');
+        }
+    }
+    static ɵfac = function LuzmoSlider_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoSlider)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoSlider, selectors: [["luzmo-slider"]], inputs: { label: "label", value: "value", min: "min", max: "max", step: "step", disabled: "disabled", debounce: "debounce", noUiSlider: [0, "no-ui-slider", "noUiSlider"], debounceTimeout: [0, "debounce-timeout", "debounceTimeout"] }, outputs: { changeEvent: "change" }, exportAs: ["luzmoSlider"], features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(() => LuzmoSlider),
+                    multi: true
+                }
+            ]), i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoSlider_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoSlider, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-slider',
+                exportAs: 'luzmoSlider',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />',
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => LuzmoSlider),
+                        multi: true
+                    }
+                ]
+            }]
+    }], () => [], { label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], value: [{
+            type: Input,
+            args: [{ alias: 'value' }]
+        }], min: [{
+            type: Input,
+            args: [{ alias: 'min' }]
+        }], max: [{
+            type: Input,
+            args: [{ alias: 'max' }]
+        }], step: [{
+            type: Input,
+            args: [{ alias: 'step' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled' }]
+        }], debounce: [{
+            type: Input,
+            args: [{ alias: 'debounce' }]
+        }], noUiSlider: [{
+            type: Input,
+            args: [{ alias: 'no-ui-slider' }]
+        }], debounceTimeout: [{
+            type: Input,
+            args: [{ alias: 'debounce-timeout' }]
+        }], changeEvent: [{ type: i0.Output, args: ["change"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoSlider, { className: "LuzmoSlider", filePath: "components/slider.ts", lineNumber: 24 }); })();

package/esm/components/status-light.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/status-light';
+import type { LuzmoStatusLight as LuzmoStatusLightHostElement, StatusLightVariants } from '@luzmo/lucero/status-light';
+import * as i0 from "@angular/core";
+export type { StatusLightNonSemanticVariants, StatusLightSemanticVariants, StatusLightVariants } from '@luzmo/lucero/status-light';
+export declare class LuzmoStatusLight 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(): LuzmoStatusLightHostElement;
+    variant?: StatusLightVariants;
+    disabled?: 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<LuzmoStatusLight, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoStatusLight, "luzmo-status-light", ["luzmoStatusLight"], { "variant": { "alias": "variant"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoStatusLight */
+export type LuzmoStatusLightElement = LuzmoStatusLightHostElement;