@luzmo/ngx-lucero 1.0.1-alpha.78

package/esm/components/action-menu.js

@@ -0,0 +1,337 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, forwardRef, inject, Input, output, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import '@luzmo/lucero/action-menu';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-action-menu>
+ *
+ * @slot (default) - menu items to be listed in the Action Menu
+ * @slot icon - The icon to use for the Action Menu
+ * @slot label - The label to use for the Action Menu
+ * @slot label-only - The label to use for the Action Menu (no icon space reserved)
+ * @slot tooltip - Tooltip to be applied to the Action Button
+ */
+export class LuzmoActionMenu {
+    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;
+    }
+    selects;
+    staticColor;
+    handleSlottableRequest;
+    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;
+    dependencyManager;
+    isMobile;
+    strategy;
+    pendingStateController;
+    applyFocusElementLabel;
+    changeEvent = output({ alias: 'change' });
+    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 'selects':
+                    this.setHostProperty('selects', changes['selects'].currentValue);
+                    break;
+                case 'staticColor':
+                    this.setHostProperty('staticColor', changes['staticColor'].currentValue);
+                    break;
+                case 'handleSlottableRequest':
+                    this.setHostProperty('handleSlottableRequest', changes['handleSlottableRequest'].currentValue);
+                    break;
+                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 '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 '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, '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 LuzmoActionMenu_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoActionMenu)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoActionMenu, selectors: [["luzmo-action-menu"]], inputs: { selects: "selects", staticColor: [0, "static-color", "staticColor"], handleSlottableRequest: [0, "handle-slottable-request", "handleSlottableRequest"], 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"], dependencyManager: [0, "dependency-manager", "dependencyManager"], isMobile: [0, "is-mobile", "isMobile"], strategy: "strategy", pendingStateController: [0, "pending-state-controller", "pendingStateController"], applyFocusElementLabel: [0, "apply-focus-element-label", "applyFocusElementLabel"] }, outputs: { changeEvent: "change", scrollEvent: "scroll" }, exportAs: ["luzmoActionMenu"], features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(() => LuzmoActionMenu),
+                    multi: true
+                }
+            ]), i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoActionMenu_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoActionMenu, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-action-menu',
+                exportAs: 'luzmoActionMenu',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />',
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => LuzmoActionMenu),
+                        multi: true
+                    }
+                ]
+            }]
+    }], () => [], { selects: [{
+            type: Input,
+            args: [{ alias: 'selects' }]
+        }], staticColor: [{
+            type: Input,
+            args: [{ alias: 'static-color' }]
+        }], handleSlottableRequest: [{
+            type: Input,
+            args: [{ alias: 'handle-slottable-request' }]
+        }], 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' }]
+        }], 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' }]
+        }], applyFocusElementLabel: [{
+            type: Input,
+            args: [{ alias: 'apply-focus-element-label' }]
+        }], changeEvent: [{ type: i0.Output, args: ["change"] }], scrollEvent: [{ type: i0.Output, args: ["scroll"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoActionMenu, { className: "LuzmoActionMenu", filePath: "components/action-menu.ts", lineNumber: 29 }); })();

package/esm/components/avatar.d.ts

