@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/slider/slider.js

@@ -1,352 +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 } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
-import { FormAssociated } from '../../internal/form-associated.js';
+export * from './slider.class.js';
+import { LyraSlider } from './slider.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { isRtl } from '../../internal/rtl.js';
-import { styles } from './slider.styles.js';
-/** PageUp/PageDown move by a larger increment than a single Arrow step,
- *  matching the WAI-ARIA APG slider pattern's expected keyboard interactions
- *  (and native `<input type=range>`). Mirrors lyra-time-range's identical
- *  constant. */
-const PAGE_STEP_MULTIPLIER = 10;
-function isArrowKey(key) {
-    return key === 'ArrowRight' || key === 'ArrowUp' || key === 'ArrowLeft' || key === 'ArrowDown';
-}
-/** Keys that onKeyDown acts on and onKeyUp commits after. */
-function isSliderKey(key) {
-    return isArrowKey(key) || key === 'Home' || key === 'End' || key === 'PageUp' || key === 'PageDown';
-}
-/** Number of decimal digits in `n`'s shortest string representation, e.g.
- *  `0.1` -> 1, `5` -> 0. Used to round a stepped value back to the precision
- *  `step` itself implies, instead of leaving binary floating-point noise in
- *  place (e.g. `20.200000000000003`). Mirrors lyra-time-range's identical
- *  helper. */
-function decimalPlaces(n) {
-    const str = n.toString();
-    const dot = str.indexOf('.');
-    return dot === -1 ? 0 : str.length - dot - 1;
-}
-/**
- * `<lyra-slider>` — a numeric range control (e.g. an LLM "temperature"
- * setting), form-associated. Mirrors native `<input type="range">`
- * semantics: `value` is the string form-submitted via `FormAssociated`,
- * `valueAsNumber` is the ergonomic numeric accessor (mirroring the native
- * `<input type=range>` IDL attribute of the same name) kept in sync with it
- * in both directions — reads parse `value`, writes stringify back to it.
- *
- * Unlike the mixin's other consumers, an unset `value` is eagerly defaulted
- * — on connect, and again after `form.reset()` — to the midpoint of
- * `[min, max]` snapped to `step`, the same "range sanitization algorithm"
- * default a native range input applies. A slider always represents *some*
- * number, so `required` (inherited from `FormAssociated`) only has a window
- * to block submission before that default lands, matching how `required`
- * isn't a meaningful constraint on a native range input either.
- *
- * @customElement lyra-slider
- * @event lyra-input - Fired continuously during an active drag or a
- *   keyboard step (including OS key-repeat while a key is held), mirroring
- *   native `<input type=range>`'s own `input` event. `detail: { value: number }`.
- * @event lyra-change - Fired once an interaction commits: on pointerup for a
- *   drag, or on keyup for a keyboard step — so a single Arrow/Home/End/
- *   PageUp/PageDown press fires both `lyra-input` and `lyra-change`,
- *   mirroring how native `<input type=range>` fires `change` on every
- *   committed step too. `detail: { value: number }`.
- * @csspart base - The row wrapping the track and the optional value readout.
- * @csspart track - The full-width background line.
- * @csspart fill - The filled portion of the track from `min` up to the current value.
- * @csspart thumb - The draggable handle (`role="slider"`).
- * @csspart value - The visible numeric readout, rendered when `show-value` is true.
- */
-export class LyraSlider extends FormAssociated(LyraElement) {
-    constructor() {
-        super(...arguments);
-        this.min = 0;
-        this.max = 100;
-        this.step = 1;
-        /** Accessible name for the slider, used when no visible label context
-         *  exists around it (e.g. no wrapping `<label>` or adjacent heading). Set
-         *  as `aria-label` on the interactive `role="slider"` element. A plain
-         *  `aria-label` attribute on the host itself is honored as a fallback when
-         *  this is left unset, matching `<lyra-checkbox>`/`<lyra-switch>`. */
-        this.label = '';
-        /** Whether to render the current numeric value as visible text next to
-         *  the track. Like `<lyra-markdown>`'s `sanitize`/`gfm`, this is a plain
-         *  `type: Boolean` property defaulting `true` — turn it off via the
-         *  `.showValue=${false}` property binding (a bare `show-value="false"`
-         *  content attribute is still truthy, since presence is all Lit's default
-         *  boolean converter checks). */
-        this.showValue = true;
-        // Keyed by pointerId (a Set, not a single scalar) purely for
-        // multi-touch/robustness parity with lyra-split and lyra-time-range, even
-        // though a single thumb has no per-pointer state of its own to track.
-        this.activePointers = new Set();
-        this.onKeyDown = (e) => {
-            if (this.effectiveDisabled)
-                return;
-            const current = this.valueAsNumber;
-            // Under RTL, physical ArrowRight moves toward inset-inline-start, i.e. a
-            // lower value — swap which physical key counts as "forward", matching
-            // lyra-split/lyra-time-range's onKeyDown/onPointerMove convention.
-            // ArrowUp/ArrowDown are never swapped (direction only affects the
-            // horizontal inline axis).
-            const rtl = isRtl(this);
-            const forwardKey = rtl ? 'ArrowLeft' : 'ArrowRight';
-            const backwardKey = rtl ? 'ArrowRight' : 'ArrowLeft';
-            if (e.key === forwardKey || e.key === 'ArrowUp') {
-                e.preventDefault();
-                this.setValue(current + this.step, false);
-            }
-            else if (e.key === backwardKey || e.key === 'ArrowDown') {
-                e.preventDefault();
-                this.setValue(current - this.step, false);
-            }
-            else if (e.key === 'PageUp') {
-                e.preventDefault();
-                this.setValue(current + this.step * PAGE_STEP_MULTIPLIER, false);
-            }
-            else if (e.key === 'PageDown') {
-                e.preventDefault();
-                this.setValue(current - this.step * PAGE_STEP_MULTIPLIER, false);
-            }
-            else if (e.key === 'Home') {
-                e.preventDefault();
-                this.setValue(this.domain().lo, false);
-            }
-            else if (e.key === 'End') {
-                e.preventDefault();
-                this.setValue(this.domain().hi, false);
-            }
-        };
-        this.onKeyUp = (e) => {
-            // Only commit on release of the keys onKeyDown acts on — releasing an
-            // unrelated key (Tab, Shift, ...) while the thumb happens to be focused
-            // must not emit a spurious lyra-change. For a single discrete press this
-            // pairs one onKeyDown (lyra-input) with one onKeyUp (lyra-change); OS
-            // key-repeat while a key is held re-fires onKeyDown (and thus
-            // lyra-input) repeatedly but still commits only once, on the eventual
-            // keyup — the same drag-like "continuous input, single final change"
-            // shape a pointer drag has.
-            if (this.effectiveDisabled || !isSliderKey(e.key))
-                return;
-            this.emit('lyra-change', { value: this.valueAsNumber });
-        };
-        this.onPointerDown = (e) => {
-            if (this.effectiveDisabled)
-                return;
-            this.activePointers.add(e.pointerId);
-            e.target.setPointerCapture(e.pointerId);
-            window.addEventListener('pointermove', this.onPointerMove);
-            window.addEventListener('pointerup', this.onPointerUp);
-            // A drag can end without a pointerup: a system gesture / palm rejection
-            // can fire `pointercancel`, and losing capture (e.g. element removed)
-            // fires `lostpointercapture` — both need the same teardown as pointerup.
-            window.addEventListener('pointercancel', this.onPointerUp);
-            window.addEventListener('lostpointercapture', this.onPointerUp);
-        };
-        this.onPointerMove = (e) => {
-            if (!this.activePointers.has(e.pointerId))
-                return;
-            if (this.effectiveDisabled) {
-                // These are window-level listeners driven by setPointerCapture, so
-                // they keep firing for this pointerId regardless of the `disabled`
-                // reflection — a drag already in progress would otherwise keep
-                // mutating `value` (and emitting lyra-input) after `disabled` flips
-                // true mid-drag. Abort the drag instead of continuing to process it.
-                this.endDrag(e.pointerId, false);
-                return;
-            }
-            const track = this.renderRoot.querySelector('[part="track"]');
-            if (!track)
-                return;
-            const rect = track.getBoundingClientRect();
-            const raw = rect.width === 0 ? 0 : (e.clientX - rect.left) / rect.width;
-            // The track is positioned with inset-inline-start (0% at the visual
-            // right edge under RTL), so the pointer ratio has to mirror that or a
-            // rightward drag would move the thumb the wrong way.
-            const ratio = Math.min(1, Math.max(0, isRtl(this) ? 1 - raw : raw));
-            const { lo, hi } = this.domain();
-            this.setValue(lo + ratio * (hi - lo), false);
-        };
-        this.onPointerUp = (e) => {
-            this.endDrag(e.pointerId, true);
-        };
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    connectedCallback() {
-        super.connectedCallback();
-        this.ensureValue();
-    }
-    disconnectedCallback() {
-        super.disconnectedCallback();
-        // Mirror lyra-split/lyra-time-range's cleanup: if the element is removed
-        // mid-drag (or a pointercancel/alt-tab means pointerup never reaches
-        // `window`), these window-level listeners would otherwise leak.
-        this.activePointers.clear();
-        window.removeEventListener('pointermove', this.onPointerMove);
-        window.removeEventListener('pointerup', this.onPointerUp);
-        window.removeEventListener('pointercancel', this.onPointerUp);
-        window.removeEventListener('lostpointercapture', this.onPointerUp);
-    }
-    /** The numeric counterpart of `value`, mirroring native `<input
-     *  type=range>.valueAsNumber`. Reading always returns a finite, clamped,
-     *  step-snapped number — even if `value` is momentarily `""` (e.g. right
-     *  after `form.reset()` restores an undeclared default) — by falling back
-     *  to the midpoint of `[min, max]`. Writing stringifies the clamped result
-     *  back into `value`. */
-    get valueAsNumber() {
-        if (this.value === '')
-            return this.defaultNumericValue();
-        const n = Number(this.value);
-        return Number.isFinite(n) ? this.clampValue(n) : this.defaultNumericValue();
-    }
-    set valueAsNumber(next) {
-        this.value = String(this.clampValue(next));
-    }
-    /** If `value` is still unset, seed it with the sanitized default — the
-     *  midpoint of `[min, max]`, snapped to `step` — so `value`/`valueAsNumber`
-     *  and rendering never have to treat "" as a real, distinct state. */
-    ensureValue() {
-        if (this.value === '')
-            this.value = String(this.defaultNumericValue());
-    }
-    domain() {
-        // A caller-supplied min/max that fails Number attribute conversion
-        // arrives here as NaN; fall back to this property's own default rather
-        // than propagating NaN into every clampValue()/percentOf() caller.
-        const min = isNaN(this.min) ? 0 : this.min;
-        const max = isNaN(this.max) ? 100 : this.max;
-        return { lo: Math.min(min, max), hi: Math.max(min, max) };
-    }
-    defaultNumericValue() {
-        const { lo, hi } = this.domain();
-        return this.clampValue(lo + (hi - lo) / 2);
-    }
-    percentOf(value) {
-        if (isNaN(value))
-            return 0;
-        const { lo, hi } = this.domain();
-        const span = hi - lo || 1;
-        return ((value - lo) / span) * 100;
-    }
-    clampValue(raw) {
-        const { lo, hi } = this.domain();
-        // A non-positive or non-finite step would otherwise divide by zero/NaN
-        // below; treat it as "unstepped" instead of propagating NaN.
-        const hasStep = Number.isFinite(this.step) && this.step > 0;
-        let stepped = raw;
-        if (hasStep) {
-            // Anchor the step grid at the domain's own `lo` (matching native
-            // `<input type=range>`) instead of absolute 0, and round back to
-            // `step`'s own decimal precision so repeated steps land on exact
-            // values like 0.7 instead of 0.7000000000000001.
-            const stepsFromLo = Math.round((raw - lo) / this.step);
-            const factor = 10 ** decimalPlaces(this.step);
-            stepped = Math.round((lo + stepsFromLo * this.step) * factor) / factor;
-        }
-        return Math.min(hi, Math.max(lo, stepped));
-    }
-    formatValue(v) {
-        return String(v);
-    }
-    setValue(raw, commit) {
-        const clamped = this.clampValue(raw);
-        this.value = String(clamped);
-        this.emit('lyra-input', { value: clamped });
-        if (commit)
-            this.emit('lyra-change', { value: clamped });
-    }
-    /** Stop the drag owned by `pointerId`, optionally committing a final lyra-change. */
-    endDrag(pointerId, commit) {
-        if (!this.activePointers.has(pointerId))
-            return;
-        this.activePointers.delete(pointerId);
-        if (commit)
-            this.emit('lyra-change', { value: this.valueAsNumber });
-        // Only the last concurrent drag to end tears down the shared window
-        // listeners — an overlapping second pointer may still be down.
-        if (this.activePointers.size === 0) {
-            window.removeEventListener('pointermove', this.onPointerMove);
-            window.removeEventListener('pointerup', this.onPointerUp);
-            window.removeEventListener('pointercancel', this.onPointerUp);
-            window.removeEventListener('lostpointercapture', this.onPointerUp);
-        }
-    }
-    willUpdate(changed) {
-        // `formResetCallback` (inherited from `FormAssociated`, restoring
-        // `value` to whatever default the mixin captured — "" when no `value`
-        // attribute was ever declared) isn't part of the mixin's exported
-        // `FormAssociatedInterface` type, so it can't be overridden here with a
-        // `super` call the way `connectedCallback`/`disconnectedCallback` above
-        // are. Catching the resulting empty `value` here instead, in the same
-        // pre-render pass that already re-clamps a changed min/max/step below,
-        // covers `form.reset()` the same way `connectedCallback` covers first
-        // mount — and doing it in `willUpdate` (not `updated`) folds the fix-up
-        // into this same update cycle instead of scheduling a second one.
-        if (changed.has('value') && this.value === '') {
-            this.ensureValue();
-            return;
-        }
-        if ((changed.has('min') || changed.has('max') || changed.has('step')) && this.value !== '') {
-            // A narrowed/shifted domain (or a changed step grid) after mount must
-            // not leave `value` — and the rendered thumb position it drives —
-            // outside the current bounds or off the step grid. `min`/`max`/`step`
-            // already hold their new values by this point, so the getter itself
-            // (which clamps against the live domain) computes the corrected value.
-            const next = String(this.valueAsNumber);
-            if (next !== this.value)
-                this.value = next;
-        }
-    }
-    render() {
-        const num = this.valueAsNumber;
-        const pct = this.percentOf(num);
-        const text = this.formatValue(num);
-        const { lo, hi } = this.domain();
-        const ariaLabel = this.label || this.getAttribute('aria-label') || nothing;
-        return html `
-      <div part="base">
-        <div part="track"></div>
-        <div part="fill" style=${`inline-size:${pct}%`}></div>
-        <div
-          part="thumb"
-          role="slider"
-          tabindex=${this.effectiveDisabled ? '-1' : '0'}
-          aria-valuemin=${lo}
-          aria-valuemax=${hi}
-          aria-valuenow=${num}
-          aria-valuetext=${text}
-          aria-label=${ariaLabel}
-          aria-disabled=${this.effectiveDisabled ? 'true' : nothing}
-          style=${`inset-inline-start:${pct}%`}
-          @pointerdown=${this.onPointerDown}
-          @keydown=${this.onKeyDown}
-          @keyup=${this.onKeyUp}
-        ></div>
-      </div>
-      ${this.showValue ? html `<span part="value" aria-hidden="true">${text}</span>` : nothing}
-    `;
-    }
-}
-__decorate([
-    property({ type: Number })
-], LyraSlider.prototype, "min", void 0);
-__decorate([
-    property({ type: Number })
-], LyraSlider.prototype, "max", void 0);
-__decorate([
-    property({ type: Number })
-], LyraSlider.prototype, "step", void 0);
-__decorate([
-    property()
-], LyraSlider.prototype, "label", void 0);
-__decorate([
-    property({ type: Boolean, attribute: 'show-value' })
-], LyraSlider.prototype, "showValue", void 0);
 defineElement('slider', LyraSlider);
+//# sourceMappingURL=slider.js.map

package/dist/components/slider/slider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slider.js","sourceRoot":"","sources":["../../../src/components/slider/slider.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,aAAa,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC"}

package/dist/components/slider/slider.styles.d.ts

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

package/dist/components/slider/slider.styles.d.ts.map

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

package/dist/components/slider/slider.styles.js

@@ -9,34 +9,34 @@ export const styles = css `
   [part='base'] {
     position: relative;
     flex: 1 1 auto;
-    block-size: 1.5rem;
+    block-size: var(--lyra-size-1-5rem);
   }
   [part='track'] {
     position: absolute;
     inset-inline: 0;
     inset-block-start: 50%;
-    block-size: 4px;
+    block-size: var(--lyra-size-4px);
     transform: translateY(-50%);
-    border-radius: 2px;
+    border-radius: var(--lyra-size-2px);
     background: var(--lyra-color-border);
   }
   [part='fill'] {
     position: absolute;
     inset-inline-start: 0;
     inset-block-start: 50%;
-    block-size: 4px;
+    block-size: var(--lyra-size-4px);
     transform: translateY(-50%);
-    border-radius: 2px;
+    border-radius: var(--lyra-size-2px);
     background: var(--lyra-color-brand);
   }
   [part='thumb'] {
     position: absolute;
     inset-block-start: 50%;
-    inline-size: 16px;
-    block-size: 16px;
+    inline-size: var(--lyra-size-16px);
+    block-size: var(--lyra-size-16px);
     border-radius: 50%;
     background: var(--lyra-color-brand);
-    border: 2px solid var(--lyra-color-surface);
+    border: var(--lyra-border-width-medium) solid var(--lyra-color-surface);
     box-shadow: var(--lyra-shadow);
     transform: translate(-50%, -50%);
     cursor: grab;
@@ -55,8 +55,8 @@ export const styles = css `
     position: absolute;
     inset-block-start: 50%;
     inset-inline-start: 50%;
-    inline-size: 28px;
-    block-size: 28px;
+    inline-size: var(--lyra-size-28px);
+    block-size: var(--lyra-size-28px);
     transform: translate(-50%, -50%);
     border-radius: 50%;
   }
