@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/result-card/result-card.js

@@ -1,83 +1,5 @@
-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 } from 'lit';
-import { property, state } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './result-card.class.js';
+import { LyraResultCard } from './result-card.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { styles } from './result-card.styles.js';
-/**
- * `<lyra-result-card>` — a small bordered card shell for a custom tool-result
- * renderer's body (see `<lyra-tool-result-view>`'s `registerToolRenderer()`
- * in `../tool-result-view/registry.js`). Purely visual, with no state of its
- * own beyond slot-presence tracking: it gives every custom renderer the same
- * "small card" language (border, radius, optional title + header actions)
- * without each one hand-rolling its own box.
- *
- * Pairs with `<lyra-result-field>` for the label/value rows that typically
- * make up the body, though the default slot accepts any content — nothing
- * here requires a `<lyra-result-field>` specifically.
- *
- * @customElement lyra-result-card
- * @slot - The card body — typically one or more `<lyra-result-field>` rows.
- * @slot actions - Small header controls (e.g. a copy button), rendered
- * alongside the title.
- * @csspart base - The outer bordered container.
- * @csspart header - The header row wrapping the title and the `actions`
- * slot. Present in the DOM at all times (so a later `slotchange` on
- * `actions` is still observed) but `hidden` whenever there is no `title`
- * and no `actions` content — an untitled, action-less card has no visible
- * header bar at all.
- * @csspart title - The title text.
- * @csspart actions - The wrapper around the `actions` slot. `hidden`
- * whenever the slot has no assigned content.
- * @csspart body - The wrapper around the default slot.
- */
-export class LyraResultCard extends LyraElement {
-    constructor() {
-        super(...arguments);
-        /** Small heading for the card. Leave unset for an untitled card (e.g. a
-         *  bare block of `<lyra-result-field>` rows with no natural heading). */
-        this.title = '';
-        // See `<lyra-widget>`'s identical `hasActionsSlot` -- a `[part]` wrapper
-        // always contains a literal `<slot>` child regardless of assigned
-        // content, so CSS `:empty` never matches; real emptiness is tracked here
-        // in JS instead and used to both hide the actions wrapper and decide
-        // whether the header row itself has anything to show.
-        this.hasActionsSlot = false;
-        this.onActionsSlotChange = (e) => {
-            this.hasActionsSlot = e.target.assignedElements({ flatten: true }).length > 0;
-        };
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    willUpdate() {
-        if (!this.hasUpdated) {
-            this.hasActionsSlot = Array.from(this.children).some((el) => el.getAttribute('slot') === 'actions');
-        }
-    }
-    render() {
-        const hasTitle = this.title.length > 0;
-        const hasHeader = hasTitle || this.hasActionsSlot;
-        return html `
-      <div part="base">
-        <div part="header" ?hidden=${!hasHeader}>
-          ${hasTitle ? html `<span part="title">${this.title}</span>` : nothing}
-          <div part="actions" ?hidden=${!this.hasActionsSlot}>
-            <slot name="actions" @slotchange=${this.onActionsSlotChange}></slot>
-          </div>
-        </div>
-        <div part="body"><slot></slot></div>
-      </div>
-    `;
-    }
-}
-__decorate([
-    property()
-], LyraResultCard.prototype, "title", void 0);
-__decorate([
-    state()
-], LyraResultCard.prototype, "hasActionsSlot", void 0);
 defineElement('result-card', LyraResultCard);
+//# sourceMappingURL=result-card.js.map

package/dist/components/result-card/result-card.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-card.js","sourceRoot":"","sources":["../../../src/components/result-card/result-card.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,aAAa,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC"}

package/dist/components/result-card/result-card.styles.d.ts

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

package/dist/components/result-card/result-card.styles.d.ts.map

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

package/dist/components/result-card/result-card.styles.js

@@ -6,18 +6,18 @@ export const styles = css `
   [part='base'] {
     display: flex;
     flex-direction: column;
-    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: hidden;
-    font-size: 0.8125rem;
+    font-size: var(--lyra-font-size-sm);
   }
   [part='header'] {
     display: flex;
     align-items: center;
     gap: var(--lyra-space-s);
     padding: var(--lyra-space-xs) var(--lyra-space-s);
-    border-block-end: 1px solid var(--lyra-color-border);
+    border-block-end: var(--lyra-border-width-thin) solid var(--lyra-color-border);
   }
   [part='header'][hidden] {
     display: none;
@@ -26,8 +26,7 @@ export const styles = css `
     flex: 1 1 auto;
     min-inline-size: 0;
     color: var(--lyra-color-text);
-    font-weight: 600;
-    font-size: 0.8125rem;
+    font-weight: var(--lyra-font-weight-semibold);
     overflow: hidden;
     text-overflow: ellipsis;
     white-space: nowrap;
@@ -48,3 +47,4 @@ export const styles = css `
     padding: var(--lyra-space-s);
   }
 `;
+//# sourceMappingURL=result-card.styles.js.map

package/dist/components/result-card/result-card.styles.js.map

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

package/dist/components/result-card/result-field.class.d.ts

@@ -0,0 +1,37 @@
+import { type TemplateResult } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+/**
+ * `<lyra-result-field>` — a single label/value row, meant for use inside a
+ * `<lyra-result-card>` body (though it works standalone too). Renders as a
+ * dense "label: value" line by default — e.g. "Status: 200 OK" or
+ * "Duration: 340ms" — matching the compact, small-card presentation this
+ * pair exists for.
+ *
+ * @customElement lyra-result-field
+ * @slot - Rich value content (e.g. a `<lyra-chip>` status badge, or a plain
+ * text override), taking precedence over the `value` prop whenever it has
+ * any assigned content.
+ * @csspart base - The row container.
+ * @csspart label - The label text (including its trailing colon).
+ * @csspart value - The wrapper around the value — either the slotted
+ * content or the plain `value` prop text.
+ */
+export declare class LyraResultField extends LyraElement {
+    static styles: import("lit").CSSResultGroup[];
+    /** The field name, e.g. "Status". Leave unset to render a value with no label. */
+    label: string;
+    /** Plain-text value, e.g. "200 OK". Ignored once the default slot carries
+     *  real content — see the `@slot` doc. */
+    value: string;
+    private hasValueSlot;
+    protected willUpdate(): void;
+    firstUpdated(): void;
+    private onSlotChange;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-result-field': LyraResultField;
+    }
+}
+//# sourceMappingURL=result-field.class.d.ts.map