@@ -0,0 +1,35 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/avatar';
+import type { LuzmoAvatar as LuzmoAvatarHostElement } from '@luzmo/lucero/avatar';
+import * as i0 from "@angular/core";
+export declare class LuzmoAvatar 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(): LuzmoAvatarHostElement;
+    /** The border style of the avatar image */
+    border?: 'none' | 'light';
+    /** The rounding of the avatar image */
+    rounding?: 'none' | 'full';
+    /** The src of the avatar image. */
+    src?: string;
+    /** When true, marks the avatar image as decorative (sets alt=""). Use when the avatar does not convey meaningful information. */
+    isDecorative?: 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<LuzmoAvatar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoAvatar, "luzmo-avatar", ["luzmoAvatar"], { "border": { "alias": "border"; "required": false; }; "rounding": { "alias": "rounding"; "required": false; }; "src": { "alias": "src"; "required": false; }; "isDecorative": { "alias": "is-decorative"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoAvatar */
+export type LuzmoAvatarElement = LuzmoAvatarHostElement;

package/esm/components/avatar.js

@@ -0,0 +1,94 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/avatar';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-avatar>
+ */
+export class LuzmoAvatar {
+    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 border style of the avatar image */
+    border;
+    /** The rounding of the avatar image */
+    rounding;
+    /** The src of the avatar image. */
+    src;
+    /** When true, marks the avatar image as decorative (sets alt=""). Use when the avatar does not convey meaningful information. */
+    isDecorative;
+    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 'border':
+                    this.setHostProperty('border', changes['border'].currentValue);
+                    break;
+                case 'rounding':
+                    this.setHostProperty('rounding', changes['rounding'].currentValue);
+                    break;
+                case 'src':
+                    this.setHostProperty('src', changes['src'].currentValue);
+                    break;
+                case 'isDecorative':
+                    this.setHostProperty('isDecorative', changes['isDecorative'].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 LuzmoAvatar_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoAvatar)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoAvatar, selectors: [["luzmo-avatar"]], inputs: { border: "border", rounding: "rounding", src: "src", isDecorative: [0, "is-decorative", "isDecorative"] }, exportAs: ["luzmoAvatar"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoAvatar_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoAvatar, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-avatar',
+                exportAs: 'luzmoAvatar',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { border: [{
+            type: Input,
+            args: [{ alias: 'border' }]
+        }], rounding: [{
+            type: Input,
+            args: [{ alias: 'rounding' }]
+        }], src: [{
+            type: Input,
+            args: [{ alias: 'src' }]
+        }], isDecorative: [{
+            type: Input,
+            args: [{ alias: 'is-decorative' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoAvatar, { className: "LuzmoAvatar", filePath: "components/avatar.ts", lineNumber: 15 }); })();

package/esm/components/badge.d.ts

@@ -0,0 +1,31 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/badge';
+import type { LuzmoBadge as LuzmoBadgeHostElement, BadgeFixed, BadgeTreatments, BadgeVariants } from '@luzmo/lucero/badge';
+import * as i0 from "@angular/core";
+export type { BadgeFixed, BadgeNonSemanticVariants, BadgeSemanticVariants, BadgeTreatments, BadgeVariants } from '@luzmo/lucero/badge';
+export declare class LuzmoBadge 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(): LuzmoBadgeHostElement;
+    variant?: BadgeVariants;
+    treatment?: BadgeTreatments;
+    fixed?: BadgeFixed;
+    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<LuzmoBadge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoBadge, "luzmo-badge", ["luzmoBadge"], { "variant": { "alias": "variant"; "required": false; }; "treatment": { "alias": "treatment"; "required": false; }; "fixed": { "alias": "fixed"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoBadge */
+export type LuzmoBadgeElement = LuzmoBadgeHostElement;

package/esm/components/badge.js

@@ -0,0 +1,86 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/badge';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-badge>
+ *
+ * @slot (default) - text label of the Badge
+ * @slot icon - an icon element to display within the Badge
+ */
+export class LuzmoBadge {
+    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;
+    }
+    variant;
+    treatment;
+    fixed;
+    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 'variant':
+                    this.setHostProperty('variant', changes['variant'].currentValue);
+                    break;
+                case 'treatment':
+                    this.setHostProperty('treatment', changes['treatment'].currentValue);
+                    break;
+                case 'fixed':
+                    this.setHostProperty('fixed', changes['fixed'].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 LuzmoBadge_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoBadge)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoBadge, selectors: [["luzmo-badge"]], inputs: { variant: "variant", treatment: "treatment", fixed: "fixed" }, exportAs: ["luzmoBadge"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoBadge_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoBadge, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-badge',
+                exportAs: 'luzmoBadge',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { variant: [{
+            type: Input,
+            args: [{ alias: 'variant' }]
+        }], treatment: [{
+            type: Input,
+            args: [{ alias: 'treatment' }]
+        }], fixed: [{
+            type: Input,
+            args: [{ alias: 'fixed' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoBadge, { className: "LuzmoBadge", filePath: "components/badge.ts", lineNumber: 19 }); })();

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

@@ -0,0 +1,28 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/button-group';
+import type { LuzmoButtonGroup as LuzmoButtonGroupHostElement } from '@luzmo/lucero/button-group';
+import * as i0 from "@angular/core";
+export declare class LuzmoButtonGroup 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(): LuzmoButtonGroupHostElement;
+    vertical?: 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<LuzmoButtonGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoButtonGroup, "luzmo-button-group", ["luzmoButtonGroup"], { "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoButtonGroup */
+export type LuzmoButtonGroupElement = LuzmoButtonGroupHostElement;