svelte-highlight 7.21.1 → 7.22.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (58) hide show
  1. package/CodeWindow.svelte +35 -11
  2. package/CodeWindow.svelte.d.ts +7 -1
  3. package/LangTag.svelte +4 -0
  4. package/LineNumbers.svelte +1 -0
  5. package/MarkdownStream.svelte +202 -0
  6. package/MarkdownStream.svelte.d.ts +100 -0
  7. package/README.md +156 -2
  8. package/index.d.ts +1 -0
  9. package/index.js +1 -0
  10. package/languages/aliases.js +1 -1
  11. package/languages/all.js +23 -1
  12. package/languages/alloy.d.ts +2 -0
  13. package/languages/alloy.js +2 -0
  14. package/languages/asymptote.d.ts +2 -0
  15. package/languages/asymptote.js +2 -0
  16. package/languages/blockdiag.d.ts +2 -0
  17. package/languages/blockdiag.js +2 -0
  18. package/languages/bsv.d.ts +2 -0
  19. package/languages/bsv.js +2 -0
  20. package/languages/casbin.d.ts +2 -0
  21. package/languages/casbin.js +2 -0
  22. package/languages/choicescript.d.ts +2 -0
  23. package/languages/choicescript.js +2 -0
  24. package/languages/dafny.d.ts +2 -0
  25. package/languages/dafny.js +2 -0
  26. package/languages/dbml.d.ts +2 -0
  27. package/languages/dbml.js +2 -0
  28. package/languages/dialog.d.ts +2 -0
  29. package/languages/dialog.js +2 -0
  30. package/languages/fstar.d.ts +2 -0
  31. package/languages/fstar.js +2 -0
  32. package/languages/gnuplot.d.ts +2 -0
  33. package/languages/gnuplot.js +2 -0
  34. package/languages/harlowe.d.ts +2 -0
  35. package/languages/harlowe.js +2 -0
  36. package/languages/index.d.ts +44 -0
  37. package/languages/index.js +22 -0
  38. package/languages/likec4.d.ts +2 -0
  39. package/languages/likec4.js +2 -0
  40. package/languages/nextflow.d.ts +2 -0
  41. package/languages/nextflow.js +2 -0
  42. package/languages/nomnoml.d.ts +2 -0
  43. package/languages/nomnoml.js +2 -0
  44. package/languages/openfga.d.ts +2 -0
  45. package/languages/openfga.js +2 -0
  46. package/languages/pikchr.d.ts +2 -0
  47. package/languages/pikchr.js +2 -0
  48. package/languages/spade.d.ts +2 -0
  49. package/languages/spade.js +2 -0
  50. package/languages/spicedb.d.ts +2 -0
  51. package/languages/spicedb.js +2 -0
  52. package/languages/tlaplus.d.ts +2 -0
  53. package/languages/tlaplus.js +2 -0
  54. package/languages/veryl.d.ts +2 -0
  55. package/languages/veryl.js +2 -0
  56. package/languages/wdl.d.ts +2 -0
  57. package/languages/wdl.js +2 -0
  58. package/package.json +1 -1
package/CodeWindow.svelte CHANGED
@@ -9,17 +9,29 @@
9
9
  <div class="code-window {variant}" {...$$restProps}>
10
10
  <div class="titlebar">
