@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/streaming-text/streaming-text.class.d.ts

@@ -0,0 +1,105 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import '../markdown/markdown.class.js';
+/** Runs {@link MARKDOWN_PATTERNS} against `text`, used whenever `markdown`
+ *  is left unset (auto-detect). Exported so the heuristic is directly
+ *  testable without going through the component's render cycle. */
+export declare function looksLikeMarkdown(text: string): boolean;
+/**
+ * `<lyra-streaming-text>` — a token-coalescing incremental text renderer for
+ * streaming assistant output, with an optional blinking cursor and
+ * auto-detected Markdown rendering.
+ *
+ * The host is expected to assign the *entire* current text on every update
+ * to `content`, not a delta -- this component does no accumulation or
+ * ordering of its own. That matches how most streaming-UI state (SSE/
+ * WebSocket token accumulation into a growing string in application state)
+ * is already managed.
+ *
+ * Token-by-token streaming can update `content` far faster than a human can
+ * usefully perceive a re-render -- dozens of times a second for a fast
+ * model. Re-rendering on every single assignment thrashes layout for no
+ * visible benefit, so updates funnel through `Announcer`
+ * (`../../internal/announcer.js`), reused here purely as the generic
+ * "coalesce rapid calls, flush the latest" timing primitive its own class
+ * doc says other components should reuse -- with none of its usual
+ * DOM/ARIA plumbing (that's `<lyra-live-region>`'s job, not this
+ * component's). Within any `coalesce-ms` window, only the *last* `content`
+ * value assigned actually reaches the rendered DOM. Two cases always bypass
+ * the throttle and flush immediately instead of waiting out the window: the
+ * very first `content` assignment after mount (so an already-complete
+ * message never shows an artificial startup delay), and any transition of
+ * `streaming` between `true` and `false` in either direction (so the final
+ * chunk of a finished stream can never be left stranded mid-window, and a
+ * stream restarting on a reused element can never keep showing the
+ * previous stream's stale final content for the length of the window).
+ *
+ * `markdown` is a tri-state property, not a plain boolean: left unset (the
+ * default), it auto-detects via a lightweight regex heuristic (see
+ * `looksLikeMarkdown`) run against whatever text is currently displayed --
+ * good enough to route obviously-Markdown output through `<lyra-markdown>`
+ * without the host needing to know or declare it up front, at the cost of
+ * an occasional one-time mode flip if Markdown syntax only appears partway
+ * through a stream. Explicitly setting `markdown` to `true`/`false` always
+ * wins over the heuristic. Rendering itself is never reimplemented here:
+ * Markdown mode composes `<lyra-markdown>` (`../markdown/markdown.js`)
+ * directly, forwarding this component's own `streaming` through as that
+ * component's own forward-compatible `streaming` hint prop; plain-text mode
+ * renders into a `white-space: pre-wrap` span instead.
+ *
+ * The blinking cursor (shown only while `streaming` is `true`) degrades to
+ * a static, always-visible bar under `prefers-reduced-motion: reduce`
+ * rather than disabling the animation into an invisible frozen frame --
+ * the same pattern `<lyra-typing-indicator>`'s own `cursor` variant uses. In
+ * plain-text mode the cursor sits inline at the tail of the final
+ * character, since the text is one continuous inline flow; in Markdown
+ * mode it renders as its own trailing block below the rendered content
+ * instead of attempting to splice into whatever nested block Markdown
+ * happens to end with (a paragraph, a table cell, a list item, a fenced
+ * code block, …) -- genuinely interleaving into arbitrary rendered Markdown
+ * without reaching across `<lyra-markdown>`'s own shadow boundary isn't a
+ * tractable general solution, so this component doesn't attempt it.
+ *
+ * Purely presentational: no events, driven entirely by its properties. It
+ * also doesn't announce anything to assistive tech itself -- a host that
+ * needs streamed text announced already has `<lyra-live-region>` for that
+ * (composed, for example, inside `<lyra-chat-message>`).
+ *
+ * @customElement lyra-streaming-text
+ * @csspart base - The root container.
+ * @csspart cursor - The blinking (or, under reduced motion, static) cursor bar. Only rendered while `streaming` is `true`.
+ */
+export declare class LyraStreamingText extends LyraElement {
+    static styles: import("lit").CSSResultGroup[];
+    /** The full current text so far -- always the complete string, never a
+     *  delta to append. */
+    content: string;
+    /** Shows the blinking cursor after the rendered text. Reflects, so a host
+     *  can also target `lyra-streaming-text[streaming]` in CSS. */
+    streaming: boolean;
+    /** Trailing-edge coalesce window, in ms, for `content` updates -- see the
+     *  class doc. */
+    coalesceMs: number;
+    /** `undefined` (default) auto-detects via `looksLikeMarkdown`; `true`/
+     *  `false` force that rendering mode regardless of content. */
+    markdown?: boolean;
+    private displayedContent;
+    private lastScannedContent?;
+    private lastScannedResult;
+    private readonly coalescer;
+    constructor();
+    protected willUpdate(changed: PropertyValues): void;
+    disconnectedCallback(): void;
+    /** Whether Markdown mode is actually in effect right now, resolving the
+     *  tri-state `markdown` property against the memoized `looksLikeMarkdown`
+     *  result for the currently-displayed content (see `lastScannedContent`/
+     *  `lastScannedResult` above). */
+    private get effectiveMarkdown();
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-streaming-text': LyraStreamingText;
+    }
+}
+//# sourceMappingURL=streaming-text.class.d.ts.map