@@ -69,19 +69,20 @@ export const styles = css `
   }
   [part='value'] {
     flex: 0 0 auto;
-    font-size: 0.8125rem;
+    font-size: var(--lyra-font-size-sm);
     color: var(--lyra-color-text-quiet);
     /* Numeric readout ticks as the thumb moves; tabular-nums keeps its own
        inline-size stable instead of jittering the layout next to it. */
     font-variant-numeric: tabular-nums;
-    min-inline-size: 2.5ch;
+    min-inline-size: var(--lyra-size-2-5ch);
     text-align: end;
   }
-  :host([disabled]) {
+  :host(:disabled) {
     opacity: var(--lyra-opacity-disabled);
     cursor: not-allowed;
   }
-  :host([disabled]) [part='thumb'] {
+  :host(:disabled) [part='thumb'] {
     cursor: not-allowed;
   }
 `;
+//# sourceMappingURL=slider.styles.js.map

package/dist/components/slider/slider.styles.js.map

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

package/dist/components/source-card/source-card.class.d.ts

@@ -0,0 +1,105 @@
+import { type PropertyValues, type TemplateResult } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+export interface SourceCardExpandDetail {
+    sourceId: string;
+    expanded: boolean;
+}
+export interface SourceCardOpenDetail {
+    sourceId: string;
+    href?: string;
+}
+/**
+ * `<lyra-source-card>` — one citation/source entry, meant to be a direct
+ * light-DOM child of `<lyra-source-list>` (though it renders and functions
+ * fine standalone). Shows a title/page heading, an always-visible `excerpt`
+ * slot, and an optional `full` slot revealed behind its own independent
+ * "Show more" toggle — unrelated to the parent `<lyra-source-list>`'s own
+ * expand/collapse, which only ever hides/shows the *set* of cards, never a
+ * single card's own content.
+ *
+ * `source-id` is this card's stable identity, meant to match a
+ * `<lyra-citation-badge>` (a sibling component) elsewhere on the page. This
+ * component doesn't implement any scroll-to/highlight behavior itself — that
+ * lives at the app level, wiring a citation badge's activation event to this
+ * card's `id`/`source-id`. See the `@example` below.
+ *
+ * @customElement lyra-source-card
+ * @slot excerpt - A short preview. When left empty, the `excerpt` part
+ * collapses away entirely rather than leaving an empty gap in the card.
+ * @slot full - The complete source text/chunk, hidden behind the "Show
+ * more"/"Show less" toggle. When left empty, no toggle renders at all — a
+ * card with no `full` content simply has no expand affordance. Removing all
+ * `full`-slotted content while expanded automatically collapses it back.
+ * @event lyra-expand - The per-card "Show more"/"Show less" toggle was
+ * activated. `detail: { sourceId, expanded }`.
+ * @event lyra-open - The title was activated. `detail: { sourceId, href }` —
+ * `href` may be `undefined`. This component never navigates on its own
+ * (staying a controlled component, the same convention
+ * `<lyra-tool-call-chip>`'s `lyra-tool-chip-select` follows); a listener
+ * decides what "open" means (open `href` in a new tab, open an in-app
+ * viewer, etc).
+ * @csspart base - The outer container.
+ * @csspart title - The clickable title/page heading (`<button>`).
+ * @csspart excerpt - The wrapper around the `excerpt` slot, `hidden` when the slot has no assigned content.
+ * @csspart full - The wrapper around the `full` slot, `hidden` while collapsed.
+ * @csspart toggle - The "Show more"/"Show less" button. Only rendered when the `full` slot has content.
+ *
+ * @example
+ * ```html
+ * <lyra-source-list label-plural="2 sources">
+ *   <lyra-source-card source-id="doc-1" title="annual_report.pdf" page="12">
+ *     <span slot="excerpt">Revenue grew 12% year over year...</span>
+ *     <span slot="full">Revenue grew 12% year over year, driven primarily by...</span>
+ *   </lyra-source-card>
+ * </lyra-source-list>
+ * ```
+ * ```js
+ * // Elsewhere, a <lyra-citation-badge>'s activation handler can scroll to
+ * // and highlight the matching card -- this component needs no extra API
+ * // surface for that, only its existing source-id to be targeted by:
+ * document.addEventListener('lyra-citation-activate', (e) => {
+ *   const card = document.querySelector(`lyra-source-card[source-id="${e.detail.sourceId}"]`);
+ *   card?.scrollIntoView({ behavior: 'smooth', block: 'center' });
+ *   card?.classList.add('is-highlighted'); // consumer-defined CSS, e.g. a brief background flash
+ *   setTimeout(() => card?.classList.remove('is-highlighted'), 2000);
+ * });
+ * ```
+ */
+export declare class LyraSourceCard extends LyraElement {
+    static styles: import("lit").CSSResultGroup[];
+    /** Stable identifier matching a `<lyra-citation-badge>` elsewhere on the page. */
+    sourceId: string;
+    /** The source's display title, e.g. a filename. Rendered only as the
+     *  title button's own text -- a bare host-level `title` attribute (the
+     *  browser's global tooltip attribute) is actively stripped once Lit has
+     *  synced it into this property, so the card never grows an unsolicited
+     *  native tooltip repeating the same text. See `attributeChangedCallback`
+     *  and `updated` below. */
+    title: string;
+    /** Optional page reference, e.g. `12` or `"iv"` — rendered as-is (never
+     *  parsed/validated as a number), so a non-numeric page label works too. */
+    page?: string | number;
+    /** Optional URL, echoed back (unopened) in `lyra-open`'s detail. */
+    href?: string;
+    private hasFullSlot;
+    private hasExcerptSlot;
+    private fullExpanded;
+    private readonly fullId;
+    private stripHostTitleAttr;
+    protected willUpdate(): void;
+    firstUpdated(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private onFullSlotChange;
+    private onExcerptSlotChange;
+    private get titleText();
+    private onTitleClick;
+    private toggleFull;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-source-card': LyraSourceCard;
+    }
+}
+//# sourceMappingURL=source-card.class.d.ts.map