package/dist/components/result-card/result-field.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-field.class.d.ts","sourceRoot":"","sources":["../../../src/components/result-card/result-field.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAe7D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,MAAM,CAAC,MAAM,iCAAgC;IAE7C,kFAAkF;IACtE,KAAK,SAAM;IAEvB;8CAC0C;IAC9B,KAAK,SAAM;IAEd,OAAO,CAAC,YAAY,CAAS;IAEtC,SAAS,CAAC,UAAU,IAAI,IAAI,CAI3B;IAED,YAAY,IAAI,IAAI,CAOnB;IAED,OAAO,CAAC,YAAY,CAElB;IAEF,MAAM,IAAI,cAAc,CAUvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,mBAAmB,EAAE,eAAe,CAAC;KACtC;CACF"}

package/dist/components/result-card/result-field.class.js

@@ -0,0 +1,86 @@
+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 } from 'lit';
+import { property, state } from 'lit/decorators.js';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { styles } from './result-field.styles.js';
+// An element always counts as real slot content, even one with no text of
+// its own (e.g. a `<lyra-chip>` status badge whose label comes from an
+// attribute, not slotted text) -- assignedElements()-only checks (as
+// lyra-widget's hasActionsSlot/lyra-source-card's hasFullSlot use) would
+// miss that case. A bare text node only counts once trimmed of whitespace,
+// matching lyra-checkbox's hasLabelSlot. Together this catches both a
+// plain-text value override (`<lyra-result-field label="Status">200 OK`)
+// and a rich slotted badge.
+function hasRealContent(nodes) {
+    return nodes.some((n) => n.nodeType === Node.ELEMENT_NODE || (n.textContent ?? '').trim().length > 0);
+}
+/**
+ * `<lyra-result-field>` — a single label/value row, meant for use inside a
+ * `<lyra-result-card>` body (though it works standalone too). Renders as a
+ * dense "label: value" line by default — e.g. "Status: 200 OK" or
+ * "Duration: 340ms" — matching the compact, small-card presentation this
+ * pair exists for.
+ *
+ * @customElement lyra-result-field
+ * @slot - Rich value content (e.g. a `<lyra-chip>` status badge, or a plain
+ * text override), taking precedence over the `value` prop whenever it has
+ * any assigned content.
+ * @csspart base - The row container.
+ * @csspart label - The label text (including its trailing colon).
+ * @csspart value - The wrapper around the value — either the slotted
+ * content or the plain `value` prop text.
+ */
+export class LyraResultField extends LyraElement {
+    constructor() {
+        super(...arguments);
+        /** The field name, e.g. "Status". Leave unset to render a value with no label. */
+        this.label = '';
+        /** Plain-text value, e.g. "200 OK". Ignored once the default slot carries
+         *  real content — see the `@slot` doc. */
+        this.value = '';
+        this.hasValueSlot = false;
+        this.onSlotChange = (e) => {
+            this.hasValueSlot = hasRealContent(e.target.assignedNodes({ flatten: true }));
+        };
+    }
+    static { this.styles = [LyraElement.styles, styles]; }
+    willUpdate() {
+        if (!this.hasUpdated) {
+            this.hasValueSlot = hasRealContent(Array.from(this.childNodes));
+        }
+    }
+    firstUpdated() {
+        // Fallback reconciliation against the fully-resolved slot assignment,
+        // the same belt-and-suspenders pass lyra-source-card's hasFullSlot and
+        // lyra-empty's hasIcon/hasActions take -- a no-op in the common case
+        // since willUpdate already seeded the correct value above.
+        const slot = this.shadowRoot.querySelector('slot');
+        this.hasValueSlot = hasRealContent(slot.assignedNodes({ flatten: true }));
+    }
+    render() {
+        const hasLabel = this.label.length > 0;
+        return html `
+      <div part="base">
+        ${hasLabel ? html `<span part="label">${this.label}:</span>` : nothing}
+        <span part="value"
+          >${this.hasValueSlot ? nothing : this.value}<slot @slotchange=${this.onSlotChange}></slot
+        ></span>
+      </div>
+    `;
+    }
+}
+__decorate([
+    property()
+], LyraResultField.prototype, "label", void 0);
+__decorate([
+    property()
+], LyraResultField.prototype, "value", void 0);
+__decorate([
+    state()
+], LyraResultField.prototype, "hasValueSlot", void 0);
+//# sourceMappingURL=result-field.class.js.map

