@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/typing-indicator/typing-indicator.js

@@ -1,96 +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 } from 'lit';
-import { property } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './typing-indicator.class.js';
+import { LyraTypingIndicator } from './typing-indicator.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { srOnly } from '../../internal/a11y.js';
-import { styles } from './typing-indicator.styles.js';
-/**
- * `<lyra-typing-indicator>` — a purely presentational "assistant is
- * responding" presence cue. No events, no interactivity: a consumer mounts
- * it while a response is being generated and removes it (or hides it) once
- * real content has arrived.
- *
- * Three visual variants share one component rather than three separate tags
- * because callers pick between them along a single axis — how the
- * surrounding surface wants the cue to read — and nothing else about the
- * component differs:
- * - `dots` (default) — three dots with a staggered bounce, the classic
- *   "typing…" affordance for a standalone status line.
- * - `pulse` — a single breathing dot, a quieter cue for a tighter space
- *   (e.g. next to an avatar).
- * - `cursor` — a blinking vertical bar, meant to sit inline at the tail end
- *   of streamed text that is still being appended to.
- *
- * Accessibility: this indicator typically mounts and unmounts around a real
- * generation lifecycle (appears when a response starts, disappears once one
- * arrives) rather than emitting a stream of updates of its own, so it does
- * *not* route through `<lyra-live-region>`/`Announcer`
- * (`../../internal/announcer.js`) — that machinery exists to coalesce many
- * rapidly-changing announcements into one, and there is only ever a single
- * announcement here: the mount itself. A plain `role="status"` plus an
- * accessible name derived from `label` is sufficient, set both as an
- * `aria-label` on the host *and* as a visually-hidden text node in the
- * shadow tree, so the name survives even if only one of the two is picked up
- * by a given assistive-tech/browser pairing. The animated dots/pulse/cursor
- * shape is `aria-hidden="true"` — it's decorative; `label` is the entire
- * accessible content, so nothing narrates individual animation frames.
- *
- * @customElement lyra-typing-indicator
- * @csspart base - The decorative (`aria-hidden`) wrapper around the animated shape.
- * @csspart dot - Each of the three dots in the `dots` variant.
- * @csspart pulse - The single pulsing dot in the `pulse` variant.
- * @csspart cursor - The blinking bar in the `cursor` variant.
- */
-export class LyraTypingIndicator extends LyraElement {
-    constructor() {
-        super(...arguments);
-        /** Which decorative presentation to render. */
-        this.variant = 'dots';
-        /** Accessible name, exposed via `role="status"`. Not re-announced on every
-         *  animation frame — only mount (and any later change to this property)
-         *  produces a new announcement. */
-        this.label = 'Thinking…';
-        /** Compact sizing for dense layouts (e.g. inline with a message bubble). */
-        this.size = 'md';
-    }
-    static { this.styles = [LyraElement.styles, styles, srOnly]; }
-    willUpdate(changed) {
-        this.setAttribute('role', 'status');
-        if (changed.has('label')) {
-            this.setAttribute('aria-label', this.label);
-        }
-    }
-    render() {
-        return html `
-      <span part="base" aria-hidden="true">${this.renderShape()}</span>
-      <span class="sr-only">${this.label}</span>
-    `;
-    }
-    renderShape() {
-        switch (this.variant) {
-            case 'pulse':
-                return html `<span part="pulse"></span>`;
-            case 'cursor':
-                return html `<span part="cursor"></span>`;
-            case 'dots':
-            default:
-                return html `<span part="dot"></span><span part="dot"></span><span part="dot"></span>`;
-        }
-    }
-}
-__decorate([
-    property({ reflect: true })
-], LyraTypingIndicator.prototype, "variant", void 0);
-__decorate([
-    property()
-], LyraTypingIndicator.prototype, "label", void 0);
-__decorate([
-    property({ reflect: true })
-], LyraTypingIndicator.prototype, "size", void 0);
 defineElement('typing-indicator', LyraTypingIndicator);
+//# sourceMappingURL=typing-indicator.js.map

package/dist/components/typing-indicator/typing-indicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing-indicator.js","sourceRoot":"","sources":["../../../src/components/typing-indicator/typing-indicator.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,aAAa,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAC"}

package/dist/components/typing-indicator/typing-indicator.styles.d.ts

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

package/dist/components/typing-indicator/typing-indicator.styles.d.ts.map

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

package/dist/components/typing-indicator/typing-indicator.styles.js

