@luzmo/ngx-lucero 1.0.1-alpha.78

package/esm/components/picker.js

@@ -0,0 +1,340 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, forwardRef, inject, Input, output, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import '@luzmo/lucero/picker';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-picker>
+ *
+ * @slot label - The placeholder content for the Picker
+ * @slot description - The description content for the Picker
+ * @slot tooltip - Tooltip to to be applied to the the Picker Button
+ * @slot (default) - menu items to be listed in the Picker
+ */
+export class LuzmoPicker {
+    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;
+    }
+    appliedLabel;
+    button;
+    /** Whether the Picker is disabled. */
+    disabled;
+    focused;
+    icons;
+    /** Type of dropdown */
+    variant;
+    /** Whether the value is invalid. */
+    invalid;
+    /** Whether the items are currently loading. */
+    pending;
+    /** Defines a string value that labels the Picker while it is in pending state. */
+    pendingLabel;
+    label;
+    open;
+    /** Readonly value */
+    readonly;
+    labelAlignment;
+    optionsMenu;
+    overlayElement;
+    placement;
+    /** Display as a quiet picker */
+    quiet;
+    value;
+    selectedItem;
+    selects;
+    dependencyManager;
+    isMobile;
+    strategy;
+    pendingStateController;
+    handleSlottableRequest;
+    applyFocusElementLabel;
+    /** Announces that the `value` of the element has changed */
+    changeEvent = output({ alias: 'change' });
+    /** Announces that the overlay has been opened */
+    luzmoOpenedEvent = output({ alias: 'luzmo-opened' });
+    /** Announces that the overlay has been closed */
+    luzmoClosedEvent = output({ alias: 'luzmo-closed' });
+    scrollEvent = output({ alias: 'scroll' });
+    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 'appliedLabel':
+                    this.setHostProperty('appliedLabel', changes['appliedLabel'].currentValue);
+                    break;
+                case 'button':
+                    this.setHostProperty('button', changes['button'].currentValue);
+                    break;
+                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 'invalid':
+                    this.setHostProperty('invalid', changes['invalid'].currentValue);
+                    break;
+                case 'pending':
+                    this.setHostProperty('pending', changes['pending'].currentValue);
+                    break;
+                case 'pendingLabel':
+                    this.setHostProperty('pendingLabel', changes['pendingLabel'].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 'optionsMenu':
+                    this.setHostProperty('optionsMenu', changes['optionsMenu'].currentValue);
+                    break;
+                case 'overlayElement':
+                    this.setHostProperty('overlayElement', changes['overlayElement'].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 'selectedItem':
+                    this.setHostProperty('selectedItem', changes['selectedItem'].currentValue);
+                    break;
+                case 'selects':
+                    this.setHostProperty('selects', changes['selects'].currentValue);
+                    break;
+                case 'dependencyManager':
+                    this.setHostProperty('dependencyManager', changes['dependencyManager'].currentValue);
+                    break;
+                case 'isMobile':
+                    this.setHostProperty('isMobile', changes['isMobile'].currentValue);
+                    break;
+                case 'strategy':
+                    this.setHostProperty('strategy', changes['strategy'].currentValue);
+                    break;
+                case 'pendingStateController':
+                    this.setHostProperty('pendingStateController', changes['pendingStateController'].currentValue);
+                    break;
+                case 'handleSlottableRequest':
+                    this.setHostProperty('handleSlottableRequest', changes['handleSlottableRequest'].currentValue);
+                    break;
+                case 'applyFocusElementLabel':
+                    this.setHostProperty('applyFocusElementLabel', changes['applyFocusElementLabel'].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-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, 'scroll', (event) => {
+            this.scrollEvent.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 LuzmoPicker_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoPicker)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoPicker, selectors: [["luzmo-picker"]], inputs: { appliedLabel: [0, "applied-label", "appliedLabel"], button: "button", disabled: "disabled", focused: "focused", icons: "icons", variant: "variant", invalid: "invalid", pending: "pending", pendingLabel: [0, "pending-label", "pendingLabel"], label: "label", open: "open", readonly: "readonly", labelAlignment: [0, "label-alignment", "labelAlignment"], optionsMenu: [0, "options-menu", "optionsMenu"], overlayElement: [0, "overlay-element", "overlayElement"], placement: "placement", quiet: "quiet", value: "value", selectedItem: [0, "selected-item", "selectedItem"], selects: "selects", dependencyManager: [0, "dependency-manager", "dependencyManager"], isMobile: [0, "is-mobile", "isMobile"], strategy: "strategy", pendingStateController: [0, "pending-state-controller", "pendingStateController"], handleSlottableRequest: [0, "handle-slottable-request", "handleSlottableRequest"], applyFocusElementLabel: [0, "apply-focus-element-label", "applyFocusElementLabel"] }, outputs: { changeEvent: "change", luzmoOpenedEvent: "luzmo-opened", luzmoClosedEvent: "luzmo-closed", scrollEvent: "scroll" }, exportAs: ["luzmoPicker"], features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(() => LuzmoPicker),
+                    multi: true
+                }
+            ]), i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoPicker_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoPicker, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-picker',
+                exportAs: 'luzmoPicker',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />',
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => LuzmoPicker),
+                        multi: true
+                    }
+                ]
+            }]
+    }], () => [], { appliedLabel: [{
+            type: Input,
+            args: [{ alias: 'applied-label' }]
+        }], button: [{
+            type: Input,
+            args: [{ alias: 'button' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled' }]
+        }], focused: [{
+            type: Input,
+            args: [{ alias: 'focused' }]
+        }], icons: [{
+            type: Input,
+            args: [{ alias: 'icons' }]
+        }], variant: [{
+            type: Input,
+            args: [{ alias: 'variant' }]
+        }], invalid: [{
+            type: Input,
+            args: [{ alias: 'invalid' }]
+        }], pending: [{
+            type: Input,
+            args: [{ alias: 'pending' }]
+        }], pendingLabel: [{
+            type: Input,
+            args: [{ alias: 'pending-label' }]
+        }], 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' }]
+        }], optionsMenu: [{
+            type: Input,
+            args: [{ alias: 'options-menu' }]
+        }], overlayElement: [{
+            type: Input,
+            args: [{ alias: 'overlay-element' }]
+        }], placement: [{
+            type: Input,
+            args: [{ alias: 'placement' }]
+        }], quiet: [{
+            type: Input,
+            args: [{ alias: 'quiet' }]
+        }], value: [{
+            type: Input,
+            args: [{ alias: 'value' }]
+        }], selectedItem: [{
+            type: Input,
+            args: [{ alias: 'selected-item' }]
+        }], selects: [{
+            type: Input,
+            args: [{ alias: 'selects' }]
+        }], dependencyManager: [{
+            type: Input,
+            args: [{ alias: 'dependency-manager' }]
+        }], isMobile: [{
+            type: Input,
+            args: [{ alias: 'is-mobile' }]
+        }], strategy: [{
+            type: Input,
+            args: [{ alias: 'strategy' }]
+        }], pendingStateController: [{
+            type: Input,
+            args: [{ alias: 'pending-state-controller' }]
+        }], handleSlottableRequest: [{
+            type: Input,
+            args: [{ alias: 'handle-slottable-request' }]
+        }], applyFocusElementLabel: [{
+            type: Input,
+            args: [{ alias: 'apply-focus-element-label' }]
+        }], changeEvent: [{ type: i0.Output, args: ["change"] }], luzmoOpenedEvent: [{ type: i0.Output, args: ["luzmo-opened"] }], luzmoClosedEvent: [{ type: i0.Output, args: ["luzmo-closed"] }], scrollEvent: [{ type: i0.Output, args: ["scroll"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoPicker, { className: "LuzmoPicker", filePath: "components/picker.ts", lineNumber: 28 }); })();

package/esm/components/popover.d.ts

@@ -0,0 +1,33 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/popover';
+import type { LuzmoPopover as LuzmoPopoverHostElement } from '@luzmo/lucero/popover';
+import type { Placement as __extt_Placement } from '@floating-ui/dom';
+import * as i0 from "@angular/core";
+export declare class LuzmoPopover 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(): LuzmoPopoverHostElement;
+    /** Whether the popover is visible or not. */
+    open?: boolean;
+    placement?: __extt_Placement;
+    tip?: boolean;
+    tipElement?: 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<LuzmoPopover, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoPopover, "luzmo-popover", ["luzmoPopover"], { "open": { "alias": "open"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "tip": { "alias": "tip"; "required": false; }; "tipElement": { "alias": "tip-element"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoPopover */
+export type LuzmoPopoverElement = LuzmoPopoverHostElement;

package/esm/components/popover.js

@@ -0,0 +1,93 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/popover';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-popover>
+ *
+ * @slot (default) - content to display within the Luzmo Popover
+ */
+export class LuzmoPopover {
+    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;
+    }
+    /** Whether the popover is visible or not. */
+    open;
+    placement;
+    tip;
+    tipElement;
+    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 'open':
+                    this.setHostProperty('open', changes['open'].currentValue);
+                    break;
+                case 'placement':
+                    this.setHostProperty('placement', changes['placement'].currentValue);
+                    break;
+                case 'tip':
+                    this.setHostProperty('tip', changes['tip'].currentValue);
+                    break;
+                case 'tipElement':
+                    this.setHostProperty('tipElement', changes['tipElement'].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 LuzmoPopover_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoPopover)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoPopover, selectors: [["luzmo-popover"]], inputs: { open: "open", placement: "placement", tip: "tip", tipElement: [0, "tip-element", "tipElement"] }, exportAs: ["luzmoPopover"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoPopover_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoPopover, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-popover',
+                exportAs: 'luzmoPopover',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { open: [{
+            type: Input,
+            args: [{ alias: 'open' }]
+        }], placement: [{
+            type: Input,
+            args: [{ alias: 'placement' }]
+        }], tip: [{
+            type: Input,
+            args: [{ alias: 'tip' }]
+        }], tipElement: [{
+            type: Input,
+            args: [{ alias: 'tip-element' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoPopover, { className: "LuzmoPopover", filePath: "components/popover.ts", lineNumber: 18 }); })();

package/esm/components/progress-bar.d.ts

@@ -0,0 +1,35 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/progress-bar';
+import type { LuzmoProgressBar as LuzmoProgressBarHostElement } from '@luzmo/lucero/progress-bar';
+import * as i0 from "@angular/core";
+export declare class LuzmoProgressBar 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(): LuzmoProgressBarHostElement;
+    indeterminate?: boolean;
+    label?: string;
+    progress?: number;
+    staticColor?: 'white' | 'black';
+    sideLabel?: boolean;
+    hideValue?: boolean;
+    valueLabel?: string;
+    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<LuzmoProgressBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoProgressBar, "luzmo-progress-bar", ["luzmoProgressBar"], { "indeterminate": { "alias": "indeterminate"; "required": false; }; "label": { "alias": "label"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "staticColor": { "alias": "static-color"; "required": false; }; "sideLabel": { "alias": "side-label"; "required": false; }; "hideValue": { "alias": "hide-value"; "required": false; }; "valueLabel": { "alias": "value-label"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoProgressBar */
+export type LuzmoProgressBarElement = LuzmoProgressBarHostElement;

package/esm/components/progress-bar.js

@@ -0,0 +1,121 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/progress-bar';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-progress-bar>
+ *
+ * @slot (default) - the label of the progress bar
+ * @slot value - custom value content displayed instead of the default percentage
+ */
+export class LuzmoProgressBar {
+    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;
+    }
+    indeterminate;
+    label;
+    progress;
+    staticColor;
+    sideLabel;
+    hideValue;
+    valueLabel;
+    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 'indeterminate':
+                    this.setHostProperty('indeterminate', changes['indeterminate'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].currentValue);
+                    break;
+                case 'progress':
+                    this.setHostProperty('progress', changes['progress'].currentValue);
+                    break;
+                case 'staticColor':
+                    this.setHostProperty('staticColor', changes['staticColor'].currentValue);
+                    break;
+                case 'sideLabel':
+                    this.setHostProperty('sideLabel', changes['sideLabel'].currentValue);
+                    break;
+                case 'hideValue':
+                    this.setHostProperty('hideValue', changes['hideValue'].currentValue);
+                    break;
+                case 'valueLabel':
+                    this.setHostProperty('valueLabel', changes['valueLabel'].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 LuzmoProgressBar_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoProgressBar)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoProgressBar, selectors: [["luzmo-progress-bar"]], inputs: { indeterminate: "indeterminate", label: "label", progress: "progress", staticColor: [0, "static-color", "staticColor"], sideLabel: [0, "side-label", "sideLabel"], hideValue: [0, "hide-value", "hideValue"], valueLabel: [0, "value-label", "valueLabel"], variant: "variant" }, exportAs: ["luzmoProgressBar"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoProgressBar_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoProgressBar, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-progress-bar',
+                exportAs: 'luzmoProgressBar',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { indeterminate: [{
+            type: Input,
+            args: [{ alias: 'indeterminate' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], progress: [{
+            type: Input,
+            args: [{ alias: 'progress' }]
+        }], staticColor: [{
+            type: Input,
+            args: [{ alias: 'static-color' }]
+        }], sideLabel: [{
+            type: Input,
+            args: [{ alias: 'side-label' }]
+        }], hideValue: [{
+            type: Input,
+            args: [{ alias: 'hide-value' }]
+        }], valueLabel: [{
+            type: Input,
+            args: [{ alias: 'value-label' }]
+        }], variant: [{
+            type: Input,
+            args: [{ alias: 'variant' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoProgressBar, { className: "LuzmoProgressBar", filePath: "components/progress-bar.ts", lineNumber: 18 }); })();

package/esm/components/progress-circle.d.ts

@@ -0,0 +1,35 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/progress-circle';
+import type { LuzmoProgressCircle as LuzmoProgressCircleHostElement } from '@luzmo/lucero/progress-circle';
+import * as i0 from "@angular/core";
+export declare class LuzmoProgressCircle 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(): LuzmoProgressCircleHostElement;
+    /** The `indeterminate` attribute is used to indicate that the progress circle is in an indeterminate state */
+    indeterminate?: boolean;
+    /** The aria-label of the progress circle */
+    label?: string;
+    /** The `static-color` attribute is used to set the color of the progress circle to black or white. This is used when the progress circle is on a colored background. */
+    staticColor?: 'white' | 'black';
+    /** The progress in degrees of the progress circle */
+    progress?: number;
+    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<LuzmoProgressCircle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoProgressCircle, "luzmo-progress-circle", ["luzmoProgressCircle"], { "indeterminate": { "alias": "indeterminate"; "required": false; }; "label": { "alias": "label"; "required": false; }; "staticColor": { "alias": "static-color"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoProgressCircle */
+export type LuzmoProgressCircleElement = LuzmoProgressCircleHostElement;