package/dist/components/result-card/result-field.class.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-field.class.js","sourceRoot":"","sources":["../../../src/components/result-card/result-field.class.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAuB,MAAM,KAAK,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAElD,0EAA0E;AAC1E,uEAAuE;AACvE,qEAAqE;AACrE,yEAAyE;AACzE,2EAA2E;AAC3E,sEAAsE;AACtE,yEAAyE;AACzE,4BAA4B;AAC5B,SAAS,cAAc,CAAC,KAAa;IACnC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACxG,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAAhD;;QAGE,kFAAkF;QACtE,UAAK,GAAG,EAAE,CAAC;QAEvB;kDAC0C;QAC9B,UAAK,GAAG,EAAE,CAAC;QAEN,iBAAY,GAAG,KAAK,CAAC;QAiB9B,iBAAY,GAAG,CAAC,CAAQ,EAAQ,EAAE;YACxC,IAAI,CAAC,YAAY,GAAG,cAAc,CAAE,CAAC,CAAC,MAA0B,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACrG,CAAC,CAAC;IAaJ,CAAC;aAzCQ,WAAM,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,AAA/B,CAAgC;IAWnC,UAAU;QAClB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QAClE,CAAC;IACH,CAAC;IAED,YAAY;QACV,sEAAsE;QACtE,uEAAuE;QACvE,qEAAqE;QACrE,2DAA2D;QAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,UAAW,CAAC,aAAa,CAAC,MAAM,CAAoB,CAAC;QACvE,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAMD,MAAM;QACJ,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACvC,OAAO,IAAI,CAAA;;UAEL,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAA,sBAAsB,IAAI,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO;;aAEhE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,qBAAqB,IAAI,CAAC,YAAY;;;KAGtF,CAAC;IACJ,CAAC;CACF;AAtCa;IAAX,QAAQ,EAAE;8CAAY;AAIX;IAAX,QAAQ,EAAE;8CAAY;AAEN;IAAhB,KAAK,EAAE;qDAA8B"}

