@luzmo/ngx-lucero 1.0.1-alpha.78

package/esm/components/help-text.js

@@ -0,0 +1,77 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/text-field';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-help-text>
+ */
+export class LuzmoHelpText {
+    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;
+    }
+    icon;
+    /** The visual variant to apply to this help text. */
+    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 'icon':
+                    this.setHostProperty('icon', changes['icon'].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 LuzmoHelpText_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoHelpText)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoHelpText, selectors: [["luzmo-help-text"]], inputs: { icon: "icon", variant: "variant" }, exportAs: ["luzmoHelpText"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoHelpText_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoHelpText, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-help-text',
+                exportAs: 'luzmoHelpText',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { icon: [{
+            type: Input,
+            args: [{ alias: 'icon' }]
+        }], variant: [{
+            type: Input,
+            args: [{ alias: 'variant' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoHelpText, { className: "LuzmoHelpText", filePath: "components/help-text.ts", lineNumber: 15 }); })();

package/esm/components/icon.d.ts

@@ -0,0 +1,33 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/icon';
+import type { LuzmoIcon as LuzmoIconHostElement } from '@luzmo/lucero/icon';
+import * as i0 from "@angular/core";
+export declare class LuzmoIcon 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(): LuzmoIconHostElement;
+    src?: string;
+    options?: any;
+    icon?: any;
+    block?: boolean;
+    label?: string;
+    size?: 'xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl';
+    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<LuzmoIcon, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoIcon, "luzmo-icon", ["luzmoIcon"], { "src": { "alias": "src"; "required": false; }; "options": { "alias": "options"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "block": { "alias": "block"; "required": false; }; "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoIcon */
+export type LuzmoIconElement = LuzmoIconHostElement;

package/esm/components/icon.js

@@ -0,0 +1,104 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/icon';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-icon>
+ */
+export class LuzmoIcon {
+    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;
+    }
+    src;
+    options;
+    icon;
+    block;
+    label;
+    size;
+    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 'src':
+                    this.setHostProperty('src', changes['src'].currentValue);
+                    break;
+                case 'options':
+                    this.setHostProperty('options', changes['options'].currentValue);
+                    break;
+                case 'icon':
+                    this.setHostProperty('icon', changes['icon'].currentValue);
+                    break;
+                case 'block':
+                    this.setHostProperty('block', changes['block'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].currentValue);
+                    break;
+                case 'size':
+                    this.setHostProperty('size', changes['size'].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 LuzmoIcon_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoIcon)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoIcon, selectors: [["luzmo-icon"]], inputs: { src: "src", options: "options", icon: "icon", block: "block", label: "label", size: "size" }, exportAs: ["luzmoIcon"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoIcon_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoIcon, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-icon',
+                exportAs: 'luzmoIcon',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { src: [{
+            type: Input,
+            args: [{ alias: 'src' }]
+        }], options: [{
+            type: Input,
+            args: [{ alias: 'options' }]
+        }], icon: [{
+            type: Input,
+            args: [{ alias: 'icon' }]
+        }], block: [{
+            type: Input,
+            args: [{ alias: 'block' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], size: [{
+            type: Input,
+            args: [{ alias: 'size' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoIcon, { className: "LuzmoIcon", filePath: "components/icon.ts", lineNumber: 15 }); })();

package/esm/components/infield-button.d.ts

@@ -0,0 +1,35 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/infield-button';
+import type { LuzmoInfieldButton as LuzmoInfieldButtonHostElement } from '@luzmo/lucero/infield-button';
+import * as i0 from "@angular/core";
+export declare class LuzmoInfieldButton 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(): LuzmoInfieldButtonHostElement;
+    /** Whether to style the button as if it is at the start or end of a vertical stack */
+    block?: 'start' | 'end';
+    /** Whether to style the button as if it is at the start or end of a horizontal group */
+    inline?: 'start' | 'end';
+    quiet?: boolean;
+    active?: boolean;
+    /** The default behavior of the button. Possible values are: `button` (default), `submit`, and `reset`. */
+    type?: 'button' | 'submit' | 'reset';
+    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<LuzmoInfieldButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoInfieldButton, "luzmo-infield-button", ["luzmoInfieldButton"], { "block": { "alias": "block"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "quiet": { "alias": "quiet"; "required": false; }; "active": { "alias": "active"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoInfieldButton */
+export type LuzmoInfieldButtonElement = LuzmoInfieldButtonHostElement;

package/esm/components/infield-button.js

@@ -0,0 +1,103 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/infield-button';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-infield-button>
+ *
+ * @slot (default) - text content to be displayed in the Button element
+ * @slot icon - icon element(s) to display at the start of the button
+ */
+export class LuzmoInfieldButton {
+    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 to style the button as if it is at the start or end of a vertical stack */
+    block;
+    /** Whether to style the button as if it is at the start or end of a horizontal group */
+    inline;
+    quiet;
+    active;
+    /** The default behavior of the button. Possible values are: `button` (default), `submit`, and `reset`. */
+    type;
+    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 'block':
+                    this.setHostProperty('block', changes['block'].currentValue);
+                    break;
+                case 'inline':
+                    this.setHostProperty('inline', changes['inline'].currentValue);
+                    break;
+                case 'quiet':
+                    this.setHostProperty('quiet', changes['quiet'].currentValue);
+                    break;
+                case 'active':
+                    this.setHostProperty('active', changes['active'].currentValue);
+                    break;
+                case 'type':
+                    this.setHostProperty('type', changes['type'].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 LuzmoInfieldButton_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoInfieldButton)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoInfieldButton, selectors: [["luzmo-infield-button"]], inputs: { block: "block", inline: "inline", quiet: "quiet", active: "active", type: "type" }, exportAs: ["luzmoInfieldButton"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoInfieldButton_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoInfieldButton, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-infield-button',
+                exportAs: 'luzmoInfieldButton',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { block: [{
+            type: Input,
+            args: [{ alias: 'block' }]
+        }], inline: [{
+            type: Input,
+            args: [{ alias: 'inline' }]
+        }], quiet: [{
+            type: Input,
+            args: [{ alias: 'quiet' }]
+        }], active: [{
+            type: Input,
+            args: [{ alias: 'active' }]
+        }], type: [{
+            type: Input,
+            args: [{ alias: 'type' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoInfieldButton, { className: "LuzmoInfieldButton", filePath: "components/infield-button.ts", lineNumber: 18 }); })();

package/esm/components/label.d.ts

@@ -0,0 +1,29 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/label';
+import type { LuzmoLabel as LuzmoLabelHostElement } from '@luzmo/lucero/label';
+import * as i0 from "@angular/core";
+export declare class LuzmoLabel 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(): LuzmoLabelHostElement;
+    label?: string;
+    tooltip?: 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<LuzmoLabel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoLabel, "luzmo-label", ["luzmoLabel"], { "label": { "alias": "label"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoLabel */
+export type LuzmoLabelElement = LuzmoLabelHostElement;

package/esm/components/label.js

@@ -0,0 +1,76 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/label';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-label>
+ */
+export class LuzmoLabel {
+    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;
+    tooltip;
+    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 'tooltip':
+                    this.setHostProperty('tooltip', changes['tooltip'].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 LuzmoLabel_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoLabel)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoLabel, selectors: [["luzmo-label"]], inputs: { label: "label", tooltip: "tooltip" }, exportAs: ["luzmoLabel"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoLabel_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoLabel, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-label',
+                exportAs: 'luzmoLabel',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], tooltip: [{
+            type: Input,
+            args: [{ alias: 'tooltip' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoLabel, { className: "LuzmoLabel", filePath: "components/label.ts", lineNumber: 15 }); })();

package/esm/components/menu.d.ts

@@ -0,0 +1,53 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import '@luzmo/lucero/menu';
+import type { LuzmoMenu as LuzmoMenuHostElement } from '@luzmo/lucero/menu';
+import * as i0 from "@angular/core";
+export declare class LuzmoMenu 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(): LuzmoMenuHostElement;
+    label?: string;
+    ignore?: boolean;
+    variant?: 'checkmarks' | 'highlight';
+    selects?: never | 'inherit' | 'single' | 'multiple';
+    value?: string;
+    valueSeparator?: string;
+    selected?: string[];
+    selectedItems?: unknown;
+    menuSlot?: unknown;
+    focusedItemIndex?: number;
+    focusInItemIndex?: number;
+    handleSubmenuClosed?: unknown;
+    handleSubmenuOpened?: unknown;
+    /** Announces that the `value` of the element has changed */
+    readonly changeEvent: import("@angular/core").OutputEmitterRef<Event>;
+    readonly closeEvent: import("@angular/core").OutputEmitterRef<Event>;
+    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: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    focus({ preventScroll }: FocusOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoMenu, "luzmo-menu", ["luzmoMenu"], { "label": { "alias": "label"; "required": false; }; "ignore": { "alias": "ignore"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "selects": { "alias": "selects"; "required": false; }; "value": { "alias": "value"; "required": false; }; "valueSeparator": { "alias": "value-separator"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selectedItems": { "alias": "selected-items"; "required": false; }; "menuSlot": { "alias": "menu-slot"; "required": false; }; "focusedItemIndex": { "alias": "focused-item-index"; "required": false; }; "focusInItemIndex": { "alias": "focus-in-item-index"; "required": false; }; "handleSubmenuClosed": { "alias": "handle-submenu-closed"; "required": false; }; "handleSubmenuOpened": { "alias": "handle-submenu-opened"; "required": false; }; }, { "changeEvent": "change"; "closeEvent": "close"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoMenu */
+export type LuzmoMenuElement = LuzmoMenuHostElement;