@lmvz-ds/components 0.24.0 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @lmvz-ds/components
 
+## 0.26.0
+
+### Minor Changes
+
+- 80f5b7d: Snackbar Komponente und Controller hinzugefügt.
+
+### Patch Changes
+
+- 1c0f1e5: Design Tokens aktualisiert
+- 72c4ec5: Design Tokens aktualisiert
+
+## 0.25.0
+
+### Minor Changes
+
+- 5780fd2: Add `lmvz-radio` — accessible, form-associated radio button component with FACE support, full ARIA model, forced-colors, and Angular value accessor binding
+
+### Patch Changes
+
+- 64bffb7: Design Tokens aktualisiert
+- 1dcb478: Design Tokens aktualisiert
+
 ## 0.24.0
 
 ## 0.23.0

package/cjs/{ds.constants-DSnxZ3ia.js → ds.constants-8fh6ItAF.js}

@@ -4,7 +4,7 @@ const sizes = ['xs', 'sm', 'md', 'lg'];
 const textSizes = [...sizes, 'xl'];
 const inputTypes = ['text', 'email', 'password', 'tel', 'url', 'search', 'number'];
 const iconSizes = [...sizes, 'inherit'];
-const iconWeights = ['thin', 'medium', 'bold', 'filled'];
+const iconWeights = ['thin', 'medium', 'bold'];
 const chipTypes = ['active', 'warning', 'success', 'error', 'neutral'];
 const chipSizes = ['default', 'small'];
 

package/cjs/{index-lW-SEvL7.js → index-BCFBLj0e.js}