package/dist/components/result-card/result-field.d.ts

@@ -1,36 +1,2 @@
-import { type TemplateResult } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-/**
- * `<lyra-result-field>` — a single label/value row, meant for use inside a
- * `<lyra-result-card>` body (though it works standalone too). Renders as a
- * dense "label: value" line by default — e.g. "Status: 200 OK" or
- * "Duration: 340ms" — matching the compact, small-card presentation this
- * pair exists for.
- *
- * @customElement lyra-result-field
- * @slot - Rich value content (e.g. a `<lyra-chip>` status badge, or a plain
- * text override), taking precedence over the `value` prop whenever it has
- * any assigned content.
- * @csspart base - The row container.
- * @csspart label - The label text (including its trailing colon).
- * @csspart value - The wrapper around the value — either the slotted
- * content or the plain `value` prop text.
- */
-export declare class LyraResultField extends LyraElement {
-    static styles: import("lit").CSSResultGroup[];
-    /** The field name, e.g. "Status". Leave unset to render a value with no label. */
-    label: string;
-    /** Plain-text value, e.g. "200 OK". Ignored once the default slot carries
-     *  real content — see the `@slot` doc. */
-    value: string;
-    private hasValueSlot;
-    protected willUpdate(): void;
-    firstUpdated(): void;
-    private onSlotChange;
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lyra-result-field': LyraResultField;
-    }
-}
+export * from './result-field.class.js';
+//# sourceMappingURL=result-field.d.ts.map

package/dist/components/result-card/result-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-field.d.ts","sourceRoot":"","sources":["../../../src/components/result-card/result-field.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/dist/components/result-card/result-field.js

