@aceshooting/lyra-ui 2.1.0 → 2.2.0

package/dist/components/chat-message/chat-message.js

@@ -1,331 +1,6 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { html, nothing, svg } from 'lit';
-import { property, state, query } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './chat-message.class.js';
+import { LyraChatMessage } from './chat-message.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { nextId } from '../../internal/a11y.js';
-import { chevronIcon } from '../../internal/icons.js';
-import '../live-region/live-region.js';
-import { styles } from './chat-message.styles.js';
-// Mirrors the shared icon set's viewBox/stroke conventions
-// (internal/icons.ts's chevronIcon()/closeIcon()/etc.) without adding a
-// retry glyph to that module -- it's off limits here -- so this one-off icon
-// still reads as part of the same visual language as the rest of the
-// library's inline icons. Same approach lyra-checkbox's own local
-// checkmark/indeterminate glyphs take for the identical reason.
-const ICON_VIEW_BOX = '0 0 24 24';
-const ICON_STROKE_WIDTH = '1.75';
-function retryIcon() {
-    return svg `
-    <svg
-      width="1em"
-      height="1em"
-      viewBox=${ICON_VIEW_BOX}
-      fill="none"
-      stroke="currentColor"
-      stroke-width=${ICON_STROKE_WIDTH}
-      stroke-linecap="round"
-      stroke-linejoin="round"
-      aria-hidden="true"
-      focusable="false"
-    ><polyline points="1 4 1 10 7 10"></polyline><path d="M3.51 15a9 9 0 1 0 2.13-9.36L1 10"></path></svg>
-  `;
-}
-/** `hour:minute` in the runtime's default locale -- the sensible baseline
- *  this library (with no i18n system of its own) can offer without
- *  hardcoding English strings; `formatTimestamp` overrides it. */
-function defaultFormatTimestamp(date) {
-    return new Intl.DateTimeFormat(undefined, { hour: 'numeric', minute: '2-digit' }).format(date);
-}
-/** Visible (not just color-coded) text for every non-resting status --
- *  `'sent'` renders nothing here, it's the resting state. */
-const STATUS_TEXT = {
-    sending: 'Sending…',
-    streaming: 'Responding…',
-    failed: 'Failed to send',
-};
-/**
- * `<lyra-chat-message>` — a role-based message bubble *shell* for a chat/
- * agent conversation surface. It renders none of the message content itself:
- * the default slot carries whatever a consumer wants to display (plain
- * text, a `<lyra-markdown>`, a custom template, anything at all) and this
- * component only supplies the surrounding chrome — alignment/coloring by
- * `role`, an avatar/badges header row, an optional collapse toggle, an
- * attachments strip, and a status-aware footer (a live-updating status dot +
- * text, the formatted `timestamp`, a built-in retry affordance for
- * `status="failed"`, and an `actions` slot for everything else).
- *
- * No built-in copy button is rendered. Deciding what "the copyable text" of
- * an arbitrary slotted message even means (plain text? the rendered
- * markdown source? something else?) is exactly the kind of content
- * interpretation this shell deliberately stays out of — slot a copy control
- * into `actions` instead. Firing `lyra-copy` (`detail: { text }`) from that
- * control keeps the event name consistent with `<lyra-json-viewer>`'s own
- * copy affordance, for anything listening at the conversation-surface level.
- *
- * Accessibility of `status`: the current status is always available as
- * plain visible text (`[part="status-text"]`), never color alone. A
- * transition *to* `"failed"`, or *from* `"streaming"` to `"sent"` (a stream
- * finishing), is additionally announced through an internal
- * `<lyra-live-region>` (see that component's header for the throttled-
- * announcement wiring this composes) so a screen-reader user who isn't
- * currently focused on this message still learns about it. This differs
- * from `<lyra-typing-indicator>`'s deliberately simpler `role="status"`
- * approach — that component only ever has one thing to announce (its own
- * mount); this one has a `status` that can flip between several values
- * across a single element's lifetime, which is exactly the coalescing job
- * `<lyra-live-region>` exists for.
- *
- * `role` is a message-author role (`user`/`assistant`/`system`, matching
- * the vocabulary of every chat/completion API), *not* a WAI-ARIA role, so
- * it reflects to a `data-role` attribute rather than the bare `role`
- * attribute — `role="user"` would collide with `Element`'s own ARIA `role`
- * accessor and is not a valid ARIA role token to begin with.
- *
- * @customElement lyra-chat-message
- * @slot - The message body.
- * @slot avatar - An avatar/icon for the message author.
- * @slot badges - Small status/metric chips (e.g. token count, latency, model name) — entirely app-supplied; this component computes none of that itself.
- * @slot actions - Action controls (e.g. copy, retry), rendered at the end of the footer.
- * @slot attachments - File/image attachment chips, rendered below the message body.
- * @event lyra-retry - Fired by the built-in retry button, only rendered when `status="failed"`.
- * @event lyra-collapse-toggle - `detail: boolean` (the new `collapsed` state) — fired when the user activates the built-in collapse button.
- * @csspart bubble - The message bubble root. Programmatically focusable (`tabindex="-1"`) so focus has a stable place to land when the built-in retry button is removed (e.g. a `lyra-retry` listener flipping `status` away from `"failed"`).
- * @csspart header - The row above the message body — avatar, badges, and the collapse toggle. Hidden entirely when none of those have anything to show.
- * @csspart avatar - The wrapper around the `avatar` slot.
- * @csspart badges - The wrapper around the `badges` slot.
- * @csspart collapse-button - The built-in collapse/expand toggle (only rendered when `collapsible`).
- * @csspart body - The wrapper around the default slot (the message content). Hidden while `collapsed`.
- * @csspart attachments - The wrapper around the `attachments` slot.
- * @csspart footer - The row below the message body — status, timestamp, retry, and actions. Hidden entirely when none of those have anything to show.
- * @csspart status-indicator - A small decorative (`aria-hidden`) dot reflecting `status`; absent while `status="sent"`.
- * @csspart status-text - The visible text twin of `status-indicator` — carries the state in text, not just color.
- * @csspart timestamp - The formatted `timestamp`, rendered in a `<time>` element.
- * @csspart retry-button - The built-in retry button (only rendered when `status="failed"`).
- * @csspart actions - The wrapper around the `actions` slot.
- */
-export class LyraChatMessage extends LyraElement {
-    constructor() {
-        super(...arguments);
-        /** Who authored the message. Reflects to `data-role` — see the class doc. */
-        this.role = 'assistant';
-        /** Shows the built-in collapse/expand toggle in the header. */
-        this.collapsible = false;
-        /** Whether the message body is currently hidden. Effective whenever set,
-         *  independent of `collapsible` — `collapsible` only controls whether the
-         *  built-in toggle button is rendered, mirroring `lyra-widget`'s identical
-         *  `collapsible`/`collapsed` pair. */
-        this.collapsed = false;
-        this.hasAvatarSlot = false;
-        this.hasBadgesSlot = false;
-        this.hasAttachmentsSlot = false;
-        this.hasActionsSlot = false;
-        this.bodyId = nextId('chat-message-body');
-        this._status = 'sent';
-        /** The value `status` held immediately before its current one, recorded
-         *  at the point of assignment in the setter below -- *not* derived from
-         *  Lit's `changed`/`changedProperties`, which only ever remembers the
-         *  single oldest value seen since the last completed update. Without this,
-         *  setting `status` to `"streaming"` and then immediately overwriting it
-         *  (e.g. to `"sent"`) within the same task, with no render in between,
-         *  would silently lose the `"streaming"` intermediate value before
-         *  `announceStatusChange` ever gets to see it. */
-        this.previousStatus = 'sent';
-        /** True only until the component's first completed update -- gates the
-         *  status-change announcement below so a message never announces
-         *  whatever status it happens to mount with (mirrors the same "not on
-         *  first paint" intent `willUpdate`'s `!this.hasUpdated` check has for the
-         *  slot-presence flags, except `this.hasUpdated` itself is already `true`
-         *  by the time `updated()` runs for the first time, so it can't be reused
-         *  here). */
-        this.isMounting = true;
-        this.onAvatarSlotChange = (e) => {
-            this.hasAvatarSlot = e.target.assignedElements({ flatten: true }).length > 0;
-        };
-        this.onBadgesSlotChange = (e) => {
-            this.hasBadgesSlot = e.target.assignedElements({ flatten: true }).length > 0;
-        };
-        this.onAttachmentsSlotChange = (e) => {
-            this.hasAttachmentsSlot = e.target.assignedElements({ flatten: true }).length > 0;
-        };
-        this.onActionsSlotChange = (e) => {
-            this.hasActionsSlot = e.target.assignedElements({ flatten: true }).length > 0;
-        };
-        this.toggleCollapsed = () => {
-            this.collapsed = !this.collapsed;
-            this.emit('lyra-collapse-toggle', this.collapsed);
-        };
-        this.onRetryClick = () => {
-            // A `lyra-retry` listener is documented to respond by flipping `status`
-            // away from `"failed"`, which removes this very button on the next
-            // render. Move focus to the always-rendered bubble first, synchronously,
-            // so it lands somewhere stable inside the message instead of silently
-            // reverting to `<body>` once the button it was on disappears.
-            this.bubbleEl?.focus();
-            this.emit('lyra-retry');
-        };
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    // `status` needs a hand-written accessor (see `previousStatus` below) so
-    // it's declared via `static properties` + `noAccessor` rather than
-    // `@property()` directly -- the same pattern `lyra-playback`'s `playing`
-    // uses for the identical reason (a property whose setter must run real
-    // logic on every assignment, not just on the next completed render).
-    static { this.properties = {
-        status: { reflect: true, noAccessor: true },
-    }; }
-    /** Delivery/generation state. Drives the footer's status dot/text and,
-     *  for `"failed"`, the bubble's danger treatment and the built-in retry
-     *  button. Declared via `static properties` above with a hand-written
-     *  accessor (see `previousStatus`). */
-    get status() {
-        return this._status;
-    }
-    set status(value) {
-        const old = this._status;
-        if (value === old)
-            return;
-        this.previousStatus = old;
-        this._status = value;
-        this.requestUpdate('status', old);
-    }
-    willUpdate() {
-        if (!this.hasUpdated) {
-            this.hasAvatarSlot = this.hasSlotted('avatar');
-            this.hasBadgesSlot = this.hasSlotted('badges');
-            this.hasAttachmentsSlot = this.hasSlotted('attachments');
-            this.hasActionsSlot = this.hasSlotted('actions');
-        }
-    }
-    updated(changed) {
-        const wasMounting = this.isMounting;
-        this.isMounting = false;
-        if (!wasMounting && changed.has('status')) {
-            this.announceStatusChange(this.previousStatus);
-        }
-    }
-    hasSlotted(name) {
-        return Array.from(this.children).some((el) => el.getAttribute('slot') === name);
-    }
-    get normalizedTimestamp() {
-        if (this.timestamp === undefined)
-            return undefined;
-        const date = this.timestamp instanceof Date ? this.timestamp : new Date(this.timestamp);
-        return Number.isNaN(date.getTime()) ? undefined : date;
-    }
-    get statusText() {
-        return this.status === 'sent' ? undefined : STATUS_TEXT[this.status];
-    }
-    announceStatusChange(previous) {
-        if (previous === this.status)
-            return;
-        const region = this.liveRegion;
-        if (!region)
-            return;
-        if (this.status === 'failed') {
-            region.mode = 'assertive';
-            region.announce('Message failed to send.', { force: true });
-        }
-        else if (previous === 'streaming' && this.status === 'sent') {
-            region.mode = 'polite';
-            region.announce('Message complete.', { force: true });
-        }
-    }
-    render() {
-        const ts = this.normalizedTimestamp;
-        const formatter = this.formatTimestamp ?? defaultFormatTimestamp;
-        const statusText = this.statusText;
-        const showHeader = this.hasAvatarSlot || this.hasBadgesSlot || this.collapsible;
-        // `statusText` is already truthy whenever `status === 'failed'`, so it
-        // alone covers that case here too.
-        const showFooter = Boolean(statusText) || Boolean(ts) || this.hasActionsSlot;
-        return html `
-      <div part="bubble" tabindex="-1">
-        <div part="header" ?hidden=${!showHeader}>
-          <span part="avatar" ?hidden=${!this.hasAvatarSlot}
-            ><slot name="avatar" @slotchange=${this.onAvatarSlotChange}></slot
-          ></span>
-          <span part="badges" ?hidden=${!this.hasBadgesSlot}
-            ><slot name="badges" @slotchange=${this.onBadgesSlotChange}></slot
-          ></span>
-          ${this.collapsible
-            ? html `<button
-                part="collapse-button"
-                type="button"
-                aria-expanded=${this.collapsed ? 'false' : 'true'}
-                aria-controls=${this.bodyId}
-                aria-label=${this.collapsed ? 'Expand message' : 'Collapse message'}
-                @click=${this.toggleCollapsed}
-              >
-                <span class="chevron" style=${`transform:rotate(${this.collapsed ? '0deg' : '90deg'})`}
-                  >${chevronIcon()}</span
-                >
-              </button>`
-            : nothing}
-        </div>
-        <div part="body" id=${this.bodyId} ?hidden=${this.collapsed}>
-          <slot></slot>
-        </div>
-        <div part="attachments" ?hidden=${!this.hasAttachmentsSlot}>
-          <slot name="attachments" @slotchange=${this.onAttachmentsSlotChange}></slot>
-        </div>
-        <div part="footer" ?hidden=${!showFooter}>
-          ${statusText
-            ? html `<span part="status-indicator" aria-hidden="true"></span><span part="status-text"
-                  >${statusText}</span
-                >`
-            : nothing}
-          ${ts ? html `<time part="timestamp" datetime=${ts.toISOString()}>${formatter(ts)}</time>` : nothing}
-          ${this.status === 'failed'
-            ? html `<button part="retry-button" type="button" @click=${this.onRetryClick}>
-                ${retryIcon()}<span>Retry</span>
-              </button>`
-            : nothing}
-          <span part="actions" ?hidden=${!this.hasActionsSlot}
-            ><slot name="actions" @slotchange=${this.onActionsSlotChange}></slot
-          ></span>
-        </div>
-        <lyra-live-region></lyra-live-region>
-      </div>
-    `;
-    }
-}
-__decorate([
-    property({ reflect: true, attribute: 'data-role' })
-], LyraChatMessage.prototype, "role", void 0);
-__decorate([
-    property({ attribute: false })
-], LyraChatMessage.prototype, "timestamp", void 0);
-__decorate([
-    property({ attribute: false })
-], LyraChatMessage.prototype, "formatTimestamp", void 0);
-__decorate([
-    property({ type: Boolean, reflect: true })
-], LyraChatMessage.prototype, "collapsible", void 0);
-__decorate([
-    property({ type: Boolean, reflect: true })
-], LyraChatMessage.prototype, "collapsed", void 0);
-__decorate([
-    state()
-], LyraChatMessage.prototype, "hasAvatarSlot", void 0);
-__decorate([
-    state()
-], LyraChatMessage.prototype, "hasBadgesSlot", void 0);
-__decorate([
-    state()
-], LyraChatMessage.prototype, "hasAttachmentsSlot", void 0);
-__decorate([
-    state()
-], LyraChatMessage.prototype, "hasActionsSlot", void 0);
-__decorate([
-    query('lyra-live-region')
-], LyraChatMessage.prototype, "liveRegion", void 0);
-__decorate([
-    query('[part="bubble"]')
-], LyraChatMessage.prototype, "bubbleEl", void 0);
+import "../live-region/live-region.js";
 defineElement('chat-message', LyraChatMessage);
+//# sourceMappingURL=chat-message.js.map

package/dist/components/chat-message/chat-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-message.js","sourceRoot":"","sources":["../../../src/components/chat-message/chat-message.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,+BAA+B,CAAC;AACvC,aAAa,CAAC,cAAc,EAAE,eAAe,CAAC,CAAC"}

package/dist/components/chat-message/chat-message.styles.d.ts

@@ -1 +1,2 @@
 export declare const styles: import("lit").CSSResult;
+//# sourceMappingURL=chat-message.styles.d.ts.map

package/dist/components/chat-message/chat-message.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-message.styles.d.ts","sourceRoot":"","sources":["../../../src/components/chat-message/chat-message.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,yBAyMlB,CAAC"}

package/dist/components/chat-message/chat-message.styles.js

@@ -6,8 +6,8 @@ export const styles = css `
        width" token exists to resolve through, same rationale as
        --lyra-json-viewer-max-height in json-viewer.styles.ts. */
     --lyra-chat-message-max-width: 80%;
-    font-size: 0.875rem;
-    line-height: 1.5;
+    font-size: var(--lyra-font-size-md-sm);
+    line-height: var(--lyra-line-height-normal);
   }
   [part='bubble'] {
     display: flex;
@@ -15,7 +15,7 @@ export const styles = css `
     gap: var(--lyra-space-xs);
     max-inline-size: var(--lyra-chat-message-max-width);
     padding: var(--lyra-space-m);
-    border: 1px solid var(--lyra-color-border);
+    border: var(--lyra-border-width-thin) solid var(--lyra-color-border);
     border-radius: var(--lyra-radius);
     background: var(--lyra-color-surface);
     overflow-wrap: anywhere;
@@ -116,7 +116,7 @@ export const styles = css `
     display: flex;
     align-items: center;
     gap: var(--lyra-space-xs);
-    font-size: 0.75rem;
+    font-size: var(--lyra-font-size-xs);
     color: var(--lyra-color-text-quiet);
   }
   [part='actions'] {
@@ -140,8 +140,8 @@ export const styles = css `
 
   [part='status-indicator'] {
     flex: 0 0 auto;
-    inline-size: 0.5rem;
-    block-size: 0.5rem;
+    inline-size: var(--lyra-size-0-5rem);
+    block-size: var(--lyra-size-0-5rem);
     border-radius: 50%;
     background: var(--lyra-color-text-quiet);
   }
@@ -157,7 +157,7 @@ export const styles = css `
   }
   :host([status='failed']) [part='status-text'] {
     color: var(--lyra-color-danger);
-    font-weight: 600;
+    font-weight: var(--lyra-font-weight-semibold);
   }
   @keyframes lyra-chat-message-pulse {
     0%,
@@ -174,21 +174,21 @@ export const styles = css `
     display: inline-flex;
     align-items: center;
     gap: var(--lyra-space-xs);
-    padding: 0.125rem var(--lyra-space-xs);
-    border: 1px solid var(--lyra-color-danger);
+    padding: var(--lyra-size-0-125rem) var(--lyra-space-xs);
+    border: var(--lyra-border-width-thin) solid var(--lyra-color-danger);
     border-radius: var(--lyra-radius);
     background: transparent;
     color: var(--lyra-color-danger);
     font: inherit;
-    font-size: 0.75rem;
+    font-size: var(--lyra-font-size-xs);
     cursor: pointer;
   }
   [part='retry-button']:hover {
     background: var(--lyra-color-danger-quiet);
   }
   [part='retry-button'] svg {
-    inline-size: 0.875em;
-    block-size: 0.875em;
+    inline-size: var(--lyra-size-0-875em);
+    block-size: var(--lyra-size-0-875em);
   }
 
   @media (prefers-reduced-motion: reduce) {
@@ -201,3 +201,4 @@ export const styles = css `
     }
   }
 `;
+//# sourceMappingURL=chat-message.styles.js.map

package/dist/components/chat-message/chat-message.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-message.styles.js","sourceRoot":"","sources":["../../../src/components/chat-message/chat-message.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyMxB,CAAC"}

package/dist/components/checkbox/checkbox.class.d.ts

@@ -0,0 +1,123 @@
+import { type TemplateResult } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+/**
+ * `<lyra-checkbox>` — a boolean form control. Structurally the same idea as
+ * `<lyra-switch>` (form-associated via `ElementInternals`, click and
+ * Space/Enter both toggle) but with checkbox semantics: `role="checkbox"` +
+ * an `aria-checked` that can also be `"mixed"`, and a visual box/checkmark
+ * instead of a track/thumb.
+ *
+ * `checked` is not a plain string, so this attaches `ElementInternals`
+ * directly and implements its own `updateValidity()` rather than using the
+ * `FormAssociated` mixin — see `<lyra-combobox>` for the same
+ * direct-`ElementInternals` shape with a non-string value.
+ *
+ * @customElement lyra-checkbox
+ * @slot - Label text, rendered next to the box. Clicking it toggles the
+ * checkbox, the same as clicking a native checkbox's associated `<label>`.
+ * If left empty, set `aria-label` on the host so the control still has an
+ * accessible name.
+ * @event lyra-change - The user toggled the checkbox (click or Space/Enter).
+ * `detail: { checked }`. Not fired for a programmatic `.checked` assignment.
+ * @csspart base - The whole interactive control (`role="checkbox"`); wraps the box and label.
+ * @csspart box - The small square that shows the checkmark/indeterminate dash.
+ * @csspart checkmark - The checkmark (or indeterminate dash) glyph inside the box.
+ * @csspart label - The wrapper around the default slot.
+ */
+export interface LyraCheckboxEventMap {
+    'lyra-change': CustomEvent<{
+        checked: boolean;
+    }>;
+}
+export declare class LyraCheckbox extends LyraElement<LyraCheckboxEventMap> {
+    static styles: import("lit").CSSResultGroup[];
+    static formAssociated: boolean;
+    static properties: {
+        checked: {
+            type: BooleanConstructor;
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+        indeterminate: {
+            type: BooleanConstructor;
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+        name: {
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+        required: {
+            type: BooleanConstructor;
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+        value: {
+            noAccessor: boolean;
+        };
+    };
+    private hasLabelSlot;
+    private touched;
+    private internals;
+    private validityController;
+    private labelObserver?;
+    private _defaultChecked;
+    private _defaultCaptured;
+    private _fieldsetDisabled;
+    private _name;
+    private _checked;
+    private _indeterminate;
+    private _disabled;
+    private _required;
+    private _value;
+    /** Whether the control is disabled explicitly or by an ancestor fieldset. */
+    get effectiveDisabled(): boolean;
+    get checked(): boolean;
+    set checked(next: boolean);
+    get indeterminate(): boolean;
+    set indeterminate(next: boolean);
+    get disabled(): boolean;
+    set disabled(next: boolean);
+    /** The form submission key, reflected synchronously for native form APIs. */
+    get name(): string;
+    set name(next: string);
+    get required(): boolean;
+    set required(next: boolean);
+    get value(): string;
+    set value(next: string);
+    constructor();
+    get form(): HTMLFormElement | null;
+    get labels(): NodeList;
+    get validity(): ValidityState;
+    get validationMessage(): string;
+    get willValidate(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected willUpdate(): void;
+    private updateValidity;
+    private reflectInvalid;
+    private syncFormState;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: string | File | FormData | null, _mode?: 'restore' | 'autocomplete'): void;
+    formDisabledCallback(disabled: boolean): void;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    private toggle;
+    private onClick;
+    private onKeyDown;
+    private onSlotChange;
+    private recomputeHasLabelSlot;
+    private onBlur;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-checkbox': LyraCheckbox;
+    }
+}
+//# sourceMappingURL=checkbox.class.d.ts.map

package/dist/components/checkbox/checkbox.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox.class.d.ts","sourceRoot":"","sources":["../../../src/components/checkbox/checkbox.class.ts"],"names":[],"mappings":"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"}