@@ -4,7 +4,7 @@ const NAMESPACE = 'lmvz-components';
 const BUILD = /* lmvz-components */ { hotModuleReplacement: false, hydratedSelectorName: "hydrated", lazyLoad: true, propChangeCallback: true, slotRelocation: true, state: true, updatable: true};
 
 /*
- Stencil Client Platform v4.43.4 | MIT Licensed | https://stenciljs.com
+ Stencil Client Platform v4.43.5 | MIT Licensed | https://stenciljs.com
  */
 
 var Build = {

package/cjs/index.cjs.js

@@ -1,12 +1,205 @@
 'use strict';
 
 var ariaLoader = require('./aria-loader-BRo2FTGh.js');
-var ds_constants = require('./ds.constants-DSnxZ3ia.js');
+var ds_constants = require('./ds.constants-8fh6ItAF.js');
 var icons = require('./icons-BQASWgk-.js');
 require('./svg-BMBduILB.js');
 require('./logger-DsM6xg6V.js');
 
-
+const PRIORITY_MAP = {
+    low: 0,
+    normal: 1,
+    high: 2,
+};
+const STATUS_DURATION = {
+    success: 5000,
+    warning: 5000,
+    error: 8000,
+};
+let idCounter = 0;
+function nextId() {
+    idCounter += 1;
+    return `snackbar-${idCounter}`;
+}
+function resolveHostElement() {
+    if (typeof document === 'undefined') {
+        return undefined;
+    }
+    const existing = document.querySelector('[data-snackbar-host]');
+    if (existing) {
+        return existing;
+    }
+    const el = document.createElement('lmvz-snackbar');
+    el.setAttribute('data-snackbar-host', '');
+    document.body.appendChild(el);
+    return el;
+}
+class SnackbarController {
+    hostEl = undefined;
+    active = undefined;
+    getHost() {
+        if (this.hostEl !== undefined && !this.hostEl.isConnected) {
+            this.hostEl = undefined;
+        }
+        if (this.hostEl === undefined) {
+            this.hostEl = resolveHostElement();
+        }
+        return this.hostEl;
+    }
+    clearTimer(entry) {
+        if (entry.timerId !== undefined) {
+            clearTimeout(entry.timerId);
+            entry.timerId = undefined;
+        }
+    }
+    scheduleTimer(entry, delayMs) {
+        if (delayMs <= 0) {
+            return;
+        }
+        entry.timerStartedAt = Date.now();
+        entry.timerId = setTimeout(() => {
+            if (this.active !== undefined && this.active.id === entry.id) {
+                this.dismissActive(entry, 'timeout');
+            }
+        }, delayMs);
+    }
+    dismissActive(entry, reason) {
+        this.clearTimer(entry);
+        const host = entry.hostEl;
+        host.removeEventListener('pointerenter', entry.onPointerEnter);
+        host.removeEventListener('pointerleave', entry.onPointerLeave);
+        host.removeEventListener('focusin', entry.onFocusIn);
+        host.removeEventListener('focusout', entry.onFocusOut);
+        if (entry.onActionListener) {
+            host.removeEventListener('lmvzAction', entry.onActionListener);
+        }
+        host.hide?.();
+        if (this.active?.id === entry.id) {
+            this.active = undefined;
+        }
+        if (reason !== 'action') {
+            host.dispatchEvent(new CustomEvent('lmvzClose', { detail: { reason }, bubbles: true, composed: true }));
+        }
+        entry.resolve({ reason });
+    }
+    pauseTimer(entry) {
+        entry.pauseCount += 1;
+        if (entry.pauseCount > 1 || entry.timerId === undefined) {
+            return;
+        }
+        const elapsed = entry.timerStartedAt !== undefined ? Date.now() - entry.timerStartedAt : 0;
+        entry.remaining = Math.max(0, entry.remaining - elapsed);
+        entry.timerStartedAt = undefined;
+        this.clearTimer(entry);
+    }
+    resumeTimer(entry) {
+        if (entry.pauseCount > 0) {
+            entry.pauseCount -= 1;
+        }
+        if (entry.pauseCount > 0) {
+            return;
+        }
+        if (entry.remaining > 0) {
+            this.scheduleTimer(entry, entry.remaining);
+        }
+    }
+    applyToHost(host, options) {
+        host.setAttribute('status', options.status ?? 'success');
+        if (options.actionLabel !== undefined) {
+            host.setAttribute('action-label', options.actionLabel);
+        }
+        else {
+            host.removeAttribute('action-label');
+        }
+    }
+    open(options) {
+        const incomingPriority = PRIORITY_MAP[options.priority ?? 'normal'];
+        if (this.active !== undefined && incomingPriority < this.active.priority) {
+            let swallowResolve;
+            const closed = new Promise((resolve) => {
+                swallowResolve = resolve;
+            });
+            swallowResolve({ reason: 'swallowed' });
+            const id = nextId();
+            return {
+                id,
+                closed,
+                dismiss() {
+                },
+            };
+        }
+        if (this.active !== undefined) {
+            this.dismissActive(this.active, 'overridden');
+        }
+        const host = this.getHost();
+        if (host === undefined) {
+            const id = nextId();
+            let ssrResolve;
+            const closed = new Promise((resolve) => {
+                ssrResolve = resolve;
+            });
+            ssrResolve({ reason: 'swallowed' });
+            return { id, closed, dismiss() { } };
+        }
+        const id = nextId();
+        const status = options.status ?? 'success';
+        const durationMs = options.duration === 0 ? 0 : (options.duration ?? STATUS_DURATION[status]);
+        let entryResolve;
+        const closed = new Promise((resolve) => {
+            entryResolve = resolve;
+        });
+        const entry = {
+            id,
+            priority: incomingPriority,
+            resolve: entryResolve,
+            timerId: undefined,
+            remaining: durationMs,
+            timerStartedAt: undefined,
+            pauseCount: 0,
+            hostEl: host,
+            onPointerEnter: () => this.pauseTimer(entry),
+            onPointerLeave: () => this.resumeTimer(entry),
+            onFocusIn: () => this.pauseTimer(entry),
+            onFocusOut: () => this.resumeTimer(entry),
+        };
+        this.active = entry;
+        host.addEventListener('pointerenter', entry.onPointerEnter);
+        host.addEventListener('pointerleave', entry.onPointerLeave);
+        host.addEventListener('focusin', entry.onFocusIn);
+        host.addEventListener('focusout', entry.onFocusOut);
+        this.applyToHost(host, options);
+        const onAction = () => {
+            if (this.active !== undefined && this.active.id === id) {
+                options.onAction?.();
+                this.dismissActive(entry, 'action');
+            }
+        };
+        entry.onActionListener = onAction;
+        host.addEventListener('lmvzAction', onAction, { once: true });
+        host.show?.();
+        queueMicrotask(() => host.setAttribute('message', options.message));
+        if (durationMs > 0) {
+            this.scheduleTimer(entry, durationMs);
+        }
+        return {
+            id,
+            closed,
+            dismiss: () => {
+                if (this.active?.id === id) {
+                    this.dismissActive(entry, 'manual');
+                }
+            },
+        };
+    }
+    dismiss(id) {
+        if (!this.active) {
+            return;
+        }
+        if (!id || this.active.id === id) {
+            this.dismissActive(this.active, 'manual');
+        }
+    }
+}
 
 exports.ARIA_VALIDATION_RUNTIME_CHANGED_EVENT = ariaLoader.ARIA_VALIDATION_RUNTIME_CHANGED_EVENT;
 exports.disableAriaValidation = ariaLoader.disableAriaValidation;
@@ -23,3 +216,4 @@ exports.textSizes = ds_constants.textSizes;
 exports.getRegisteredIconProvider = icons.getRegisteredIconProvider;
 exports.registerIconProvider = icons.registerIconProvider;
 exports.typedIconFromSet = icons.typedIconFromSet;
+exports.SnackbarController = SnackbarController;

package/cjs/lmvz-action.cjs.entry.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-lW-SEvL7.js');
+var index = require('./index-BCFBLj0e.js');
 
 const lmvzActionCss = () => `:host{display:block}`;
 

package/cjs/lmvz-button-group.cjs.entry.js

@@ -0,0 +1,183 @@
+'use strict';
+
+var index = require('./index-BCFBLj0e.js');
+var ariaLoader = require('./aria-loader-BRo2FTGh.js');
+var component = require('./component-C7cavwmZ.js');
+
+/**
+ * Returns a function that delegates to the given predicate/filter and negates its result.
+ * The returned function preserves the input function's types, arguments and timing.
+ *
+ * @param delegate - The predicate/filter function to negate.
+ * @returns A function that returns the negated result.
+ */
+function negate(delegate) {
+    return (...args) => {
+        const result = delegate(...args);
+        return ariaLoader.isPromise(result) ? result.then((res) => !res) : !result;
+    };
+}
+
+const lmvzButtonGroupCss = () => `:host{display:flex;justify-content:flex-end;gap:var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));font:var(--lmvz-typography-body-md, 400 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5     Router);flex-wrap:wrap}::slotted([hidden]){display:none !important}`;
+
+const LmvzButtonGroup = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+    }
+    actionsSlot;
+    validationMessageCache = [];
+    actionsStateObserver;
+    get primaryEnabledAction() {
+        return this.enabledButtons.find(isPrimaryAction) ?? this.enabledButtons[0];
+    }
+    get hasActions() {
+        return this.assignedButtons.some((element) => isVisible(element) && isActionButton(element) && !isDisabledButton(element));
+    }
+    componentDidLoad() {
+        this.handleActionsSlotChange();
+    }
+    disconnectedCallback() {
+        this.actionsStateObserver?.disconnect();
+    }
+    get assignedElements() {
+        return this.actionsSlot?.assignedElements({ flatten: true }) ?? [];
+    }
+    get assignedButtons() {
+        return this.assignedElements.filter(isActionButton);
+    }
+    get visibleButtons() {
+        return this.assignedButtons.filter(isVisible);
+    }
+    get enabledButtons() {
+        return this.visibleButtons.filter(negate(isDisabledButton));
+    }
+    getActionValidationResult() {
+        if (!this.visibleButtons.length) {
+            return [];
+        }
+        const primaryActions = this.visibleButtons.filter(isPrimaryAction);
+        const secondaryActions = this.visibleButtons.filter(isSecondaryAction);
+        const issues = [];
+        const order = this.visibleButtons.toReversed();
+        if (primaryActions.length !== 1)
+            issues.push('LmvzModal actions slot must contain exactly one primary action.');
+        if (secondaryActions.length > 1)
+            issues.push(`LmvzModal actions slot must contain at most one secondary action (received ${secondaryActions.length})`);
+        if (primaryActions.length) {
+            const primaryAction = primaryActions[0];
+            const secondaryAction = secondaryActions[0];
+            if (order.indexOf(primaryAction) !== 0)
+                issues.push('Primary action must be the last focusable element in the actions slot (i.e. rightmost button).');
+            if (secondaryAction && order.indexOf(secondaryAction) !== 1)
+                issues.push('Secondary action must be the second-to-last focusable element in the actions slot (i.e. left of primary button).');
+        }
+        else if (secondaryActions.length) {
+            const secondaryAction = secondaryActions[0];
+            if (order.indexOf(secondaryAction) !== 0)
+                issues.push('Secondary action must be the last focusable element in the actions slot when no primary action is present (i.e. rightmost button).');
+        }
+        return issues;
+    }
+    handleActionsSlotChange = () => {
+        this.observeActionState();
+        this.syncActionsState();
+    };
+    observeActionState() {
+        if (typeof MutationObserver === 'undefined')
+            return;
+        this.actionsStateObserver?.disconnect();
+        if (!this.assignedButtons.length)
+            return;
+        this.actionsStateObserver = new MutationObserver(() => {
+            this.syncActionsState();
+        });
+        this.assignedButtons.forEach((element) => {
+            this.actionsStateObserver?.observe(element, {
+                attributes: true,
+                attributeFilter: ['disabled', 'hidden', 'variant'],
+            });
+        });
+    }
+    syncActionsState() {
+        const assignedElements = this.assignedElements;
+        assignedElements.forEach((element) => {
+            const isAllowedAction = ['LMVZ-BUTTON', 'BUTTON'].includes(element.tagName.toUpperCase());
+            if (isAllowedAction)
+                return;
+            if (!element.hasAttribute('hidden')) {
+                element.setAttribute('hidden', '');
+            }
+            if (element.getAttribute('aria-hidden') !== 'true') {
+                element.setAttribute('aria-hidden', 'true');
+            }
+        });
+        this.checkActions();
+        const length = this.visibleButtons.length;
+        for (let i = 0; i < length; i++) {
+            const variant = i === length - 1 ? 'primary' : i === length - 2 ? 'secondary' : 'tertiary';
+            const element = this.visibleButtons.at(i);
+            if (!element)
+                continue;
+            if (isLmvzButton(element)) {
+                if (!element.getAttribute('variant'))
+                    element.setAttribute('variant', variant);
+            }
+            else {
+                element.classList.add(variant);
+            }
+        }
+        this.focusPrimaryAction();
+    }
+    focusPrimaryAction() {
+        const focusTarget = this.primaryEnabledAction;
+        if (!focusTarget || typeof window === 'undefined')
+            return;
+        window.requestAnimationFrame(() => {
+            if (component.canReceiveFocus(focusTarget)) {
+                focusTarget.focus();
+            }
+        });
+    }
+    checkActions() {
+        if (!ariaLoader.isAriaValidationEnabled())
+            return;
+        const issues = this.getActionValidationResult();
+        if (!issues.length) {
+            return;
+        }
+        issues.forEach((issue) => {
+            if (this.validationMessageCache.includes(issue))
+                return;
+            console.warn(issue);
+            this.validationMessageCache.push(issue);
+        });
+    }
+    render() {
+        return (index.h(index.Host, { key: '56b60821ecaa2301d13e78d621e873aa74cd170e' }, index.h("slot", { key: 'e6a1422950fa5b0026356b7788a607a690116186', ref: (element) => (this.actionsSlot = element), onSlotchange: this.handleActionsSlotChange })));
+    }
+};
+function isActionButton(element) {
+    return ['LMVZ-BUTTON', 'BUTTON'].includes(element.tagName.toUpperCase());
+}
+function isLmvzButton(element) {
+    return element?.tagName.toUpperCase() === 'LMVZ-BUTTON';
+}
+function isDisabledButton(element) {
+    return element.hasAttribute('disabled') || element.disabled === true;
+}
+function isVisible(element) {
+    return !element.hasAttribute('hidden');
+}
+function getActionVariant(element) {
+    const variant = element.getAttribute('variant') ?? element.variant;
+    return variant === 'primary' || variant === 'secondary' || variant === 'tertiary' ? variant : 'secondary';
+}
+function isPrimaryAction(element) {
+    return getActionVariant(element) === 'primary';
+}
+function isSecondaryAction(element) {
+    return getActionVariant(element) === 'secondary';
+}
+LmvzButtonGroup.style = lmvzButtonGroupCss();
+
+exports.lmvz_button_group = LmvzButtonGroup;