package/dist/components/streaming-text/streaming-text.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-text.class.d.ts","sourceRoot":"","sources":["../../../src/components/streaming-text/streaming-text.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAkC,MAAM,KAAK,CAAC;AAE9G,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE7D,OAAO,+BAA+B,CAAC;AA2BvC;;mEAEmE;AACnE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGvD;AAsBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,MAAM,CAAC,MAAM,iCAAgC;IAE7C;2BACuB;IACX,OAAO,SAAM;IAEzB;mEAC+D;IACnB,SAAS,UAAS;IAE9D;qBACiB;IACqC,UAAU,SAAuB;IAEvF;mEAC+D;IACW,QAAQ,CAAC,EAAE,OAAO,CAAC;IAIpF,OAAO,CAAC,gBAAgB,CAAM;IAQvC,OAAO,CAAC,kBAAkB,CAAC,CAAS;IACpC,OAAO,CAAC,iBAAiB,CAAS;IAElC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IAEtC,cAYC;IAED,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CA+BlD;IAED,oBAAoB,IAAI,IAAI,CAG3B;IAED;;;sCAGkC;IAClC,OAAO,KAAK,iBAAiB,GAE5B;IAED,MAAM,IAAI,cAAc,CASvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,qBAAqB,EAAE,iBAAiB,CAAC;KAC1C;CACF"}

package/dist/components/streaming-text/streaming-text.class.js