@@ -1,87 +1,5 @@
-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 } from 'lit';
-import { property, state } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './result-field.class.js';
+import { LyraResultField } from './result-field.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { styles } from './result-field.styles.js';
-// An element always counts as real slot content, even one with no text of
-// its own (e.g. a `<lyra-chip>` status badge whose label comes from an
-// attribute, not slotted text) -- assignedElements()-only checks (as
-// lyra-widget's hasActionsSlot/lyra-source-card's hasFullSlot use) would
-// miss that case. A bare text node only counts once trimmed of whitespace,
-// matching lyra-checkbox's hasLabelSlot. Together this catches both a
-// plain-text value override (`<lyra-result-field label="Status">200 OK`)
-// and a rich slotted badge.
-function hasRealContent(nodes) {
-    return nodes.some((n) => n.nodeType === Node.ELEMENT_NODE || (n.textContent ?? '').trim().length > 0);
-}
-/**
- * `<lyra-result-field>` — a single label/value row, meant for use inside a
- * `<lyra-result-card>` body (though it works standalone too). Renders as a
- * dense "label: value" line by default — e.g. "Status: 200 OK" or
- * "Duration: 340ms" — matching the compact, small-card presentation this
- * pair exists for.
- *
- * @customElement lyra-result-field
- * @slot - Rich value content (e.g. a `<lyra-chip>` status badge, or a plain
- * text override), taking precedence over the `value` prop whenever it has
- * any assigned content.
- * @csspart base - The row container.
- * @csspart label - The label text (including its trailing colon).
- * @csspart value - The wrapper around the value — either the slotted
- * content or the plain `value` prop text.
- */
-export class LyraResultField extends LyraElement {
-    constructor() {
-        super(...arguments);
-        /** The field name, e.g. "Status". Leave unset to render a value with no label. */
-        this.label = '';
-        /** Plain-text value, e.g. "200 OK". Ignored once the default slot carries
-         *  real content — see the `@slot` doc. */
-        this.value = '';
-        this.hasValueSlot = false;
-        this.onSlotChange = (e) => {
-            this.hasValueSlot = hasRealContent(e.target.assignedNodes({ flatten: true }));
-        };
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    willUpdate() {
-        if (!this.hasUpdated) {
-            this.hasValueSlot = hasRealContent(Array.from(this.childNodes));
-        }
-    }
-    firstUpdated() {
-        // Fallback reconciliation against the fully-resolved slot assignment,
-        // the same belt-and-suspenders pass lyra-source-card's hasFullSlot and
-        // lyra-empty's hasIcon/hasActions take -- a no-op in the common case
-        // since willUpdate already seeded the correct value above.
-        const slot = this.shadowRoot.querySelector('slot');
-        this.hasValueSlot = hasRealContent(slot.assignedNodes({ flatten: true }));
-    }
-    render() {
-        const hasLabel = this.label.length > 0;
-        return html `
-      <div part="base">
-        ${hasLabel ? html `<span part="label">${this.label}:</span>` : nothing}
-        <span part="value"
-          >${this.hasValueSlot ? nothing : this.value}<slot @slotchange=${this.onSlotChange}></slot
-        ></span>
-      </div>
-    `;
-    }
-}
-__decorate([
-    property()
-], LyraResultField.prototype, "label", void 0);
-__decorate([
-    property()
-], LyraResultField.prototype, "value", void 0);
-__decorate([
-    state()
-], LyraResultField.prototype, "hasValueSlot", void 0);
 defineElement('result-field', LyraResultField);
+//# sourceMappingURL=result-field.js.map

package/dist/components/result-card/result-field.js.map

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

package/dist/components/result-card/result-field.styles.d.ts

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

package/dist/components/result-card/result-field.styles.d.ts.map

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

package/dist/components/result-card/result-field.styles.js

@@ -13,8 +13,8 @@ export const styles = css `
     align-items: baseline;
     flex-wrap: wrap;
     column-gap: var(--lyra-space-xs);
-    font-size: 0.8125rem;
-    line-height: 1.4;
+    font-size: var(--lyra-font-size-sm);
+    line-height: var(--lyra-line-height-1-4);
   }
   [part='label'] {
     flex: 0 0 auto;
@@ -30,3 +30,4 @@ export const styles = css `
     vertical-align: middle;
   }
 `;
+//# sourceMappingURL=result-field.styles.js.map

package/dist/components/result-card/result-field.styles.js.map

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

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

@@ -0,0 +1,212 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import '../combobox/option.class.js';
+export type LyraSelectSize = 'xs' | 's' | 'm' | 'l' | 'xl';
+/**
+ * `<lyra-select>` — a plain closed-list dropdown: a direct `<lyra-*>`
+ * counterpart to `<wa-select>`/`<wa-option>`. Trigger is a button (not a text
+ * input) -- click/Enter/Space/ArrowDown opens it, there's no typing-to-filter.
+ * A printable keypress instead jumps (or, while closed, directly selects) the
+ * next option whose label starts with what's been typed, like a native
+ * `<select>`'s type-ahead.
+ *
+ * Options are `<lyra-option value>` children, the same element `<lyra-combobox>`
+ * uses. Unlike `lyra-combobox` this is single-select only, with no filter/
+ * source/with-clear/max-options-visible/empty-text/max-render/multiple surface
+ * -- see `<lyra-combobox>` for the filterable/multi-select case.
+ *
+ * Reuses `lyra-combobox`'s popup positioning (`internal/positioner.js`) and
+ * click-outside/Escape/Home/End/Arrow-key listbox navigation patterns,
+ * adapted to a trigger button that keeps DOM focus throughout (the listbox's
+ * "active" row is conveyed via `aria-activedescendant`, never actual focus),
+ * matching the WAI-ARIA "select-only combobox" pattern.
+ *
+ * When `autoCommitSingleOption` is set and exactly one option is enabled
+ * (regardless of how many disabled ones exist alongside it), the popup never
+ * opens at all: a click, Enter, Space, ArrowDown, or ArrowUp on the trigger
+ * commits that sole option directly, and the trigger renders as a plain
+ * `role="button"` with no chevron/`aria-haspopup`/`aria-expanded` rather than
+ * a combobox with a permanently inert popup state — opening a one-row list to
+ * pick the only available choice is pure friction with no real decision
+ * behind it. This never changes `value`/validity defaults on its own — an
+ * unselected single-option select stays unselected (and a `required` one
+ * stays invalid) exactly like the multi-option case, until the trigger is
+ * actually activated. `autoCommitSingleOption` defaults to `false`: by
+ * default a select always renders the normal combobox/listbox/chevron
+ * trigger no matter how many options are enabled, matching pre-1.3.0
+ * behavior — opt in explicitly if a narrowing-to-one option list should
+ * auto-commit.
+ *
+ * @customElement lyra-select
+ * @slot - `<lyra-option>` elements.
+ * @slot label - Custom label content.
+ * @slot hint - Custom hint content.
+ * @slot error - Custom error content.
+ * @event change - The selection changed.
+ * @event input - Fired alongside `change` on every selection change (native
+ *   `<select>` doesn't meaningfully distinguish the two either).
+ * @event lyra-show - The listbox opened.
+ * @event lyra-hide - The listbox closed.
+ * @csspart form-control - The outer wrapper around label, trigger, listbox, error and hint.
+ * @csspart form-control-label - The `<label>` element.
+ * @csspart trigger - The trigger button (positioning anchor).
+ * @csspart listbox - The options popover.
+ * @csspart option - An option row.
+ * @csspart option-dot - An option row's leading status dot (when `dot-color` is set).
+ * @csspart option-label - An option row's label/sub wrapper.
+ * @csspart option-sub - An option row's secondary line (when `sub` is set).
+ * @csspart expand-icon - The dropdown indicator.
+ * @csspart error - The error message.
+ * @csspart hint - The hint message.
+ */
+export interface LyraSelectEventMap {
+    'lyra-show': CustomEvent<undefined>;
+    'lyra-hide': CustomEvent<undefined>;
+    input: CustomEvent<undefined>;
+    change: CustomEvent<undefined>;
+}
+export declare class LyraSelect extends LyraElement<LyraSelectEventMap> {
+    static formAssociated: boolean;
+    static styles: import("lit").CSSResultGroup[];
+    static properties: {
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+        required: {
+            type: BooleanConstructor;
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+        value: {
+            noAccessor: boolean;
+        };
+        name: {
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+    };
+    placeholder: string;
+    label: string;
+    hint: string;
+    errorText: string;
+    open: boolean;
+    /** Visual size — same `xs`–`xl` scale as `lyra-toast-item`'s `size`. */
+    size: LyraSelectSize;
+    /**
+     * Opt-in: when `true` and exactly one `<lyra-option>` is enabled, the
+     * trigger commits that option directly (click/Enter/Space/ArrowDown/
+     * ArrowUp) instead of opening the listbox, and renders as a plain
+     * `role="button"` with no chevron. Defaults to `false`, which always
+     * renders the normal combobox/listbox/chevron trigger regardless of how
+     * many options are enabled — the pre-1.3.0 behavior. See the class doc
+     * above and `onlyOption` below for the full rationale.
+     */
+    autoCommitSingleOption: boolean;
+    private activeIndex;
+    private options;
+    private touched;
+    private hasHintSlot;
+    private hasErrorSlot;
+    private hasLabelSlot;
+    private internals;
+    private validityController;
+    private _fieldsetDisabled;
+    private listId;
+    private triggerId;
+    private cleanup?;
+    private _isFirstUpdate;
+    private _selected;
+    private _disabled;
+    private _required;
+    private _defaultSelected;
+    private _defaultCaptured;
+    private _restoredStateActive;
+    private typeAheadBuffer;
+    private typeAheadTimer?;
+    private _name;
+    constructor();
+    get form(): HTMLFormElement | null;
+    get labels(): NodeList;
+    get validity(): ValidityState;
+    get validationMessage(): string;
+    get willValidate(): boolean;
+    connectedCallback(): void;
+    protected willUpdate(): void;
+    get name(): string;
+    set name(next: string);
+    get disabled(): boolean;
+    set disabled(next: boolean);
+    get required(): boolean;
+    set required(next: boolean);
+    /** The selected value: a single string (empty when nothing is selected). */
+    get value(): string;
+    set value(next: string);
+    private updateValidity;
+    private syncFormValue;
+    /** Effective disabled state: this element's own `disabled` OR an ancestor
+     *  `<fieldset disabled>`'s inherited state -- mirrors native `<input>`, whose
+     *  own `disabled` IDL property/attribute is never mutated by a fieldset. */
+    get effectiveDisabled(): boolean;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: string | File | FormData | null, _mode?: 'restore' | 'autocomplete'): void;
+    /**
+     * Called by the browser when an ancestor `<fieldset disabled>` toggles.
+     * Tracked separately from the consumer's own `disabled` (see
+     * `effectiveDisabled`) so a consumer's explicit `disabled` survives the
+     * fieldset re-enabling instead of being permanently overwritten.
+     */
+    formDisabledCallback(disabled: boolean): void;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    disconnectedCallback(): void;
+    private collectOptions;
+    private reflectSelected;
+    /**
+     * The sole navigable (non-disabled) option, when `autoCommitSingleOption` is set and
+     * there's exactly one. Opening a one-row popup to pick the only available choice is pure
+     * friction with no real decision behind it, so an opted-in single-option select skips the
+     * popup entirely -- see `onTriggerClick`/`onKeyDown`, which commit this option directly on
+     * activation instead of opening the listbox, and `render()`, which drops the popup-trigger
+     * ARIA semantics (`role="combobox"`, `aria-haspopup`, `aria-expanded`, the chevron) in favor
+     * of a plain button's, since no popup can ever appear while this getter returns a value.
+     * Returns `undefined` whenever `autoCommitSingleOption` is `false` (the default), regardless
+     * of option count, so the normal combobox trigger renders unconditionally. Does not affect
+     * `value`/validity defaults in any way -- an unselected single-option select stays unselected
+     * until the trigger is actually activated, exactly like the multi-option case.
+     */
+    private get onlyOption();
+    private onOptionChange;
+    private show;
+    private hide;
+    private onDocPointer;
+    protected updated(changed: PropertyValues): void;
+    private selectOption;
+    private onTriggerClick;
+    private onTriggerBlur;
+    private onHintSlotChange;
+    private onErrorSlotChange;
+    private onLabelSlotChange;
+    /**
+     * Standard listbox type-ahead: moves to the next non-disabled option whose
+     * label starts with the accumulated buffer, cycling from just after the
+     * "current" option (the active row while open, the selected value while
+     * closed). While open this only moves `activeIndex` (a highlight, matching
+     * Arrow-key nav -- Enter/click still commits it); while closed there's no
+     * highlight to show, so it commits immediately, matching a native
+     * `<select>`'s closed-state type-ahead.
+     */
+    private typeAhead;
+    private onKeyDown;
+    private onListboxMouseDown;
+    private onListboxClick;
+    private renderRows;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-select': LyraSelect;
+    }
+}
+//# sourceMappingURL=select.class.d.ts.map