@@ -17,16 +17,16 @@ export const styles = css `
     display: inline-flex;
     align-items: center;
     vertical-align: middle;
-    line-height: 1;
-    --lyra-typing-dot-size: 0.5rem;
-    --lyra-typing-gap: 0.25rem;
-    --lyra-typing-cursor-width: 0.125rem;
-    --lyra-typing-cursor-height: 1em;
+    line-height: var(--lyra-line-height-none);
+    --lyra-typing-dot-size: var(--lyra-space-s);
+    --lyra-typing-gap: var(--lyra-space-xs);
+    --lyra-typing-cursor-width: var(--lyra-size-0-125rem);
+    --lyra-typing-cursor-height: var(--lyra-size-1em);
   }
   :host([size='sm']) {
-    --lyra-typing-dot-size: 0.375rem;
-    --lyra-typing-gap: 0.1875rem;
-    --lyra-typing-cursor-width: 0.09375rem;
+    --lyra-typing-dot-size: var(--lyra-size-0-375rem);
+    --lyra-typing-gap: var(--lyra-size-0-1875rem);
+    --lyra-typing-cursor-width: var(--lyra-size-0-09375rem);
   }
 
   [part='base'] {
@@ -130,3 +130,4 @@ export const styles = css `
     }
   }
 `;
+//# sourceMappingURL=typing-indicator.styles.js.map

package/dist/components/typing-indicator/typing-indicator.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing-indicator.styles.js","sourceRoot":"","sources":["../../../src/components/typing-indicator/typing-indicator.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,6EAA6E;AAC7E,yEAAyE;AACzE,0EAA0E;AAC1E,qEAAqE;AACrE,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,0EAA0E;AAC1E,6EAA6E;AAC7E,2EAA2E;AAC3E,wEAAwE;AACxE,2EAA2E;AAC3E,8DAA8D;AAC9D,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHxB,CAAC"}

package/dist/components/virtual-list/virtual-list.class.d.ts

@@ -0,0 +1,215 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+/** Largest accepted overscan on either side of the visible range. This keeps
+ *  an accidental huge value from defeating virtualization. */
+export declare const MAX_OVERSCAN_ROWS = 100;
+/** `lyra-visible-range-changed` detail -- the current visible (non-overscanned) item index range. */
+export interface VirtualListRange {
+    start: number;
+    end: number;
+}
+/** A visible group label anchored to the first row in its group. */
+export interface VirtualListGroup {
+    key: string | number;
+    label?: string;
+    startIndex: number;
+}
+type VirtualListKey = string | number;
+/**
+ * `<lyra-virtual-list>` — a generic windowed/virtualized list host. Renders
+ * only the items within the current viewport (plus `overscan` padding rows
+ * on each side) as real DOM, regardless of how large `items` is, so a
+ * multi-thousand-row chat history sidebar or long message thread stays cheap
+ * to scroll.
+ *
+ * Content is entirely caller-supplied: `renderItem(item, index)` returns
+ * whatever `lit-html` value should represent that row (typically a
+ * `TemplateResult`), and `keyFunction(item, index)` gives it a stable
+ * identity for `repeat()`'s DOM-reconciliation key, so scroll position and
+ * any per-row state (e.g. an `<audio>` element's playback position) survive
+ * an `items` mutation instead of every row remounting from scratch.
+ *
+ * **Windowing math.** Every row — in both `row-height` modes — is positioned
+ * by a `transform: translateY(offset)` computed from a single cumulative
+ * `offsets` array (`offsets[i]` = the pixel top of row `i`), rather than by
+ * page flow. This is what lets only a small DOM window exist while the
+ * scrollbar still reflects the *true* total content height:
+ * - **`row-height="auto"` (default).** Each currently-rendered row is
+ *   watched by a `ResizeObserver`; its real height lands in a per-key
+ *   `Map`, and any row not yet measured contributes `DEFAULT_ROW_ESTIMATE_PX`
+ *   to the offsets array until it has been. `offsets` is *not* the same
+ *   thing as a page-count-based `padding-top`/`padding-bottom` spacer pair —
+ *   that approach reflows every unmeasured row's position on every new
+ *   measurement, which is exactly what per-row transform offsets avoid: only
+ *   the rows *after* a newly-measured one shift, and even that shift is a
+ *   cheap style recompute, not a layout-affecting padding change.
+ * - **Fixed numeric `row-height`.** No measurement needed — `offsets[i]` is
+ *   just `i * rowHeightPx`, computed by the exact same cumulative-array code
+ *   path (a dedicated "single spacer + start-index" special case was
+ *   considered and would work too, but reusing one code path for both modes
+ *   avoids maintaining two parallel rendering strategies for a difference
+ *   that's otherwise just "how is row *i*'s height looked up").
+ *
+ * The `offsets` array is rebuilt only when `items`, `row-height`, or
+ * `keyFunction` change, or a row's measured height changes -- not on every
+ * update, so a pure scroll-position tick (potentially every rAF while
+ * scrolling) only re-runs the cheap range/visibility math in
+ * `computeRange()`, never the `O(n)` offsets rebuild (which, in
+ * `row-height="auto"` mode, also means a `keyFunction` call per item). For
+ * the list sizes this component is meant for (a scrollable history sidebar,
+ * realistically hundreds to a few thousand rows) that rebuild is a trivial
+ * `O(n)` arithmetic loop even when it does run; it is *not* the right
+ * approach for a hundred-thousand-row list without further work (e.g. a
+ * Fenwick/segment tree for `O(log n)` offset queries+updates), which is out
+ * of scope here.
+ *
+ * **Accessibility.** The scroll container is `role="list"` and each rendered
+ * row is `role="listitem"`, deliberately *not* `listbox`/`option` — this
+ * component only provides windowing, not the roving-tabindex/
+ * `aria-activedescendant` keyboard-interaction contract ARIA requires
+ * alongside a real `listbox`. A consumer that wants full single-select
+ * listbox semantics on top of this should compose that behavior itself (see
+ * `<lyra-select>`'s pattern), the same way this component's `active-id`
+ * only *scrolls* the matching row into view and marks it `aria-current` —
+ * it never claims to be a selection widget. `aria-setsize`/`aria-posinset`
+ * are computed from the row's real index in the full `items` array (not its
+ * position among the currently-rendered DOM window), so a screen reader
+ * still announces e.g. "item 12 of 340" correctly. `[part="base"]` itself
+ * carries `tabindex="0"` — `renderItem`'s content is caller-supplied and not
+ * guaranteed to contain a focusable element, and a scrollable region with no
+ * focusable content of its own is otherwise unreachable by keyboard (native
+ * arrow/Page Up/Page Down scrolling included).
+ *
+ * **Grouping.** When supplied, `groups` renders a labeled group marker at the
+ * corresponding `startIndex`. Group markers are positioned independently of
+ * the row window, so they remain available when the first row in a group is
+ * outside the current overscanned range.
+ *
+ * @customElement lyra-virtual-list
+ * @event lyra-load-more - Fired once per approach to the bottom of the list
+ *   while `has-more` is true and `loading` is false. Deliberately does not
+ *   refire on every scroll tick while still near the bottom (`loading`
+ *   gates the in-flight case; scrolling back away from the bottom and
+ *   returning, or `items` growing enough to move the window away from the
+ *   end, re-arms it) — a consumer wanting an automatic retry after a failed
+ *   fetch should surface its own retry affordance rather than relying on
+ *   this firing again unprompted.
+ * @event lyra-visible-range-changed - `detail: { start, end }` (see
+ *   `VirtualListRange`) — the current visible (non-overscanned) item index
+ *   range, fired only when it actually changes.
+ * @csspart base - The scrollable container (`role="list"`).
+ * @csspart spacer - The full-content-height inner element that gives the
+ *   container its true scrollable extent.
+ * @csspart group - A positioned group label.
+ * @csspart row - One rendered row's absolutely-positioned wrapper
+ *   (`role="listitem"`); `renderItem`'s return value renders inside it.
+ */
+export interface LyraVirtualListEventMap {
+    'lyra-visible-range-changed': CustomEvent<VirtualListRange>;
+    'lyra-load-more': CustomEvent<undefined>;
+}
+export declare class LyraVirtualList extends LyraElement<LyraVirtualListEventMap> {
+    static styles: import("lit").CSSResultGroup[];
+    /** The full (non-windowed) item collection. */
+    items: unknown[];
+    /** Renders one row's content — typically returns a `lit-html` `TemplateResult`. */
+    renderItem: (item: unknown, index: number) => unknown;
+    /** Derives a row's stable `repeat()` key. Falls back to the item's index
+     *  in `items` when omitted, which is only a safe identity while `items`
+     *  never reorders/inserts/removes — provide this whenever it can, or
+     *  scroll position and any per-row DOM state can attach to the wrong row
+     *  across a mutation (same caveat as `<lyra-table>`'s `rowKey`). */
+    keyFunction?: (item: unknown, index: number) => string | number;
+    /** Group labels positioned at their first row's `startIndex`. Invalid or
+     * duplicate indexes are ignored during rendering. */
+    groups?: VirtualListGroup[];
+    /** `'auto'` (default) measures each row's real height via `ResizeObserver`;
+     *  a numeric string fixes every row to that many pixels. */
+    rowHeight: string;
+    /** Extra rows rendered beyond the visible viewport on each side, to reduce
+     *  blank-frame risk during fast scrolling. Normalized to a whole number in
+     *  the inclusive range 0–`MAX_OVERSCAN_ROWS`; non-finite values use the
+     *  default. */
+    overscan: number;
+    /** When set and it matches a row's typed `keyFunction` result, that row is
+     * smoothly scrolled into view whenever this changes. Attribute values are
+     * strings; assign the property for a numeric key. */
+    activeId: VirtualListKey | '';
+    loading: boolean;
+    /** When true, scrolling near the bottom fires `lyra-load-more`. */
+    hasMore: boolean;
+    private containerScrollTop;
+    private viewportHeight;
+    /** `offsets[i]` = row `i`'s pixel top; `offsets[items.length]` = total content height. Rebuilt only when `offsetsDirty` is set -- see `willUpdate()`. */
+    private offsets;
+    /** Parsed `rowHeight`: a positive pixel number, or `null` for `'auto'` (measured) mode. */
+    private fixedRowHeight;
+    /** `row-height="auto"` per-row measured heights, keyed by
+     *  keyFunction result. Pruned to the current `items`'
+     *  live keys whenever `items` changes (see `recomputeOffsets()`), so a
+     *  long-lived instance handed many wholly different `items` arrays over
+     *  its life doesn't grow this map without bound. */
+    private readonly measuredHeights;
+    /** True whenever `offsets` needs rebuilding before the next render --
+     *  set initially and whenever `items`/`rowHeight`/`keyFunction` change or
+     *  a row's measured height changes, but *not* on a pure scroll-position
+     *  update, so the `O(n)` rebuild (including a `keyFunction` call per item
+     *  in `row-height="auto"` mode) only runs when something that actually
+     *  affects row heights or ordering changed. */
+    private offsetsDirty;
+    /** Set alongside `offsetsDirty` specifically when `items` changed (not
+     *  just `rowHeight`/`keyFunction`/a measurement) -- consumed by the next
+     *  `recomputeOffsets()` call to prune `measuredHeights` entries for keys
+     *  no longer present in `items`. */
+    private itemsChangedPendingPrune;
+    private renderStart;
+    private renderEnd;
+    private visibleStart;
+    private visibleEnd;
+    private lastEmittedStart;
+    private lastEmittedEnd;
+    /** Re-armed whenever the window moves away from the end of `items` -- see the `lyra-load-more` event doc. */
+    private loadMoreArmed;
+    private isFirstUpdate;
+    private rowResizeObserver?;
+    private containerResizeObserver?;
+    private readonly observedRows;
+    private readonly observedRowKeys;
+    private readonly observedRowIndices;
+    private scrollRafId?;
+    private pendingScrollTop;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    private parseRowHeight;
+    private keyOf;
+    private recomputeOffsets;
+    /** First item index whose bottom edge is at/after `offset`. */
+    private findIndexAtOrAfter;
+    /** Last item index whose top edge is at/before `offset`. */
+    private findIndexAtOrBefore;
+    private computeRange;
+    private attachContainerListeners;
+    private onScroll;
+    private onRowsResized;
+    /** Keeps the row `ResizeObserver` watching exactly the currently-rendered
+     *  rows in `row-height="auto"` mode -- rows that scroll out of the
+     *  rendered window are unobserved so the observer doesn't accumulate
+     *  references to detached elements it can never usefully report on again. */
+    private syncRowObservers;
+    private scrollActiveIntoView;
+    private emitRangeChangeIfNeeded;
+    private maybeFireLoadMore;
+    private renderRow;
+    private renderGroups;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-virtual-list': LyraVirtualList;
+    }
+}
+export {};
+//# sourceMappingURL=virtual-list.class.d.ts.map

package/dist/components/virtual-list/virtual-list.class.d.ts.map

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