@aceshooting/lyra-ui 3.8.0 → 3.9.0

package/dist/components/markdown/markdown-core.class.d.ts

@@ -0,0 +1,334 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { type LyraAnchorTargetEventMap } from '../../internal/anchor-target.js';
+import type { LyraAnchor, LyraAnchorKind } from '../document-viewer/anchors.js';
+import { type ShikiLanguageInput } from '../code-block/code-loader.js';
+/** One entry of `getHeadingTree()`'s document-ordered outline. `level` already reflects
+ *  `heading-offset` -- it always matches the rendered `<h${level}>` tag, not the source `#` count. */
+export interface MarkdownHeadingItem {
+    id: string;
+    label: string;
+    level: number;
+}
+export interface LyraMarkdownCoreEventMap extends LyraAnchorTargetEventMap {
+    'lyra-render-error': CustomEvent<{
+        error: unknown;
+    }>;
+    'lyra-link-click': CustomEvent<{
+        href: string;
+        internal: boolean;
+    }>;
+}
+declare class LyraMarkdownCoreBase extends LyraElement<LyraMarkdownCoreEventMap> {
+}
+declare const LyraMarkdownCore_base: typeof LyraMarkdownCoreBase & (new (...args: any[]) => import("../../internal/anchor-target.js").LyraAnchorTarget & {
+    renderAnchorLiveRegion(): unknown;
+});
+/**
+ * `<lyra-markdown-core>` — a build-lean variant of `<lyra-markdown>` for a consumer whose
+ * `languages` map already covers every language it will ever render. Every other capability (GFM
+ * tables, fenced code blocks, links, blockquotes, heading anchors, text-quote highlights, math) is
+ * identical to `<lyra-markdown>` -- only fenced-code-block highlighting differs: this component's
+ * own module never textually contains a call to (or import of) `loadShikiHighlighter` (the
+ * ~200-language default dynamic-import table `<lyra-markdown>` calls unconditionally unless its
+ * *runtime* `languagesOnly` flag is `true` -- a flag on that same module a bundler can't prove
+ * always-true, so the unconditional call stays in the build output regardless). A consumer
+ * importing this entry point instead of `markdown.js` gets a genuinely shiki-full-table-free
+ * build. A fenced block whose language isn't a key in `languages` always renders the plain-text
+ * fallback -- there is no default/full-table highlighter here to fall back to, mirroring
+ * `<lyra-code-block-core>`'s identical contract for the sibling component.
+ *
+ * Built on the optional peer dependencies `marked` (parsing) and `dompurify` (sanitizing), both
+ * lazy-loaded via `markdown-loader.ts` on first connect.
+ *
+ * Rendering never ships unsanitized or broken markup silently:
+ * - If `marked` fails to load, or throws while parsing malformed input, the
+ *   component falls back to plain text (`white-space: pre-wrap`, no HTML
+ *   parsing at all) and fires `lyra-render-error`.
+ * - If `sanitize` is `true` (the default) and `dompurify` fails to load, the
+ *   component *also* falls back to plain text + `lyra-render-error` — it
+ *   never renders marked's raw HTML output when sanitization was requested
+ *   (or defaulted to) but is unavailable, even though `marked` itself loaded
+ *   fine.
+ * - If `sanitize` is explicitly `false`, marked's raw output renders as-is
+ *   regardless of whether `dompurify` is installed — the consumer opted out
+ *   of sanitization, so `dompurify`'s absence is irrelevant to that path.
+ *
+ * That same plain-text fallback rendering (`data-fallback` on the `content`
+ * part) is also, unconditionally and by default, a brief *transient* state on
+ * every connect, not just a failure path: `connectedCallback()`'s dynamic
+ * `import()` of `marked`/`dompurify` (see `markdown-loader.ts`) is
+ * asynchronous, so the very first paint of any `<lyra-markdown>` on a page
+ * shows plain text for at least one microtask — even when both peers are
+ * already installed and load without error — until that import resolves and
+ * a second render replaces it with the real Markdown output. Set
+ * `eager-load` to skip that window once the shared dependency cache is
+ * already warm; see that property's doc for exactly what "warm" requires.
+ *
+ * `heading`/`code`/`blockquote`/`table`/`link`/`image` tokens are rendered
+ * through a `marked` renderer override that injects `part="..."` attributes
+ * directly into the produced HTML — a single pass, not a second DOM walk
+ * after insertion.
+ *
+ * Fenced code blocks are syntax-highlighted via the same fine-grained `shiki/core` recipe
+ * `<lyra-code-block-core>` uses (`highlightCode`, default `true` — gated by whether a fenced
+ * block's language is a key in `languages`, since there is no default highlighter here to gate on
+ * "is shiki installed at all"). The very first render of any content is always plain (identical to
+ * `<lyra-markdown>`'s own output); highlighting arrives as an asynchronous upgrade one render
+ * later, once the fine-grained highlighter resolves. No highlighting is attempted while
+ * `streaming` is `true` — it applies once a stream settles, so there is no added per-chunk cost
+ * while content is still arriving.
+ *
+ * When `heading-anchors` is set, every rendered heading's slug (computed via the shared
+ * GitHub-slugger-style `Slugger`) is stamped as its `id`; `getHeadingTree()` computes that same
+ * outline on every parse regardless of `heading-anchors`, so a host can build a table of contents
+ * even while ids aren't in the DOM yet. `scrollToAnchor()` (from the adopted `DocumentAnchorTarget`
+ * mixin) resolves `fragment` anchors against that outline and `text-quote` anchors via
+ * `internal/text-quote.ts`'s shared scope/resolve helpers; `highlights` re-resolve by quote after
+ * every render (never by node identity), so a highlight painted before a `streaming` update
+ * finishes still finds its quote once the matching text arrives. Highlight painting uses
+ * `internal/text-highlights.ts`'s `acquireHighlightHandle()` -- the CSS Custom Highlight API where
+ * the browser supports it (no DOM mutation at all), a `<mark>`-wrap fallback otherwise.
+ *
+ * `math` renders `$...$`/`$$...$$` TeX as MathML via the optional `katex` peer's
+ * `renderToString(tex, { output: 'mathml' })` -- MathML Core renders natively and accessibly in
+ * evergreen browsers with no extra stylesheet or webfont needing to cross the shadow boundary. A
+ * missing `katex` peer renders the literal, unparsed TeX source (delimiters included) and fires one
+ * `lyra-render-error`.
+ *
+ * @customElement lyra-markdown-core
+ * @event lyra-link-click - Fired (and the click prevented) when a rendered
+ *   link's `href` starts with `internal-link-prefix`. `detail: { href:
+ *   string, internal: true }`. Ordinary external links navigate normally
+ *   (in `link-target`) and never fire this event.
+ * @event lyra-render-error - Fired whenever rendering falls back to plain
+ *   text, or `math` is set but the `katex` peer isn't installed. `detail: { error: unknown }`.
+ * @event lyra-highlight-activate - A painted `text-quote` highlight was clicked. `detail: { id }`.
+ * @event lyra-text-select - Fired on selection end inside the rendered content. `detail: { text,
+ *   anchor, rects }`; `anchor` is a `text-quote` `LyraAnchor` scoped to the rendered content, or
+ *   `null` if the selection couldn't be anchored.
+ * @event lyra-anchor-result - Fired after an `anchor` property assignment or a `scrollToAnchor()`
+ *   call is applied. `detail: { found }`.
+ * @csspart content - The wrapper around the rendered (or plain-text
+ *   fallback) output.
+ * @csspart heading - Every rendered `<h1>`–`<h6>` (shifted by
+ *   `heading-offset`).
+ * @csspart paragraph - Every rendered `<p>`.
+ * @csspart list - Every rendered `<ul>`/`<ol>`.
+ * @csspart code-block - Every rendered fenced/indented `<pre>`.
+ * @csspart inline-code - Every rendered inline `<code>` span (backtick spans, not fenced blocks).
+ * @csspart link - Every rendered `<a>`.
+ * @csspart table - Every rendered `<table>`.
+ * @csspart blockquote - Every rendered `<blockquote>`.
+ * @csspart img - Every rendered `<img>`.
+ * @csspart math - A rendered inline or block math span (`data-display="inline"|"block"`).
+ */
+export declare class LyraMarkdownCore extends LyraMarkdownCore_base {
+    static styles: import("lit").CSSResultGroup[];
+    /** The Markdown source to render. */
+    content: string;
+    /** Sanitize marked's HTML output with DOMPurify before rendering. See the
+     *  class doc for what happens when this is `true` (the default) but the
+     *  `dompurify` peer isn't installed. */
+    sanitize: boolean;
+    /** When `true`, overrides marked's `html` renderer hook to emit the HTML-escaped source text
+     *  instead of passing raw/sanitized markup through -- for a consumer rendering arbitrary
+     *  already-written content (e.g. a historical chat/agent transcript full of code/XML/HTML
+     *  snippets) where a stray angle bracket should render as visible text, not a real DOM element.
+     *  Still lets GFM tables/lists/etc. render normally -- only raw embedded HTML is affected.
+     *  `false` (the default) reproduces today's exact `marked`-default (sanitized-when-`sanitize`)
+     *  passthrough behavior. */
+    escapeHtml: boolean;
+    /** Enable GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists). */
+    gfm: boolean;
+    /** `target` applied to every rendered `<a>`, with `rel="noopener
+     *  noreferrer"` always added alongside it whenever a `target` is emitted.
+     *  `'_blank'` (the default) preserves today's exact output. Set to `null`
+     *  (or the empty string, e.g. via the `link-target=""` attribute) to omit
+     *  `target`/`rel` entirely, so rendered links open in the same tab. */
+    linkTarget: string | null;
+    /** When set, a rendered link whose `href` starts with this prefix is
+     *  treated as internal — its click is intercepted and reported via
+     *  `lyra-link-click` instead of navigating. Empty (the default) means
+     *  every link is treated as external. */
+    internalLinkPrefix: string;
+    /** Added to every rendered heading's source `token.depth` before emitting
+     *  `<h${depth}>` — e.g. `heading-offset="2"` renders a source `#` as
+     *  `<h3>` and a source `##` as `<h4>`. The result is clamped to `[1, 6]`
+     *  (a source `######` with a positive offset stays at `<h6>` rather than
+     *  overflowing past the HTML heading levels; the floor at `1` is
+     *  defensive, since this property is meant to be additive-only). `0`
+     *  (the default) preserves today's exact `<h${token.depth}>` output. */
+    headingOffset: number;
+    /** When `true`, `connectedCallback()` skips awaiting `loadMarkdownDeps()`'s
+     *  dynamic `import()` if the shared `marked`/`dompurify` module cache (see
+     *  `markdown-loader.ts`'s `getMarkdownDepsIfLoaded()`) has *already*
+     *  resolved — e.g. because an earlier `<lyra-markdown>` instance on the
+     *  page already finished loading, or the consumer primed the cache
+     *  directly by calling `loadMarkdownDeps()` themselves at startup — and
+     *  renders synchronously instead. When the cache isn't warm yet (most
+     *  notably: the very first `<lyra-markdown>` ever connected on a page,
+     *  since nothing has called `loadMarkdownDeps()` before it), this still
+     *  falls back to the normal async path — a dynamic `import()` can't be
+     *  made synchronous, so this is a fast path for the common "already warm"
+     *  case, not a hard guarantee. `false` (the default) is byte-identical to
+     *  today: always the async `import()`, fallback-text window included. */
+    eagerLoad: boolean;
+    /** Signals that `content` is still arriving incrementally. Content changes
+     *  continue to render immediately; while this is `true`, the host remains
+     *  `aria-busy="true"` so assistive technology knows the rendered document
+     *  is not final. Set it back to `false` with the final content update.
+     *  Reflects so a consumer can also target `lyra-markdown[streaming]`. */
+    streaming: boolean;
+    /** Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lyra-code-block>`
+     *  uses. `true` (the default) upgrades every fenced block from plain `<pre><code>` once the peer
+     *  is available -- a pure upgrade, not a behavior change gated on opt-in, since it's itself gated
+     *  transparently by whether `shiki` is installed at all (an app that never installs it sees
+     *  byte-identical output to today). Set `false` to keep plain output even when `shiki` is
+     *  installed. No effect while `streaming` is `true` -- see that property's own doc. */
+    highlightCode: boolean;
+    /** Grammar definitions this instance can highlight, e.g. `{ json: jsonGrammar }` (import from
+     *  `shiki/langs/<name>.mjs`), forwarded verbatim to `loadShikiHighlighterCore()` -- same shape as
+     *  `<lyra-code-block-core>`'s own `languages`. This component has no default/full-table
+     *  highlighter to fall back to -- a fenced block whose language isn't a key here always renders
+     *  the plain-text fallback. Empty (the default) never highlights anything. */
+    languages: Record<string, ShikiLanguageInput>;
+    /** Stamps a computed slug as `id` on every rendered heading. `getHeadingTree()` computes the
+     *  same slugs regardless of this property -- it only controls whether the `id` attribute is
+     *  emitted into the rendered DOM. `false` (the default) preserves today's exact output.
+     *
+     *  When `sanitize` is also on (the default), a slug whose *value* collides with a real
+     *  `document` property name (e.g. a heading literally titled "Title", "Location", or "Forms"
+     *  slugs to `title`/`location`/`forms`) has its `id` silently stripped by DOMPurify's DOM-
+     *  clobbering protection (`SANITIZE_DOM`) -- `getHeadingTree()` still reports that heading's slug
+     *  either way, but `scrollToAnchor({ kind: 'fragment', id })` still resolves it correctly even
+     *  without a DOM `id` present, via its own position-based fallback lookup. */
+    headingAnchors: boolean;
+    /** Renders `$...$`/`$$...$$` TeX via the optional `katex` peer, as MathML. `false` (the
+     *  default) renders `$...$` literally, unparsed -- today's exact output. */
+    math: boolean;
+    /** Anchor kinds this component resolves via `scrollToAnchor()`. Readonly. */
+    readonly anchorKinds: readonly LyraAnchorKind[];
+    private renderedHtml;
+    private deps?;
+    /** Document-ordered heading outline computed on every parse (see `getHeadingTree()`), regardless
+     *  of `headingAnchors`. */
+    private headingTree;
+    /** Lazily acquired the first time a highlight needs painting; released on disconnect. */
+    private highlightHandle?;
+    /** The most recently resolved `text-quote` highlight ranges, kept for `onContentClick()`'s
+     *  coordinate hit-test -- the CSS Custom Highlight API paints ranges without creating any DOM
+     *  element to attach a click listener to, so activation is resolved by comparing the click point
+     *  against each range's own `getClientRects()` instead, uniformly across both paint paths. */
+    private resolvedHighlightRanges;
+    /** Guards `lyra-render-error` so a permanently-missing `katex` peer reports once per instance,
+     *  not on every subsequent re-render while `math` stays on. Reset whenever `math` toggles. */
+    private mathFailureReported;
+    /** `(lang, code)` -> already-highlighted HTML, content-addressed (see `PendingHighlight`'s doc).
+     *  Persists across renders of this instance; populated asynchronously by `highlightPending()`.
+     *  Never consulted while `streaming` is `true` or `highlightCode` is `false` -- both gates live
+     *  in the `code()` renderer inside `parseMarkdown()`. Bounded to {@link HIGHLIGHT_CACHE_MAX}
+     *  entries, least-recently-used first out, via `getCachedHighlight()`/`setCachedHighlight()` --
+     *  always go through those instead of the map directly so hits refresh recency. */
+    private highlightCache;
+    /** LRU read: a hit is re-inserted so Map iteration order (insertion order) keeps the first key
+     *  the least recently used one -- the entry `setCachedHighlight()` evicts when full. */
+    private getCachedHighlight;
+    private setCachedHighlight;
+    /** Bumped on every `highlightPending()` call, including ones that end up not actually loading
+     *  anything -- guards against a newer `content`/`streaming` change superseding an older in-flight
+     *  highlight, exactly mirroring `<lyra-code-block>`'s own `highlightToken` field for the identical
+     *  race (an async grammar load resolving after a newer call already produced correct output). */
+    private highlightToken;
+    /** Keys from `PendingHighlight` that failed to highlight -- peer missing, language unrecognized,
+     *  or tokenization threw. Once a key lands here, `code()` stops re-discovering it as pending on
+     *  every future render. Without this, a permanently-unhighlightable block (e.g. an unrecognized
+     *  language) would never get cached, so every `renderMarkdown()` pass -- including the one
+     *  `highlightPending()` itself triggers on completion -- would rediscover it as pending and retry
+     *  it again, forever. Mirrors `code-loader.ts`'s own `unsupportedLanguages` Set, which exists for
+     *  the identical reason one level down (a single unrecognized `language` value on
+     *  `<lyra-code-block>`). */
+    private failedHighlightKeys;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Binds selection -> `lyra-text-select` once, on the stable `[part="content"]` wrapper --
+     *  re-renders only replace that wrapper's children via `unsafeHTML`, never the wrapper itself.
+     *  `bindTextSelection` is `protected` on the mixin's own narrowed return type (deliberately not
+     *  part of `LyraAnchorTarget`'s public surface -- see `anchor-target.ts`'s class doc), so it's
+     *  reached the same way that module's own tests do: through a cast, without declaring a no-op
+     *  passthrough override just to satisfy the type checker. */
+    protected firstUpdated(): void;
+    protected willUpdate(changed: PropertyValues): void;
+    protected updated(changed: PropertyValues): void;
+    private renderMarkdown;
+    private applyFallback;
+    /** Kicks off the shared `katex` load the first time `math` needs it and no attempt is already
+     *  in flight (module-scoped, so every `<lyra-markdown>` instance on the page shares one load --
+     *  mirrors `markdown-loader.ts`'s own warm-cache shape). Skipped entirely under
+     *  `__setKatexForTesting()` -- that seam controls math-rendering behavior directly and must never
+     *  race a real, unmocked `import('katex')` settling underneath it. */
+    private maybeLoadKatex;
+    /** Fires `lyra-render-error` once per instance for a permanently-missing `katex` peer. Called
+     *  only once `renderMarkdown()` has confirmed the peer is actually missing (`katexOverride` or
+     *  the resolved module is `null`) -- a math token rendering its literal fallback while the load
+     *  is merely still in flight (the same one-microtask transient window every other optional peer
+     *  in this component has) never reports an error on its own. */
+    private reportMathFailure;
+    /** Kicks off async highlighting for `pendingKeys` (see `highlightPending()`) unless there's
+     *  nothing to do, `highlightCode` is off, or `streaming` is on -- called from both of
+     *  `renderMarkdown()`'s exit points (the `sanitize=false` early return and the normal sanitized
+     *  path), since highlighting is independent of that decision. */
+    private maybeHighlightPending;
+    /** Loads whatever shiki grammars `pendingKeys` need, tokenizes each pending block concurrently,
+     *  populates `highlightCache` with the results, then triggers one more `renderMarkdown()` pass so
+     *  the newly-cached entries actually reach the screen. A pending key whose language isn't a key in
+     *  `languages`, or otherwise fails to tokenize, is recorded in `failedHighlightKeys` -- it stays
+     *  uncached, so `code()` keeps emitting its plain fallback for it on every future render, and
+     *  `code()` also stops re-discovering it as pending (see `failedHighlightKeys`'s own doc for why
+     *  that matters: without it, the `renderMarkdown()` call at the end of this method would
+     *  rediscover the same permanently-uncacheable key as pending on every pass, forever). Does not
+     *  block or delay any other pending key -- each is tried independently via `Promise.all`. */
+    private highlightPending;
+    private parseMarkdown;
+    /** A document-ordered, flattened heading outline -- computed on every parse regardless of
+     *  `headingAnchors` (see that property's own doc). A caller building a table of contents can rely
+     *  on this even while `heading-anchors` is off. */
+    getHeadingTree(): MarkdownHeadingItem[];
+    private contentRoot;
+    protected applyAnchor(anchor: LyraAnchor): Promise<boolean>;
+    private applyFragmentAnchor;
+    /** `headingAnchors` may be off, so a target heading might carry no `id` attribute in the DOM --
+     *  re-derives the same slug order `getHeadingTree()` was built in and matches by position
+     *  instead of by attribute. */
+    private findHeadingByComputedId;
+    private applyTextQuoteAnchor;
+    /** Overrides `DocumentAnchorTarget`'s default (whole render-root) selection scope, matching
+     *  `heading`'s slug computation and `applyTextQuoteAnchor()` above: only `[part="content"]` is a
+     *  meaningful text-quote scope, so a selection that somehow reaches outside it (there is no other
+     *  text in this component's shadow tree today, but the live region could grow one) never leaks
+     *  into a captured anchor. */
+    protected computeSelectionAnchor(range: Range): LyraAnchor | null;
+    private ensureHighlightHandle;
+    /** Re-resolves every `text-quote` highlight against the current rendered content and repaints
+     *  via `acquireHighlightHandle()` -- resolution is always by quote text, never by node identity,
+     *  so a highlight set before its quote exists in `content` yet (e.g. mid-`streaming`) simply
+     *  paints nothing until a later render's text actually contains it. `fragment` highlights aren't
+     *  painted (there is no literal span of text to wrap/underline for a whole section). */
+    private repaintHighlights;
+    /** Hit-tests a click point against every currently-resolved highlight's `getClientRects()`,
+     *  topmost (last-resolved) first. The CSS Custom Highlight API paints ranges without creating any
+     *  DOM element to attach a click listener to, so this is the only activation path that works
+     *  identically on both paint paths -- mirrors `<lyra-pdf-viewer>`'s own coordinate-based
+     *  `onPageClick()` hit-test for the same reason (its own painted highlights sit under a text
+     *  layer that intercepts most pointer events). */
+    private hitTestHighlightAt;
+    private onContentClick;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-markdown-core': LyraMarkdownCore;
+    }
+}
+export {};
+//# sourceMappingURL=markdown-core.class.d.ts.map

package/dist/components/markdown/markdown-core.class.d.ts.map

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