package/cjs/lmvz-button_2.cjs.entry.js

@@ -0,0 +1,198 @@
+'use strict';
+
+var index = require('./index-BCFBLj0e.js');
+var index$1 = require('./index-Bp6Dd2i1.js');
+var reactiveControllerHost = require('./reactive-controller-host-DrtMkMd7.js');
+var elementActivationController = require('./element-activation-controller-DC_6T0Rt.js');
+var component = require('./component-C7cavwmZ.js');
+var svg = require('./svg-BMBduILB.js');
+var icons = require('./icons-BQASWgk-.js');
+require('./aria-loader-BRo2FTGh.js');
+require('./logger-DsM6xg6V.js');
+
+const lmvzButtonCss = () => ` @layer lmvz-ds.reset, lmvz-ds.theme, lmvz-ds.components, lmvz-ds.overrides;  @layer lmvz-ds.theme {   @font-face {   font-family: Router;   src:     local('RouterBook-Regular'),     local('Router-Book'),     url('/assets/fonts/Router-Book.woff') format('woff');   font-weight: 400; }  @font-face {   font-family: Router;   src:     local('RouterMedium-Regular'),     local('Router-Medium'),     url('/assets/fonts/Router-Medium.woff') format('woff');   font-weight: 500; }  @font-face {   font-family: Router;   src:     local('RouterBold-Regular'),     local('Router-Bold'),     url('/assets/fonts/Router-Bold.woff') format('woff');   font-weight: 700; }  } @layer lmvz-ds.reset { body {   margin: 0; }  h1, h2, h3, h4, h5, h6 {   margin: 0; }  *[hidden] {   display: none !important; }  } :host {         button {      --lmvz-button-color: var(--lmvz-component-color, var(--lmvz-semantic-color-int-on-secondary, #000000));   --lmvz-button-padding-inline: var(--lmvz-button-padding, var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem)));   --lmvz-button-padding-block: var(--lmvz-button-padding, var(--lmvz-component-input-padding-md, clamp(0.88rem, 0.84rem + 0.13vw, 1rem)));   --lmvz-button-gap: var(--lmvz-component-input-gap-md, clamp(0.5rem, 0.44rem + 0.26vw, 0.75rem));   --lmvz-button-min-height: var(--lmvz-component-input-size-md, clamp(2.5rem, 2.44rem + 0.26vw, 2.75rem));   --lmvz-button-font: var(--lmvz-typography-body-md-strong, 500 clamp(0.88rem, 0.84rem + 0.13vw, 1rem) / 1.5     Router);   --lmvz-button-radius: var(--lmvz-component-input-radius-default, 999px);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent;   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary, #f0f0f0);    display: inline-flex;   align-items: center;   justify-content: center;   gap: var(--lmvz-button-gap);   padding-block: var(--lmvz-button-padding-block);   padding-inline: var(--lmvz-button-padding-inline);   min-height: var(--lmvz-button-min-height);   border-radius: var(--lmvz-button-radius);   border: var(--lmvz-button-border-width) solid var(--lmvz-button-border-color);   background-color: var(--lmvz-button-background);   color: var(--lmvz-button-color);   cursor: pointer;   font: var(--lmvz-button-font);   text-align: center;   text-decoration: none;   white-space: nowrap;   transition:     background-color 0.15s ease,     color 0.15s ease,     border-color 0.15s ease,     box-shadow 0.15s ease; }  button > * {   font: inherit;   color: inherit; }  button:focus-visible {   outline: var(--lmvz-ds-outline, 1px solid #0e7ab4);   outline-offset: var(--lmvz-ds-outline-offset, clamp(0.25rem, 0.19rem + 0.26vw, 0.5rem)); }  button:is([disabled], .disabled) {   cursor: not-allowed;   pointer-events: none;                   opacity: var(--lmvz-component-input-disabled-opacity, 40%); }  button:not([disabled]):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0); }  button:not([disabled]):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-active, #d4d4d4); }  button.primary {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary, #000000);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-primary, #ffffff);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent; }  button.primary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-hover, #2e2e2e); }  button.primary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-primary-active, #545454); }  button.secondary {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary, #f0f0f0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary, #000000);   --lmvz-button-border-width: 0;   --lmvz-button-border-color: transparent; }  button.secondary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-hover, #e0e0e0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary-hover, #000000); }  button.secondary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-secondary-active, #d4d4d4);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-secondary-active, #000000); }  button.tertiary {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary, #ffffff);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary, #000000); }  button.tertiary:not([disabled], .disabled):hover {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-hover, #f0f0f0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary-hover, #000000); }  button.tertiary:not([disabled], .disabled):active {   --lmvz-button-background: var(--lmvz-semantic-color-int-tertiary-active, #e0e0e0);   --lmvz-button-color: var(--lmvz-semantic-color-int-on-tertiary-active, #000000); }  button.small {   --lmvz-button-padding-inline: var(--lmvz-component-input-padding-sm, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   --lmvz-button-padding-block: var(--lmvz-component-input-padding-sm, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem));   --lmvz-button-gap: var(--lmvz-component-input-gap-sm, clamp(0.38rem, 0.31rem + 0.26vw, 0.63rem));   --lmvz-button-min-height: var(--lmvz-component-input-size-sm, clamp(2rem, 1.94rem + 0.26vw, 2.25rem));   --lmvz-button-font: var(--lmvz-typography-body-sm-strong, 500 clamp(0.69rem, 0.67rem + 0.06vw, 0.75rem) / 1.5     Router); }  button.large {   --lmvz-button-padding-inline: var(--lmvz-component-input-padding-lg, clamp(1rem, 0.94rem + 0.26vw, 1.25rem));   --lmvz-button-padding-block: var(--lmvz-component-input-padding-lg, clamp(1rem, 0.94rem + 0.26vw, 1.25rem));   --lmvz-button-gap: var(--lmvz-component-input-gap-lg, clamp(0.75rem, 0.69rem + 0.26vw, 1rem));   --lmvz-button-min-height: var(--lmvz-component-input-size-lg, clamp(2.75rem, 2.69rem + 0.26vw, 3rem));   --lmvz-button-font: var(--lmvz-typography-body-lg-strong, 500 clamp(1rem, 0.97rem + 0.13vw, 1.13rem) / 1.5     Router); }     display: inline-block; } ::slotted(*) {   --lmvz-component-color: var(--lmvz-button-color); } `;
+
+const LmvzButton = class extends reactiveControllerHost.ReactiveControllerHost {
+    get el() { return index.getElement(this); }
+    validationEl;
+    inheritedAttributes = {};
+    formEl = null;
+    formButtonEl = null;
+    lmvzActivation;
+    get ti() {
+        return 0;
+    }
+    scale = 'default';
+    variant;
+    disabled = false;
+    type = 'button';
+    form;
+    formMethod;
+    name;
+    value;
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.lmvzActivation = index.createEvent(this, "lmvzActivation", 7);
+        this.addController(new reactiveControllerHost.AriaValidationController(this));
+        this.addController(new elementActivationController.ElementActivationController(this, {
+            localHandler: this.handleClick.bind(this),
+            keys: ['Enter'],
+        }));
+    }
+    connectedCallback() {
+        this.inheritedAttributes = component.inheritAriaAttributes(this.el);
+        super.connectedCallback();
+    }
+    disconnectedCallback() {
+        this.formButtonEl?.remove();
+        this.formButtonEl = null;
+        this.formEl = null;
+        super.disconnectedCallback();
+    }
+    renderHiddenButton() {
+        if (this.type !== 'submit') {
+            this.formButtonEl?.remove();
+            this.formButtonEl = null;
+            this.formEl = null;
+            return;
+        }
+        const formEl = component.findFormByRef(this.form, this.el);
+        if (!formEl) {
+            this.formButtonEl?.remove();
+            this.formButtonEl = null;
+            this.formEl = null;
+            return;
+        }
+        this.formEl = formEl;
+        const formButtonEl = this.formButtonEl ?? document.createElement('button');
+        formButtonEl.type = 'submit';
+        formButtonEl.style.display = 'none';
+        formButtonEl.disabled = this.disabled;
+        formButtonEl.name = this.name ?? '';
+        formButtonEl.value = this.value ?? '';
+        if (this.formMethod) {
+            formButtonEl.setAttribute('formmethod', this.formMethod);
+        }
+        else {
+            formButtonEl.removeAttribute('formmethod');
+        }
+        if (this.formButtonEl !== formButtonEl) {
+            this.formButtonEl = formButtonEl;
+        }
+        if (formButtonEl.parentElement !== formEl) {
+            formButtonEl.remove();
+            formEl.appendChild(formButtonEl);
+        }
+    }
+    submitForm(ev) {
+        if (this.formEl && this.formButtonEl) {
+            ev.preventDefault();
+            this.formButtonEl.click();
+        }
+    }
+    handleClick = (ev) => {
+        if (this.type === 'submit') {
+            this.submitForm(ev);
+        }
+    };
+    render() {
+        this.renderHiddenButton();
+        return (index.h(index.Host, { key: '8196de85afc3878c6f38e582d7c031f5d19bcd36', "aria-disabled": this.disabled ? 'true' : null }, index.h("button", { key: '8d73f979fa227de22a03403a2a3938684911060a', ref: (e) => (this.validationEl = e), part: "button", disabled: this.disabled, type: this.type, class: index$1.classNames(this.variant ?? 'secondary', { [this.scale ?? '']: !!this.scale, disabled: this.disabled }), ...this.inheritedAttributes }, index.h("slot", { key: '18e91a2f94ba0d7e5cf13150191003e2f0b2a03a' }))));
+    }
+    static get delegatesFocus() { return true; }
+};
+LmvzButton.style = lmvzButtonCss();
+
+const lmvzIconCss = () => `.sc-lmvz-icon-h{--lmvz-icon-color:var(--lmvz-component-color, var(--lmvz-semantic-color-on-surface-input-primary, #000000));--lmvz-icon-size:var(--lmvz-component-size, var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem)));display:inline-block;line-height:0;svg{display:block;height:var(--lmvz-icon-size);width:auto}svg path{stroke:var(--lmvz-icon-color);fill:none}}[size='xs'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-xs, clamp(0.75rem, 0.72rem + 0.13vw, 0.88rem))}}[size='sm'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-sm, clamp(0.88rem, 0.84rem + 0.13vw, 1rem))}}[size='md'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-md, clamp(1rem, 0.94rem + 0.26vw, 1.25rem))}}[size='lg'].sc-lmvz-icon-h{svg{--lmvz-icon-size:var(--lmvz-component-icon-size-lg, clamp(1.5rem, 1.44rem + 0.26vw, 1.75rem))}}[size='inherit'].sc-lmvz-icon-h{svg{height:var(--lmvz-component-size, inherit)}}[weight='light'].sc-lmvz-icon-h{svg path{stroke-width:1}}[weight='medium'].sc-lmvz-icon-h{svg path{stroke-width:1.5}}[weight='bold'].sc-lmvz-icon-h{svg path{stroke-width:2}}[weight='filled'].sc-lmvz-icon-h{svg path{stroke-width:2;fill:var(--lmvz-icon-color)}}`;
+
+const LmvzIcon = class extends reactiveControllerHost.ReactiveControllerHost {
+    intersectionObserver;
+    ariaValidationController = new reactiveControllerHost.AriaValidationController(this);
+    get el() { return index.getElement(this); }
+    validationEl;
+    icon;
+    weight = 'medium';
+    size = 'md';
+    iconset;
+    iconData;
+    visible = false;
+    ariaLabel;
+    get ariaHidden() {
+        return !this.ariaLabel;
+    }
+    constructor(hostRef) {
+        super();
+        index.registerInstance(this, hostRef);
+        this.addController(this.ariaValidationController);
+    }
+    connectedCallback() {
+        this.waitUntilVisible(() => {
+            this.visible = true;
+            this.loadIconPathData();
+        });
+        super.connectedCallback();
+    }
+    disconnectedCallback() {
+        if (this.intersectionObserver && typeof this.intersectionObserver.disconnect === 'function') {
+            this.intersectionObserver.disconnect();
+        }
+        this.intersectionObserver = undefined;
+        super.disconnectedCallback();
+    }
+    async loadIconPathData() {
+        const { icon, iconset, visible } = this;
+        if (!icon || !visible) {
+            return;
+        }
+        const maybeIcon = svg.parseSvgString(icon);
+        if (maybeIcon) {
+            this.iconData = maybeIcon;
+            return;
+        }
+        this.iconData = await icons.resolveIconSvg({
+            icon,
+            iconset,
+        });
+    }
+    componentDidRender() {
+        this.validationEl = this.el.querySelector('svg');
+        this.ariaValidationController.revalidateAria();
+        super.componentDidRender();
+    }
+    render() {
+        return index.h(index.Host, { key: '03b4391d02a77409257bcda51c2b65ad9a9e0a0c', role: "img", "aria-hidden": `${this.ariaHidden}`, innerHTML: this.iconData });
+    }
+    waitUntilVisible(callback, rootMargin = 50) {
+        if (typeof window === 'undefined' || !window.IntersectionObserver) {
+            callback();
+            return;
+        }
+        this.intersectionObserver = new IntersectionObserver((entries) => {
+            entries.some((entry) => {
+                if (entry.isIntersecting) {
+                    if (this.intersectionObserver && typeof this.intersectionObserver.disconnect === 'function') {
+                        this.intersectionObserver.disconnect();
+                    }
+                    this.intersectionObserver = undefined;
+                    callback();
+                    return true;
+                }
+                return false;
+            });
+        }, { rootMargin: `${rootMargin}px` });
+        this.intersectionObserver.observe(this.el);
+    }
+    static get watchers() { return {
+        "icon": [{
+                "loadIconPathData": 0
+            }],
+        "iconset": [{
+                "loadIconPathData": 0
+            }]
+    }; }
+};
+LmvzIcon.style = lmvzIconCss();
+
+exports.lmvz_button = LmvzButton;
+exports.lmvz_icon = LmvzIcon;