@@ -0,0 +1,223 @@
+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 { Announcer } from '../../internal/announcer.js';
+import '../markdown/markdown.class.js';
+import { styles } from './streaming-text.styles.js';
+const DEFAULT_COALESCE_MS = 50;
+/**
+ * Lightweight, deliberately-imperfect signals that the currently-displayed
+ * text contains Markdown syntax worth routing through `<lyra-markdown>`
+ * rather than a plain `white-space: pre-wrap` node. Checked in order against
+ * the whole string; the first match short-circuits. None of these need to be
+ * airtight -- a false positive just renders ordinary prose through
+ * `<lyra-markdown>` (which renders plain prose fine); a false negative just
+ * renders literal `**`/backticks/etc. as plain text until more of the stream
+ * arrives.
+ */
+const MARKDOWN_PATTERNS = [
+    /^ {0,3}#{1,6}\s+\S/m, // ATX heading: "# Heading"
+    /```/, // fenced code block
+    /\*\*[^*\n]+\*\*/, // **bold**
+    /(?:^|[^\w])_[^_\n]+_(?:[^\w]|$)/, // _italic_
+    /`[^`\n]+`/, // inline code
+    /^ {0,3}[-*+]\s+\S/m, // bullet list item
+    /^ {0,3}\d+\.\s+\S/m, // numbered list item
+    /\[[^\]]+\]\([^)\s]+\)/, // [text](url)
+    /^ {0,3}>\s?\S/m, // blockquote
+];
+/** Runs {@link MARKDOWN_PATTERNS} against `text`, used whenever `markdown`
+ *  is left unset (auto-detect). Exported so the heuristic is directly
+ *  testable without going through the component's render cycle. */
+export function looksLikeMarkdown(text) {
+    if (!text)
+        return false;
+    return MARKDOWN_PATTERNS.some((pattern) => pattern.test(text));
+}
+/**
+ * Tri-state boolean attribute converter for `markdown`. Lit's built-in
+ * `type: Boolean` converter is presence-based and can only ever represent
+ * two states (attribute present -> `true`, absent -> `false`) -- there's no
+ * way for it to also represent "not specified, auto-detect instead", which
+ * is the actual default this property needs. `markdown` (no value, or
+ * `="true"`) -> `true`; `markdown="false"` -> `false`; attribute entirely
+ * absent -> `undefined`.
+ */
+const optionalBooleanConverter = {
+    fromAttribute(value) {
+        if (value === null)
+            return undefined;
+        return value !== 'false';
+    },
+    toAttribute(value) {
+        if (value === undefined)
+            return null;
+        return value ? '' : 'false';
+    },
+};
+/**
+ * `<lyra-streaming-text>` — a token-coalescing incremental text renderer for
+ * streaming assistant output, with an optional blinking cursor and
+ * auto-detected Markdown rendering.
+ *
+ * The host is expected to assign the *entire* current text on every update
+ * to `content`, not a delta -- this component does no accumulation or
+ * ordering of its own. That matches how most streaming-UI state (SSE/
+ * WebSocket token accumulation into a growing string in application state)
+ * is already managed.
+ *
+ * Token-by-token streaming can update `content` far faster than a human can
+ * usefully perceive a re-render -- dozens of times a second for a fast
+ * model. Re-rendering on every single assignment thrashes layout for no
+ * visible benefit, so updates funnel through `Announcer`
+ * (`../../internal/announcer.js`), reused here purely as the generic
+ * "coalesce rapid calls, flush the latest" timing primitive its own class
+ * doc says other components should reuse -- with none of its usual
+ * DOM/ARIA plumbing (that's `<lyra-live-region>`'s job, not this
+ * component's). Within any `coalesce-ms` window, only the *last* `content`
+ * value assigned actually reaches the rendered DOM. Two cases always bypass
+ * the throttle and flush immediately instead of waiting out the window: the
+ * very first `content` assignment after mount (so an already-complete
+ * message never shows an artificial startup delay), and any transition of
+ * `streaming` between `true` and `false` in either direction (so the final
+ * chunk of a finished stream can never be left stranded mid-window, and a
+ * stream restarting on a reused element can never keep showing the
+ * previous stream's stale final content for the length of the window).
+ *
+ * `markdown` is a tri-state property, not a plain boolean: left unset (the
+ * default), it auto-detects via a lightweight regex heuristic (see
+ * `looksLikeMarkdown`) run against whatever text is currently displayed --
+ * good enough to route obviously-Markdown output through `<lyra-markdown>`
+ * without the host needing to know or declare it up front, at the cost of
+ * an occasional one-time mode flip if Markdown syntax only appears partway
+ * through a stream. Explicitly setting `markdown` to `true`/`false` always
+ * wins over the heuristic. Rendering itself is never reimplemented here:
+ * Markdown mode composes `<lyra-markdown>` (`../markdown/markdown.js`)
+ * directly, forwarding this component's own `streaming` through as that
+ * component's own forward-compatible `streaming` hint prop; plain-text mode
+ * renders into a `white-space: pre-wrap` span instead.
+ *
+ * The blinking cursor (shown only while `streaming` is `true`) degrades to
+ * a static, always-visible bar under `prefers-reduced-motion: reduce`
+ * rather than disabling the animation into an invisible frozen frame --
+ * the same pattern `<lyra-typing-indicator>`'s own `cursor` variant uses. In
+ * plain-text mode the cursor sits inline at the tail of the final
+ * character, since the text is one continuous inline flow; in Markdown
+ * mode it renders as its own trailing block below the rendered content
+ * instead of attempting to splice into whatever nested block Markdown
+ * happens to end with (a paragraph, a table cell, a list item, a fenced
+ * code block, …) -- genuinely interleaving into arbitrary rendered Markdown
+ * without reaching across `<lyra-markdown>`'s own shadow boundary isn't a
+ * tractable general solution, so this component doesn't attempt it.
+ *
+ * Purely presentational: no events, driven entirely by its properties. It
+ * also doesn't announce anything to assistive tech itself -- a host that
+ * needs streamed text announced already has `<lyra-live-region>` for that
+ * (composed, for example, inside `<lyra-chat-message>`).
+ *
+ * @customElement lyra-streaming-text
+ * @csspart base - The root container.
+ * @csspart cursor - The blinking (or, under reduced motion, static) cursor bar. Only rendered while `streaming` is `true`.
+ */
+export class LyraStreamingText extends LyraElement {
+    static { this.styles = [LyraElement.styles, styles]; }
+    constructor() {
+        super();
+        /** The full current text so far -- always the complete string, never a
+         *  delta to append. */
+        this.content = '';
+        /** Shows the blinking cursor after the rendered text. Reflects, so a host
+         *  can also target `lyra-streaming-text[streaming]` in CSS. */
+        this.streaming = false;
+        /** Trailing-edge coalesce window, in ms, for `content` updates -- see the
+         *  class doc. */
+        this.coalesceMs = DEFAULT_COALESCE_MS;
+        // The coalesced value actually rendered -- lags `content` by up to
+        // `coalesceMs` (or zero, for the immediate-flush cases documented above).
+        this.displayedContent = '';
+        this.lastScannedResult = false;
+        // Built in the constructor (not a class-field initializer) so it reads
+        // `this.coalesceMs` only after that property's own field initializer has
+        // already run and set the declared default -- same ordering rationale as
+        // lyra-live-region's identical constructor-built Announcer.
+        this.coalescer = new Announcer({
+            throttleMs: this.coalesceMs,
+            onFlush: (text) => {
+                this.displayedContent = text;
+            },
+        });
+    }
+    willUpdate(changed) {
+        if (changed.has('coalesceMs')) {
+            this.coalescer.throttleMs = this.coalesceMs;
+        }
+        if (changed.has('content')) {
+            // The very first content assignment after mount always flushes
+            // immediately -- an already-complete message (or the first chunk of a
+            // new one) shouldn't show an artificial startup delay just because a
+            // coalescing window technically applies to it.
+            this.coalescer.announce(this.content, { force: !this.hasUpdated });
+        }
+        // Neither a stream finishing nor a stream (re)starting on a reused
+        // element may leave stale content stranded inside an in-progress
+        // coalescing window -- force whatever `content` currently holds through
+        // immediately in both directions. Without the restart side of this, a
+        // reused element would keep showing the *previous* stream's final
+        // content for up to a full coalesce-ms window after a new stream had
+        // already begun. `changed.get('streaming')` is only defined for a real
+        // transition (never the initial mount value, per Lit's documented
+        // first-change semantics), so this can't misfire on connect.
+        if (changed.has('streaming') &&
+            changed.get('streaming') !== undefined &&
+            changed.get('streaming') !== this.streaming) {
+            this.coalescer.announce(this.content, { force: true });
+        }
+        if (changed.has('displayedContent') && this.displayedContent !== this.lastScannedContent) {
+            this.lastScannedContent = this.displayedContent;
+            this.lastScannedResult = looksLikeMarkdown(this.displayedContent);
+        }
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.coalescer.cancel();
+    }
+    /** Whether Markdown mode is actually in effect right now, resolving the
+     *  tri-state `markdown` property against the memoized `looksLikeMarkdown`
+     *  result for the currently-displayed content (see `lastScannedContent`/
+     *  `lastScannedResult` above). */
+    get effectiveMarkdown() {
+        return this.markdown ?? this.lastScannedResult;
+    }
+    render() {
+        return html `
+      <div part="base">
+        ${this.effectiveMarkdown
+            ? html `<lyra-markdown .content=${this.displayedContent} .streaming=${this.streaming}></lyra-markdown>`
+            : html `<span class="plain">${this.displayedContent}</span>`}
+        ${this.streaming ? html `<span part="cursor" aria-hidden="true"></span>` : nothing}
+      </div>
+    `;
+    }
+}
+__decorate([
+    property()
+], LyraStreamingText.prototype, "content", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraStreamingText.prototype, "streaming", void 0);
+__decorate([
+    property({ type: Number, attribute: 'coalesce-ms' })
+], LyraStreamingText.prototype, "coalesceMs", void 0);
+__decorate([
+    property({ attribute: 'markdown', converter: optionalBooleanConverter })
+], LyraStreamingText.prototype, "markdown", void 0);
+__decorate([
+    state()
+], LyraStreamingText.prototype, "displayedContent", void 0);
+//# sourceMappingURL=streaming-text.class.js.map