package/dist/components/source-card/source-card.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-card.class.d.ts","sourceRoot":"","sources":["../../../src/components/source-card/source-card.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAE9E,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAI7D,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,MAAM,CAAC,MAAM,iCAAgC;IAE7C,kFAAkF;IAC5C,QAAQ,SAAM;IAEpD;;;;;+BAK2B;IACf,KAAK,SAAM;IAEvB;gFAC4E;IAChE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEnC,oEAAoE;IACxD,IAAI,CAAC,EAAE,MAAM,CAAC;IAMjB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,YAAY,CAAS;IAEtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IAOrD,OAAO,CAAC,kBAAkB,CAAS;IAEnC,SAAS,CAAC,UAAU,IAAI,IAAI,CAK3B;IAED,YAAY,IAAI,IAAI,CAQnB;IAED,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAGrF;IAED,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI,CAUrD;IAED,OAAO,CAAC,gBAAgB,CAItB;IAEF,OAAO,CAAC,mBAAmB,CAEzB;IAEF,OAAO,KAAK,SAAS,GAGpB;IAED,OAAO,CAAC,YAAY,CAElB;IAEF,OAAO,CAAC,UAAU,CAGhB;IAEF,MAAM,IAAI,cAAc,CAuBvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,kBAAkB,EAAE,cAAc,CAAC;KACpC;CACF"}