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.
- package/CodeWindow.svelte +35 -11
- package/CodeWindow.svelte.d.ts +7 -1
- package/LangTag.svelte +4 -0
- package/LineNumbers.svelte +1 -0
- package/MarkdownStream.svelte +202 -0
- package/MarkdownStream.svelte.d.ts +100 -0
- package/README.md +156 -2
- package/index.d.ts +1 -0
- package/index.js +1 -0
- package/languages/aliases.js +1 -1
- package/languages/all.js +23 -1
- package/languages/alloy.d.ts +2 -0
- package/languages/alloy.js +2 -0
- package/languages/asymptote.d.ts +2 -0
- package/languages/asymptote.js +2 -0
- package/languages/blockdiag.d.ts +2 -0
- package/languages/blockdiag.js +2 -0
- package/languages/bsv.d.ts +2 -0
- package/languages/bsv.js +2 -0
- package/languages/casbin.d.ts +2 -0
- package/languages/casbin.js +2 -0
- package/languages/choicescript.d.ts +2 -0
- package/languages/choicescript.js +2 -0
- package/languages/dafny.d.ts +2 -0
- package/languages/dafny.js +2 -0
- package/languages/dbml.d.ts +2 -0
- package/languages/dbml.js +2 -0
- package/languages/dialog.d.ts +2 -0
- package/languages/dialog.js +2 -0
- package/languages/fstar.d.ts +2 -0
- package/languages/fstar.js +2 -0
- package/languages/gnuplot.d.ts +2 -0
- package/languages/gnuplot.js +2 -0
- package/languages/harlowe.d.ts +2 -0
- package/languages/harlowe.js +2 -0
- package/languages/index.d.ts +44 -0
- package/languages/index.js +22 -0
- package/languages/likec4.d.ts +2 -0
- package/languages/likec4.js +2 -0
- package/languages/nextflow.d.ts +2 -0
- package/languages/nextflow.js +2 -0
- package/languages/nomnoml.d.ts +2 -0
- package/languages/nomnoml.js +2 -0
- package/languages/openfga.d.ts +2 -0
- package/languages/openfga.js +2 -0
- package/languages/pikchr.d.ts +2 -0
- package/languages/pikchr.js +2 -0
- package/languages/spade.d.ts +2 -0
- package/languages/spade.js +2 -0
- package/languages/spicedb.d.ts +2 -0
- package/languages/spicedb.js +2 -0
- package/languages/tlaplus.d.ts +2 -0
- package/languages/tlaplus.js +2 -0
- package/languages/veryl.d.ts +2 -0
- package/languages/veryl.js +2 -0
- package/languages/wdl.d.ts +2 -0
- package/languages/wdl.js +2 -0
- 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="
|
|
13
|
-
<span class="
|
|
14
|
-
|
|
15
|
-
|
|
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="
|
|
20
|
+
<span class="titlebar-lead">
|
|
21
|
+
<span class="prompt" aria-hidden="true">>_</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
|
-
/*
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
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;
|
package/CodeWindow.svelte.d.ts
CHANGED
|
@@ -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
package/LineNumbers.svelte
CHANGED
|
@@ -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.
|
|
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,
|