package/dist/components/streaming-text/streaming-text.class.js.map

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

package/dist/components/streaming-text/streaming-text.d.ts

@@ -1,98 +1,3 @@
-import { type TemplateResult, type PropertyValues } from 'lit';
-import { LyraElement } from '../../internal/lyra-element.js';
-import '../markdown/markdown.js';
-/** Runs {@link MARKDOWN_PATTERNS} against `text`, used whenever `markdown`
- *  is left unset (auto-detect). Exported so the heuristic is directly
- *  testable without going through the component's render cycle. */
-export declare function looksLikeMarkdown(text: string): boolean;
-/**
- * `<lyra-streaming-text>` — a token-coalescing incremental text renderer for
- * streaming assistant output, with an optional blinking cursor and
- * auto-detected Markdown rendering.
- *
- * The host is expected to assign the *entire* current text on every update
- * to `content`, not a delta -- this component does no accumulation or
- * ordering of its own. That matches how most streaming-UI state (SSE/
- * WebSocket token accumulation into a growing string in application state)
- * is already managed.
- *
- * Token-by-token streaming can update `content` far faster than a human can
- * usefully perceive a re-render -- dozens of times a second for a fast
- * model. Re-rendering on every single assignment thrashes layout for no
- * visible benefit, so updates funnel through `Announcer`
- * (`../../internal/announcer.js`), reused here purely as the generic
- * "coalesce rapid calls, flush the latest" timing primitive its own class
- * doc says other components should reuse -- with none of its usual
- * DOM/ARIA plumbing (that's `<lyra-live-region>`'s job, not this
- * component's). Within any `coalesce-ms` window, only the *last* `content`
- * value assigned actually reaches the rendered DOM. Two cases always bypass
- * the throttle and flush immediately instead of waiting out the window: the
- * very first `content` assignment after mount (so an already-complete
- * message never shows an artificial startup delay), and any transition of
- * `streaming` from `true` to `false` (so the final chunk of a finished
- * stream can never be left stranded mid-window).
- *
- * `markdown` is a tri-state property, not a plain boolean: left unset (the
- * default), it auto-detects via a lightweight regex heuristic (see
- * `looksLikeMarkdown`) run against whatever text is currently displayed --
- * good enough to route obviously-Markdown output through `<lyra-markdown>`
- * without the host needing to know or declare it up front, at the cost of
- * an occasional one-time mode flip if Markdown syntax only appears partway
- * through a stream. Explicitly setting `markdown` to `true`/`false` always
- * wins over the heuristic. Rendering itself is never reimplemented here:
- * Markdown mode composes `<lyra-markdown>` (`../markdown/markdown.js`)
- * directly, forwarding this component's own `streaming` through as that
- * component's own forward-compatible `streaming` hint prop; plain-text mode
- * renders into a `white-space: pre-wrap` span instead.
- *
- * The blinking cursor (shown only while `streaming` is `true`) degrades to
- * a static, always-visible bar under `prefers-reduced-motion: reduce`
- * rather than disabling the animation into an invisible frozen frame --
- * the same pattern `<lyra-typing-indicator>`'s own `cursor` variant uses. In
- * plain-text mode the cursor sits inline at the tail of the final
- * character, since the text is one continuous inline flow; in Markdown
- * mode it renders as its own trailing block below the rendered content
- * instead of attempting to splice into whatever nested block Markdown
- * happens to end with (a paragraph, a table cell, a list item, a fenced
- * code block, …) -- genuinely interleaving into arbitrary rendered Markdown
- * without reaching across `<lyra-markdown>`'s own shadow boundary isn't a
- * tractable general solution, so this component doesn't attempt it.
- *
- * Purely presentational: no events, driven entirely by its properties. It
- * also doesn't announce anything to assistive tech itself -- a host that
- * needs streamed text announced already has `<lyra-live-region>` for that
- * (composed, for example, inside `<lyra-chat-message>`).
- *
- * @customElement lyra-streaming-text
- * @csspart base - The root container.
- * @csspart cursor - The blinking (or, under reduced motion, static) cursor bar. Only rendered while `streaming` is `true`.
- */
-export declare class LyraStreamingText extends LyraElement {
-    static styles: import("lit").CSSResultGroup[];
-    /** The full current text so far -- always the complete string, never a
-     *  delta to append. */
-    content: string;
-    /** Shows the blinking cursor after the rendered text. Reflects, so a host
-     *  can also target `lyra-streaming-text[streaming]` in CSS. */
-    streaming: boolean;
-    /** Trailing-edge coalesce window, in ms, for `content` updates -- see the
-     *  class doc. */
-    coalesceMs: number;
-    /** `undefined` (default) auto-detects via `looksLikeMarkdown`; `true`/
-     *  `false` force that rendering mode regardless of content. */
-    markdown?: boolean;
-    private displayedContent;
-    private readonly coalescer;
-    constructor();
-    protected willUpdate(changed: PropertyValues): void;
-    disconnectedCallback(): void;
-    /** Whether Markdown mode is actually in effect right now, resolving the
-     *  tri-state `markdown` property against `looksLikeMarkdown`. */
-    private get effectiveMarkdown();
-    render(): TemplateResult;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'lyra-streaming-text': LyraStreamingText;
-    }
-}
+export * from './streaming-text.class.js';
+import "../markdown/markdown.js";
+//# sourceMappingURL=streaming-text.d.ts.map