11
11
  {#if variant === "macos"}
12
- <span class="dots" aria-hidden="true">
13
- <span class="dot close"></span>
14
- <span class="dot minimize"></span>
15
- <span class="dot maximize"></span>
12
+ <span class="titlebar-lead">
13
+ <span class="dots" aria-hidden="true">
14
+ <span class="dot close"></span>
15
+ <span class="dot minimize"></span>
16
+ <span class="dot maximize"></span>
17
+ </span>
16
18
  </span>
17
19
  {:else if variant === "terminal"}
18
- <span class="prompt" aria-hidden="true">&gt;_</span>
20
+ <span class="titlebar-lead">
21
+ <span class="prompt" aria-hidden="true">&gt;_</span>
22
+ </span>
19
23
  {/if}
20
24
 
21
25
  {#if title}
22
- <span class="title">{title}</span>
26
+ <span class="title" {title}>{title}</span>
27
+ {/if}
28
+
29
+ {#if variant !== "plain"}
30
+ <!-- titlebar content wider than the leading chrome will unbalance the
31
+ centering above -- an accepted trade-off, not a bug. -->
32
+ <span class="titlebar-end"><slot name="titlebar" /></span>
33
+ {:else}
34
+ <slot name="titlebar" />
23
35
  {/if}
24
36
  </div>
25
37
 
@@ -84,12 +96,24 @@
84
96
  color: var(--prompt-color, inherit);
85
97
  }
86
98
 
99
+ .titlebar-lead,
100
+ .titlebar-end {
101
+ display: flex;
102
+ align-items: center;
103
+ flex: 1 1 0;
104
+ min-width: 0;
105
+ }
106
+
107
+ .titlebar-end {
108
+ justify-content: flex-end;
109
+ }
110
+
87
111
  .title {
88
- /* Center title across titlebar, ignoring dots/prompt. */
89
- position: absolute;
90
- left: 50%;
91
- transform: translateX(-50%);
92
- max-width: 70%;
112
+ /* Sandwiched between equal-width .titlebar-lead/.titlebar-end, so it
113
+ centers in the space actually left over instead of the full bar. */
114
+ flex: 1 1 0;
115
+ min-width: 0;
116
+ text-align: center;
93
117
  overflow: hidden;
94
118
  white-space: nowrap;
95
119
  text-overflow: ellipsis;
@@ -9,7 +9,8 @@ export type CodeWindowProps = HTMLAttributes<HTMLDivElement> & {
9
9
  variant?: "macos" | "terminal" | "plain";
10
10
 
11
11
  /**
12
- * Title bar text.
12
+ * Title bar text. Also becomes the title bar's native HTML `title`
13
+ * attribute, so a truncated title is readable as a hover/focus tooltip.
13
14
  * @default ""
14
15
  */
15
16
  title?: string;
@@ -127,6 +128,11 @@ export type CodeWindowEvents = {};
127
128
 
128
129
  export type CodeWindowSlots = {
129
130
  default: {};
131
+
132
+ /**
133
+ * Optional content rendered in the mirrored trailing region of the title bar.
134
+ */
135
+ titlebar: {};
130
136
  };
131
137
 
132
138
  export default class CodeWindow extends SvelteComponentTyped<
package/LangTag.svelte CHANGED
@@ -32,4 +32,8 @@
32
32
 
33
33
  <style>
34
34
  @import "./langtag.css";
35
+
36
+ pre {
37
+ direction: ltr;
38
+ }
35
39
  </style>
@@ -140,6 +140,7 @@
140
140
 
141
141
  pre {
142
142
  margin: 0;
143
+ direction: ltr;
143
144
  }
144
145
 
145
146
  table,
@@ -0,0 +1,202 @@
1
+ <script>
2
+ /**
3
+ * Growing Markdown buffer. On change, `splitter.append` is used when the
4
+ * new value starts with the previous one; otherwise the whole buffer is
5
+ * replaced via `splitter.set`.
6
+ * @type {string}
7
+ */
8
+ export let text = "";
9
+
10
+ /**
11
+ * Stream finished: forwarded to every fence's `HighlightStream` as
12
+ * `done || !segment.open`.
13
+ * @type {boolean}
14
+ */
15
+ export let done = false;
16
+
17
+ /**
18
+ * Resolves a fence's language. Cached per canonical name for the
19
+ * component's lifetime.
20
+ * @type {(lang: string | undefined, segment: import("./fence.d.ts").FenceSegment) => import("./languages").LanguageType<string> | Promise<import("./languages").LanguageType<string>> | undefined}
21
+ */
22
+ export let resolveLanguage = defaultResolveLanguage;
23
+
24
+ /** @type {boolean} */
25
+ export let caret = true;
26
+
27
+ /** @type {boolean} */
28
+ export let autoScroll = true;
29
+
30
+ /**
31
+ * Announced once, by the last fence only, when `done` becomes `true`.
32
+ * @type {string}
33
+ */
34
+ export let doneText = "Code finished streaming";
35
+
36
+ import { createEventDispatcher } from "svelte";
37
+ import { createFenceSplitter } from "./fence.js";
38
+ import HighlightStream from "./HighlightStream.svelte";
39
+ import plaintext from "./languages/plaintext.js";
40
+ import { loadLanguage } from "./load-language.js";
41
+
42
+ /**
43
+ * @param {string | undefined} lang
44
+ * @returns {Promise<import("./languages").LanguageType<string> | undefined>}
45
+ */
46
+ async function defaultResolveLanguage(lang) {
47
+ if (!lang) return undefined;
48
+ try {
49
+ return await loadLanguage(
50
+ /** @type {import("./languages").LanguageName} */ (lang),
51
+ );
52
+ } catch {
53
+ return undefined;
54
+ }
55
+ }
56
+
57
+ const dispatch = createEventDispatcher();
58
+ const splitter = createFenceSplitter();
59
+
60
+ let previousText = "";
61
+ /** @type {readonly import("./fence.d.ts").MarkdownSegment[]} */
62
+ let segments = splitter.segments();
63
+
64
+ // Fence ids already reported via the `fence` event -- an id is only ever
65
+ // seen once, even if the splitter later rebuilds the segment object (a
66
+ // regenerated buffer keeps the id per the splitter's contract).
67
+ /** @type {Set<number>} */
68
+ const seenFenceIds = new Set();
69
+
70
+ // Resolved languages by canonical name, plus in-flight names so a second
71
+ // fence sharing a language doesn't re-invoke `resolveLanguage`.
72
+ /** @type {Record<string, import("./languages").LanguageType<string>>} */
73
+ let resolvedLanguages = {};
74
+ /** @type {Set<string>} */
75
+ const pendingLanguages = new Set();
76
+
77
+ /** @param {string | undefined} lang */
78
+ function cacheKey(lang) {
79
+ return lang === undefined ? "\0" : lang;
80
+ }
81
+
82
+ /** @param {import("./fence.d.ts").FenceSegment} segment */
83
+ function ensureLanguage(segment) {
84
+ const key = cacheKey(segment.lang);
85
+ if (pendingLanguages.has(key)) return;
86
+ pendingLanguages.add(key);
87
+ Promise.resolve(resolveLanguage(segment.lang, segment))
88
+ .then((language) => {
89
+ resolvedLanguages = {
90
+ ...resolvedLanguages,
91
+ [key]: language ?? plaintext,
92
+ };
93
+ })
94
+ .catch(() => {
95
+ resolvedLanguages = { ...resolvedLanguages, [key]: plaintext };
96
+ });
97
+ }
98
+
99
+ /**
100
+ * `languages` is passed in so the template tracks the cache. A helper
101
+ * that only closed over `resolvedLanguages` would not re-run when a
102
+ * grammar finished loading (Svelte 3/4, and Svelte 5's `untrack` of
103
+ * helper bodies).
104
+ * @param {Record<string, import("./languages").LanguageType<string>>} languages
105
+ * @param {import("./fence.d.ts").FenceSegment} segment
106
+ */
107
+ function languageFor(languages, segment) {
108
+ return languages[cacheKey(segment.lang)] ?? plaintext;
109
+ }
110
+
111
+ // Feed the splitter, then re-read its (identity-stable) segment list.
112
+ $: {
113
+ if (text !== previousText) {
114
+ if (text.startsWith(previousText)) {
115
+ splitter.append(text.slice(previousText.length));
116
+ } else {
117
+ splitter.set(text);
118
+ }
119
+ previousText = text;
120
+ segments = splitter.segments();
121
+ }
122
+ }
123
+
124
+ $: for (const segment of segments) {
125
+ if (segment.kind !== "fence") continue;
126
+ if (!seenFenceIds.has(segment.id)) {
127
+ seenFenceIds.add(segment.id);
128
+ dispatch("fence", { id: segment.id, lang: segment.lang });
129
+ }
130
+ ensureLanguage(segment);
131
+ }
132
+
133
+ let doneDispatched = false;
134
+ $: if (done) {
135
+ if (!doneDispatched) {
136
+ doneDispatched = true;
137
+ dispatch("done");
138
+ }
139
+ } else {
140
+ doneDispatched = false;
141
+ }
142
+
143
+ // Only the trailing segment can be an open fence (the parser is still
144
+ // inside it), so caret placement never needs to scan the whole document.
145
+ $: lastSegment = segments[segments.length - 1];
146
+ $: lastOpenFenceId =
147
+ lastSegment !== undefined &&
148
+ lastSegment.kind === "fence" &&
149
+ lastSegment.open
150
+ ? lastSegment.id
151
+ : undefined;
152
+
153
+ $: lastFenceId = findLastFenceId(segments);
154
+
155
+ /** @param {readonly import("./fence.d.ts").MarkdownSegment[]} list */
156
+ function findLastFenceId(list) {
157
+ for (let i = list.length - 1; i >= 0; i -= 1) {
158
+ const segment = /** @type {import("./fence.d.ts").MarkdownSegment} */ (
159
+ list[i]
160
+ );
161
+ if (segment.kind === "fence") return segment.id;
162
+ }
163
+ return undefined;
164
+ }
165
+ </script>
166
+
167
+ <div class="shl-md" aria-busy={!done} {...$$restProps}>
168
+ {#each segments as segment (segment.id)}
169
+ {#if segment.kind === "text"}
170
+ <slot name="text" {segment}>
171
+ <div class="shl-md-text">{segment.text}</div>
172
+ </slot>
173
+ {:else}
174
+ <slot
175
+ name="fence"
176
+ {segment}
177
+ language={languageFor(resolvedLanguages, segment)}
178
+ >
179
+ <HighlightStream
180
+ code={segment.code}
181
+ language={languageFor(resolvedLanguages, segment)}
182
+ done={done || !segment.open}
183
+ caret={caret && segment.id === lastOpenFenceId}
184
+ {autoScroll}
185
+ doneText={segment.id === lastFenceId ? doneText : ""}
186
+ />
187
+ </slot>
188
+ {/if}
189
+ {/each}
190
+ </div>
191
+
192
+ <style>
193
+ .shl-md {
194
+ display: flex;
195
+ flex-direction: column;
196
+ gap: var(--md-gap, 1em);
197
+ }
198
+
199
+ .shl-md-text {
200
+ white-space: var(--md-text-white-space, pre-wrap);
201
+ }
202
+ </style>
@@ -0,0 +1,100 @@
1
+ import type { SvelteComponentTyped } from "svelte";
2
+ import type { HTMLAttributes } from "svelte/elements";
3
+ import type { FenceSegment, MarkdownSegment } from "./fence";
4
+ import type { LanguageType } from "./languages";
5
+
6
+ export type MarkdownStreamProps = HTMLAttributes<HTMLDivElement> & {
7
+ /**
8
+ * Growing Markdown buffer. On change, `splitter.append` is used when the
9
+ * new value starts with the previous one; otherwise the whole buffer is
10
+ * replaced via `splitter.set` (a regenerated reply, say).
11
+ * @default ""
12
+ */
13
+ text?: string;
14
+
15
+ /**
16
+ * Stream finished. Forwarded to every fence's `HighlightStream` as
17
+ * `done || !segment.open`, so a trailing open fence is treated as closed
18
+ * once the overall stream ends.
19
+ * @default false
20
+ */
21
+ done?: boolean;
22
+
23
+ /**
24
+ * Resolves a fence's language. The default dynamically imports the
25
+ * grammar via `loadLanguage`, falling back to plaintext while loading and
26
+ * whenever `lang` is `undefined`, unrecognized, or the returned promise
27
+ * rejects -- it never throws. Results are cached per canonical name for
28
+ * the component's lifetime.
29
+ * @default resolves via `loadLanguage`, falling back to plaintext
30
+ */
31
+ resolveLanguage?: (
32
+ lang: string | undefined,
33
+ segment: FenceSegment,
34
+ ) => LanguageType<string> | Promise<LanguageType<string>> | undefined;
35
+
36
+ /**
37
+ * Show a blinking caret at the end of the last open fence while streaming.
38
+ * @default true
39
+ */
40
+ caret?: boolean;
41
+
42
+ /**
43
+ * Keep each streaming fence scrolled to the bottom, unless the user has
44
+ * scrolled away from it.
45
+ * @default true
46
+ */
47
+ autoScroll?: boolean;
48
+
49
+ /**
50
+ * Announced by the last fence's visually-hidden live region once `done`
51
+ * becomes `true` -- every other fence gets `""` so completion is
52
+ * announced only once. Set to `""` to disable the announcement.
53
+ * @default "Code finished streaming"
54
+ */
55
+ doneText?: string;
56
+
57
+ /**
58
+ * Space between prose and fence segments.
59
+ * @default "1em"
60
+ */
61
+ "--md-gap"?: string;
62
+
63
+ /**
64
+ * `white-space` of the default prose block.
65
+ * @default "pre-wrap"
66
+ */
67
+ "--md-text-white-space"?: string;
68
+ };
69
+
70
+ export type MarkdownStreamEvents = {
71
+ /**
72
+ * Fires once, the first time a fence segment appears.
73
+ */
74
+ fence: CustomEvent<{
75
+ id: number;
76
+ lang: string | undefined;
77
+ }>;
78
+
79
+ /**
80
+ * Fires once when `done` becomes `true`.
81
+ */
82
+ done: CustomEvent<null>;
83
+ };
84
+
85
+ export type MarkdownStreamSlots = {
86
+ text: {
87
+ segment: MarkdownSegment & { kind: "text" };
88
+ };
89
+ fence: {
90
+ segment: FenceSegment;
91
+ /** The resolved language, or plaintext while loading/unknown. */
92
+ language: LanguageType<string>;
93
+ };
94
+ };
95
+
96
+ export default class MarkdownStream extends SvelteComponentTyped<
97
+ MarkdownStreamProps,
98
+ MarkdownStreamEvents,
99
+ MarkdownStreamSlots
100
+ > {}
package/README.md CHANGED
@@ -1552,7 +1552,7 @@ The action dispatches `highlighted` (`detail: { html, language }`) on success an
1552
1552
 
1553
1553
  Wrap a code block in `CodeWindow` to frame it with window chrome. It's purely cosmetic; the default slot renders your content unchanged.
1554
1554
 
1555
- Use the `variant` prop to choose the chrome style: `"macos"` (default) renders traffic-light dots, `"terminal"` renders a prompt, and `"plain"` renders just the title bar. The optional `title` is shown in the title bar.
1555
+ Use the `variant` prop to choose the chrome style: `"macos"` (default) renders traffic-light dots, `"terminal"` renders a prompt, and `"plain"` renders just the title bar. The optional `title` is shown in the title bar, and is also exposed as a native tooltip via the HTML `title` attribute so a truncated title is readable on hover or focus.
1556
1556
 
1557
1557
  ```svelte
1558
1558
  <script>
@@ -1598,6 +1598,8 @@ added 1 package in 1.2s`;
1598
1598
 
1599
1599
  ### Theming the chrome
1600
1600
 
1601
+ The title bar is a three-column flex row (leading chrome, title, a mirrored trailing spacer), so the title stays centered in the space actually left over without overlapping the dots or prompt even at narrow widths -- this doesn't apply to `plain`, which has no leading chrome to mirror.
1602
+
1601
1603
  Every part of the chrome is driven by CSS variables (see [`CodeWindow` variables](#codewindow-variables)). Pass them as style props to restyle the window without `:global` overrides. For example, give the default square window rounded corners with `--window-radius`:
1602
1604
 
1603
1605
  ```svelte
@@ -1673,6 +1675,34 @@ Or layer a `CopyButton` over it by wrapping both in a relatively-positioned cont
1673
1675
  </div>
1674
1676
  ```
1675
1677
 
1678
+ Put a `FileTabs` strip in the `titlebar` slot to switch between files without leaving the title bar:
1679
+
1680
+ ```svelte
1681
+ <script>
1682
+ import Highlight, { CodeWindow, FileTabs } from "svelte-highlight";
1683
+ import javascript from "svelte-highlight/languages/javascript";
1684
+ import typescript from "svelte-highlight/languages/typescript";
1685
+ import github from "svelte-highlight/styles/github";
1686
+
1687
+ const sources = {
1688
+ "App.svelte": { language: typescript, code: "const answer = 42;" },
1689
+ "index.js": { language: javascript, code: "export default answer;" },
1690
+ };
1691
+
1692
+ const files = Object.keys(sources);
1693
+ let active = files[0];
1694
+ </script>
1695
+
1696
+ <svelte:head>
1697
+ {@html github}
1698
+ </svelte:head>
1699
+
1700
+ <CodeWindow variant="macos">
1701
+ <FileTabs {files} bind:active slot="titlebar" />
1702
+ <Highlight language={sources[active].language} code={sources[active].code} />
1703
+ </CodeWindow>
1704
+ ```
1705
+
1676
1706
  ## Animation
1677
1707
 
1678
1708
  Use `Typewriter` inside `Highlight`'s default slot with the `highlighted` prop. It prints the code one character at a time, syntax highlighting included. A blinking caret marks the end of the typed text and hides when typing stops.
@@ -1846,7 +1876,89 @@ Per-chunk work is O(tail), not O(stream length so far): finished output is seale
1846
1876
  {/each}
1847
1877
  ```
1848
1878
 
1849
- Every segment's `id` is stable across both `append` (growing the buffer) and a full `set` (a regenerated buffer, keyed by common prefix) for everything before the first change, so the keyed `{#each}` never re-mounts a fence's `HighlightStream` just because more text arrived elsewhere in the document -- only the segment that actually changed gets a new instance. A `MarkdownStream` component that wraps this pattern is a separate deliverable; `createFenceSplitter` is the headless primitive underneath it.
1879
+ Every segment's `id` is stable across both `append` (growing the buffer) and a full `set` (a regenerated buffer, keyed by common prefix) for everything before the first change, so the keyed `{#each}` never re-mounts a fence's `HighlightStream` just because more text arrived elsewhere in the document -- only the segment that actually changed gets a new instance.
1880
+
1881
+ ### `MarkdownStream`
1882
+
1883
+ `MarkdownStream` wraps the pattern above: pass it a growing Markdown `text` buffer and it drives one `HighlightStream` per fence for you, keyed by the splitter's stable ids. Prose renders as plain text by default -- it's not a Markdown renderer, just a router for fenced code.
1884
+
1885
+ ```svelte
1886
+ <script>
1887
+ import { MarkdownStream } from "svelte-highlight";
1888
+ import github from "svelte-highlight/styles/github";
1889
+
1890
+ let text = "";
1891
+ let done = false;
1892
+
1893
+ // Wire this up to your streaming source (fetch, WebSocket, SSE, ...).
1894
+ async function stream() {
1895
+ for (const chunk of chunks) {
1896
+ text += chunk;
1897
+ await new Promise((r) => setTimeout(r, 30));
1898
+ }
1899
+ done = true;
1900
+ }
1901
+ </script>
1902
+
1903
+ <svelte:head>
1904
+ {@html github}
1905
+ </svelte:head>
1906
+
1907
+ <MarkdownStream {text} {done} />
1908
+ ```
1909
+
1910
+ `done` is forwarded to every fence's `HighlightStream` as `done || !segment.open`, so a trailing fence still open when the overall stream ends is treated as closed. The caret only ever renders on the last open fence, and `doneText`'s completion announcement fires once, from the last fence, rather than once per fence.
1911
+
1912
+ Override the `text` slot to render real Markdown prose (headings, lists, inline code) with a library of your choice, leaving fences to `MarkdownStream`:
1913
+
1914
+ ```svelte
1915
+ <script>
1916
+ import { MarkdownStream } from "svelte-highlight";
1917
+ import { renderInlineMarkdown } from "./your-markdown-renderer.js";
1918
+ </script>
1919
+
1920
+ <MarkdownStream {text} {done}>
1921
+ <div slot="text" let:segment>{@html renderInlineMarkdown(segment.text)}</div>
1922
+ </MarkdownStream>
1923
+ ```
1924
+
1925
+ By default, `resolveLanguage` dynamically imports one grammar per language seen via `loadLanguage`, falling back to plaintext while loading and for an unrecognized fence language. Pass your own `resolveLanguage` to restrict resolution to a fixed set of languages -- for example, everything else falls back to plaintext instead of fetching an arbitrary grammar chunk:
1926
+
1927
+ ```svelte
1928
+ <script>
1929
+ import { MarkdownStream, loadLanguage } from "svelte-highlight";
1930
+
1931
+ const ALLOWED = new Set(["typescript", "javascript", "bash", "json"]);
1932
+
1933
+ function resolveLanguage(lang) {
1934
+ return lang && ALLOWED.has(lang) ? loadLanguage(lang) : undefined;
1935
+ }
1936
+ </script>
1937
+
1938
+ <MarkdownStream {text} {done} {resolveLanguage} />
1939
+ ```
1940
+
1941
+ That still dynamically imports each allowed language's grammar on first use. For an app that wants no dynamic chunks at all -- everything bundled up front, same tradeoff as [Loading a language by name](#loading-a-language-by-name) -- map the allowlist to statically imported grammars instead:
1942
+
1943
+ ```svelte
1944
+ <script>
1945
+ import { MarkdownStream } from "svelte-highlight";
1946
+ import bash from "svelte-highlight/languages/bash";
1947
+ import javascript from "svelte-highlight/languages/javascript";
1948
+ import json from "svelte-highlight/languages/json";
1949
+ import typescript from "svelte-highlight/languages/typescript";
1950
+
1951
+ const GRAMMARS = { typescript, javascript, bash, json };
1952
+
1953
+ function resolveLanguage(lang) {
1954
+ return lang ? GRAMMARS[lang] : undefined;
1955
+ }
1956
+ </script>
1957
+
1958
+ <MarkdownStream {text} {done} {resolveLanguage} />
1959
+ ```
1960
+
1961
+ See [Code-splitting](#code-splitting) for the tradeoffs between a static import (bundled up front, no request-time latency) and `loadLanguage` (smaller initial bundle, one chunk fetched per language actually seen).
1850
1962
 
1851
1963
  ## Large documents
1852
1964
 
@@ -2231,6 +2343,10 @@ The default slot exposes `{ scopeClass }`. `$$restProps` are forwarded to the to
2231
2343
 
2232
2344
  `$$restProps` are forwarded to the top-level `div` element.
2233
2345
 
2346
+ #### Slots
2347
+
2348
+ - **titlebar**: optional content rendered in the mirrored trailing region of the title bar (empty by default, which keeps the title centered)
2349
+
2234
2350
  #### CSS Variables
2235
2351
 
2236
2352
  | Variable | Description | Default value |
@@ -2423,6 +2539,44 @@ Use `bind:this`, then call `scrollToLine(line)` -- works in both `virtualize` an
2423
2539
  />
2424
2540
  ```
2425
2541
 
2542
+ ### `MarkdownStream`
2543
+
2544
+ #### Props
2545
+
2546
+ | Name | Type | Default value |
2547
+ | :-------------- | :------------------------------------------------------------------------ | :----------------------------------- |
2548
+ | text | `string` | `""` |
2549
+ | done | `boolean` | `false` |
2550
+ | resolveLanguage | `(lang: string \| undefined, segment: FenceSegment) => LanguageType \| Promise<LanguageType> \| undefined` | resolves via `loadLanguage`, falling back to plaintext |
2551
+ | caret | `boolean` | `true` |
2552
+ | autoScroll | `boolean` | `true` |
2553
+ | doneText | `string` | `"Code finished streaming"` |
2554
+
2555
+ `$$restProps` are forwarded to the top-level `div` element. `resolveLanguage` results are cached per canonical language name for the component's lifetime. `doneText` is announced once, by the last fence only, once `done` becomes `true`; set it to `""` to disable the announcement.
2556
+
2557
+ #### Slots
2558
+
2559
+ | Name | Props | Fallback |
2560
+ | :--- | :-------------------- | :----------------------------------------------------------------- |
2561
+ | text | `segment` | `<div class="shl-md-text">{segment.text}</div>` |
2562
+ | fence | `segment`, `language` | `<HighlightStream code={segment.code} {language} done={done \|\| !segment.open} caret={...} autoScroll={autoScroll} doneText={...} />` |
2563
+
2564
+ #### Dispatched Events
2565
+
2566
+ - **on:fence**: fired once, the first time a fence segment appears, with `{ id, lang }`
2567
+ - **on:done**: fired once when `done` becomes `true`
2568
+
2569
+ #### CSS Variables
2570
+
2571
+ | Variable | Description | Default value |
2572
+ | :----------------------- | :------------------------------------ | :------------- |
2573
+ | --md-gap | Gap between prose and fence segments | `1em` |
2574
+ | --md-text-white-space | `white-space` of the default prose block | `pre-wrap` |
2575
+
2576
+ ```svelte
2577
+ <MarkdownStream {text} {done} on:fence={(e) => console.log(e.detail.lang)} />
2578
+ ```
2579
+
2426
2580
  ### `HighlightVirtual`
2427
2581
 
2428
2582
  #### Props
package/index.d.ts CHANGED
@@ -17,6 +17,7 @@ export { default as HighlightVirtual } from "./HighlightVirtual.svelte";
17
17
  export { default as LineNumbers } from "./LineNumbers.svelte";
18
18
  export type { LanguageName, LanguageType } from "./languages";
19
19
  export { LanguageLoadError, loadLanguage } from "./load-language";
20
+ export { default as MarkdownStream } from "./MarkdownStream.svelte";
20
21
  export {
21
22
  dualStyle,
22
23
  scopeClassFor,
package/index.js CHANGED
@@ -14,6 +14,7 @@ export { default as HighlightSvelte } from "./HighlightSvelte.svelte";
14
14
  export { default as HighlightVirtual } from "./HighlightVirtual.svelte";
15
15
  export { default as LineNumbers } from "./LineNumbers.svelte";
16
16
  export { LanguageLoadError, loadLanguage } from "./load-language.js";
17
+ export { default as MarkdownStream } from "./MarkdownStream.svelte";
17
18
  export {
18
19
  dualStyle,
19
20
  scopeClassFor,