package/dist/components/streaming-text/streaming-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-text.d.ts","sourceRoot":"","sources":["../../../src/components/streaming-text/streaming-text.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAG1C,OAAO,yBAAyB,CAAC"}

package/dist/components/streaming-text/streaming-text.js

@@ -1,209 +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 } from 'lit';
-import { property, state } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './streaming-text.class.js';
+import { LyraStreamingText } from './streaming-text.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { Announcer } from '../../internal/announcer.js';
-import '../markdown/markdown.js';
-import { styles } from './streaming-text.styles.js';
-const DEFAULT_COALESCE_MS = 50;
-/**
- * Lightweight, deliberately-imperfect signals that the currently-displayed
- * text contains Markdown syntax worth routing through `<lyra-markdown>`
- * rather than a plain `white-space: pre-wrap` node. Checked in order against
- * the whole string; the first match short-circuits. None of these need to be
- * airtight -- a false positive just renders ordinary prose through
- * `<lyra-markdown>` (which renders plain prose fine); a false negative just
- * renders literal `**`/backticks/etc. as plain text until more of the stream
- * arrives.
- */
-const MARKDOWN_PATTERNS = [
-    /^ {0,3}#{1,6}\s+\S/m, // ATX heading: "# Heading"
-    /```/, // fenced code block
-    /\*\*[^*\n]+\*\*/, // **bold**
-    /(?:^|[^\w])_[^_\n]+_(?:[^\w]|$)/, // _italic_
-    /`[^`\n]+`/, // inline code
-    /^ {0,3}[-*+]\s+\S/m, // bullet list item
-    /^ {0,3}\d+\.\s+\S/m, // numbered list item
-    /\[[^\]]+\]\([^)\s]+\)/, // [text](url)
-    /^ {0,3}>\s?\S/m, // blockquote
-];
-/** Runs {@link MARKDOWN_PATTERNS} against `text`, used whenever `markdown`
- *  is left unset (auto-detect). Exported so the heuristic is directly
- *  testable without going through the component's render cycle. */
-export function looksLikeMarkdown(text) {
-    if (!text)
-        return false;
-    return MARKDOWN_PATTERNS.some((pattern) => pattern.test(text));
-}
-/**
- * Tri-state boolean attribute converter for `markdown`. Lit's built-in
- * `type: Boolean` converter is presence-based and can only ever represent
- * two states (attribute present -> `true`, absent -> `false`) -- there's no
- * way for it to also represent "not specified, auto-detect instead", which
- * is the actual default this property needs. `markdown` (no value, or
- * `="true"`) -> `true`; `markdown="false"` -> `false`; attribute entirely
- * absent -> `undefined`.
- */
-const optionalBooleanConverter = {
-    fromAttribute(value) {
-        if (value === null)
-            return undefined;
-        return value !== 'false';
-    },
-    toAttribute(value) {
-        if (value === undefined)
-            return null;
-        return value ? '' : 'false';
-    },
-};
-/**
- * `<lyra-streaming-text>` — a token-coalescing incremental text renderer for
- * streaming assistant output, with an optional blinking cursor and
- * auto-detected Markdown rendering.
- *
- * The host is expected to assign the *entire* current text on every update
- * to `content`, not a delta -- this component does no accumulation or
- * ordering of its own. That matches how most streaming-UI state (SSE/
- * WebSocket token accumulation into a growing string in application state)
- * is already managed.
- *
- * Token-by-token streaming can update `content` far faster than a human can
- * usefully perceive a re-render -- dozens of times a second for a fast
- * model. Re-rendering on every single assignment thrashes layout for no
- * visible benefit, so updates funnel through `Announcer`
- * (`../../internal/announcer.js`), reused here purely as the generic
- * "coalesce rapid calls, flush the latest" timing primitive its own class
- * doc says other components should reuse -- with none of its usual
- * DOM/ARIA plumbing (that's `<lyra-live-region>`'s job, not this
- * component's). Within any `coalesce-ms` window, only the *last* `content`
- * value assigned actually reaches the rendered DOM. Two cases always bypass
- * the throttle and flush immediately instead of waiting out the window: the
- * very first `content` assignment after mount (so an already-complete
- * message never shows an artificial startup delay), and any transition of
- * `streaming` from `true` to `false` (so the final chunk of a finished
- * stream can never be left stranded mid-window).
- *
- * `markdown` is a tri-state property, not a plain boolean: left unset (the
- * default), it auto-detects via a lightweight regex heuristic (see
- * `looksLikeMarkdown`) run against whatever text is currently displayed --
- * good enough to route obviously-Markdown output through `<lyra-markdown>`
- * without the host needing to know or declare it up front, at the cost of
- * an occasional one-time mode flip if Markdown syntax only appears partway
- * through a stream. Explicitly setting `markdown` to `true`/`false` always
- * wins over the heuristic. Rendering itself is never reimplemented here:
- * Markdown mode composes `<lyra-markdown>` (`../markdown/markdown.js`)
- * directly, forwarding this component's own `streaming` through as that
- * component's own forward-compatible `streaming` hint prop; plain-text mode
- * renders into a `white-space: pre-wrap` span instead.
- *
- * The blinking cursor (shown only while `streaming` is `true`) degrades to
- * a static, always-visible bar under `prefers-reduced-motion: reduce`
- * rather than disabling the animation into an invisible frozen frame --
- * the same pattern `<lyra-typing-indicator>`'s own `cursor` variant uses. In
- * plain-text mode the cursor sits inline at the tail of the final
- * character, since the text is one continuous inline flow; in Markdown
- * mode it renders as its own trailing block below the rendered content
- * instead of attempting to splice into whatever nested block Markdown
- * happens to end with (a paragraph, a table cell, a list item, a fenced
- * code block, …) -- genuinely interleaving into arbitrary rendered Markdown
- * without reaching across `<lyra-markdown>`'s own shadow boundary isn't a
- * tractable general solution, so this component doesn't attempt it.
- *
- * Purely presentational: no events, driven entirely by its properties. It
- * also doesn't announce anything to assistive tech itself -- a host that
- * needs streamed text announced already has `<lyra-live-region>` for that
- * (composed, for example, inside `<lyra-chat-message>`).
- *
- * @customElement lyra-streaming-text
- * @csspart base - The root container.
- * @csspart cursor - The blinking (or, under reduced motion, static) cursor bar. Only rendered while `streaming` is `true`.
- */
-export class LyraStreamingText extends LyraElement {
-    static { this.styles = [LyraElement.styles, styles]; }
-    constructor() {
-        super();
-        /** The full current text so far -- always the complete string, never a
-         *  delta to append. */
-        this.content = '';
-        /** Shows the blinking cursor after the rendered text. Reflects, so a host
-         *  can also target `lyra-streaming-text[streaming]` in CSS. */
-        this.streaming = false;
-        /** Trailing-edge coalesce window, in ms, for `content` updates -- see the
-         *  class doc. */
-        this.coalesceMs = DEFAULT_COALESCE_MS;
-        // The coalesced value actually rendered -- lags `content` by up to
-        // `coalesceMs` (or zero, for the immediate-flush cases documented above).
-        this.displayedContent = '';
-        // Built in the constructor (not a class-field initializer) so it reads
-        // `this.coalesceMs` only after that property's own field initializer has
-        // already run and set the declared default -- same ordering rationale as
-        // lyra-live-region's identical constructor-built Announcer.
-        this.coalescer = new Announcer({
-            throttleMs: this.coalesceMs,
-            onFlush: (text) => {
-                this.displayedContent = text;
-            },
-        });
-    }
-    willUpdate(changed) {
-        if (changed.has('coalesceMs')) {
-            this.coalescer.throttleMs = this.coalesceMs;
-        }
-        if (changed.has('content')) {
-            // The very first content assignment after mount always flushes
-            // immediately -- an already-complete message (or the first chunk of a
-            // new one) shouldn't show an artificial startup delay just because a
-            // coalescing window technically applies to it.
-            this.coalescer.announce(this.content, { force: !this.hasUpdated });
-        }
-        // A stream finishing must never leave its final chunk stranded inside an
-        // in-progress coalescing window -- force whatever `content` currently
-        // holds through immediately. `changed.get('streaming')` is only defined
-        // for a real transition (never the initial mount value, per Lit's
-        // documented first-change semantics), so this can't misfire on connect.
-        if (changed.has('streaming') && changed.get('streaming') === true && !this.streaming) {
-            this.coalescer.announce(this.content, { force: true });
-        }
-    }
-    disconnectedCallback() {
-        super.disconnectedCallback();
-        this.coalescer.cancel();
-    }
-    /** Whether Markdown mode is actually in effect right now, resolving the
-     *  tri-state `markdown` property against `looksLikeMarkdown`. */
-    get effectiveMarkdown() {
-        return this.markdown ?? looksLikeMarkdown(this.displayedContent);
-    }
-    render() {
-        return html `
-      <div part="base">
-        ${this.effectiveMarkdown
-            ? html `<lyra-markdown .content=${this.displayedContent} .streaming=${this.streaming}></lyra-markdown>`
-            : html `<span class="plain">${this.displayedContent}</span>`}
-        ${this.streaming ? html `<span part="cursor" aria-hidden="true"></span>` : nothing}
-      </div>
-    `;
-    }
-}
-__decorate([
-    property()
-], LyraStreamingText.prototype, "content", void 0);
-__decorate([
-    property({ type: Boolean, reflect: true })
-], LyraStreamingText.prototype, "streaming", void 0);
-__decorate([
-    property({ type: Number, attribute: 'coalesce-ms' })
-], LyraStreamingText.prototype, "coalesceMs", void 0);
-__decorate([
-    property({ attribute: 'markdown', converter: optionalBooleanConverter })
-], LyraStreamingText.prototype, "markdown", void 0);
-__decorate([
-    state()
-], LyraStreamingText.prototype, "displayedContent", void 0);
+import "../markdown/markdown.js";
 defineElement('streaming-text', LyraStreamingText);
+//# sourceMappingURL=streaming-text.js.map