svelte-highlight 7.21.1 → 7.23.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/AnsiOutput.svelte +6 -30
- package/CodeWindow.svelte +35 -11
- package/CodeWindow.svelte.d.ts +7 -1
- package/FileTabs.svelte +3 -1
- package/HighlightEditable.svelte +115 -143
- package/HighlightStream.svelte +44 -48
- package/HighlightStyle.svelte +9 -21
- package/HighlightVirtual.svelte +82 -4
- package/HighlightVirtual.svelte.d.ts +19 -2
- package/LangTag.svelte +4 -0
- package/LineNumbers.svelte +1 -0
- package/MarkdownStream.svelte +209 -0
- package/MarkdownStream.svelte.d.ts +100 -0
- package/README.md +183 -9
- package/ansi-color.js +109 -22
- package/ansi-output.js +93 -0
- package/ansi.d.ts +18 -0
- package/ansi.js +85 -24
- package/css-walk.js +9 -12
- package/editable-css-paint.js +118 -0
- package/editable-dom-paint.js +217 -146
- package/editable-line-dom.js +241 -0
- package/engine.d.ts +28 -6
- package/engine.js +707 -144
- package/fence.d.ts +5 -5
- package/fence.js +196 -56
- package/highlight-theme.js +10 -4
- package/incremental-tokenize.js +95 -17
- 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/preprocessor.js +16 -2
- package/scoped.js +15 -13
- package/search.d.ts +6 -4
- package/search.js +427 -85
- package/stream-final-highlight.js +52 -0
- package/stream-highlighted.js +17 -0
- package/stream-preview.js +7 -2
- package/stream-regenerate.js +262 -0
- package/style-registry.js +60 -0
- package/text-diff.js +66 -18
- package/tokenized-document.d.ts +8 -0
- package/tokenized-document.js +60 -15
- package/worker.js +14 -2
package/HighlightStream.svelte
CHANGED
|
@@ -66,8 +66,10 @@
|
|
|
66
66
|
import { createEventDispatcher, onMount, tick } from "svelte";
|
|
67
67
|
import { extendLines } from "./engine.js";
|
|
68
68
|
import { ensureRegistered, registry } from "./registry.js";
|
|
69
|
+
import { createFinalHighlighter } from "./stream-final-highlight.js";
|
|
69
70
|
import { createCompletedHtmlBuffer } from "./stream-highlighted.js";
|
|
70
71
|
import { computeStagedTailPreview } from "./stream-preview.js";
|
|
72
|
+
import { regenerate } from "./stream-regenerate.js";
|
|
71
73
|
import {
|
|
72
74
|
buildSealedChunkHtml,
|
|
73
75
|
pushSealedChunk,
|
|
@@ -160,6 +162,8 @@
|
|
|
160
162
|
// so `on:highlight` stays live mid-line; that concat copies the completed
|
|
161
163
|
// string but avoids rebuilding it from sealed DOM chunks.
|
|
162
164
|
const completedHtml = createCompletedHtmlBuffer();
|
|
165
|
+
// The `done` pass's full re-parse; see stream-final-highlight.js.
|
|
166
|
+
const finalHighlighter = createFinalHighlighter();
|
|
163
167
|
// Completed lines not yet folded into a sealed chunk - bounded by
|
|
164
168
|
// `SEAL_CHUNK_LINES`, so touching it every repaint stays O(1).
|
|
165
169
|
/** @type {string[]} */
|
|
@@ -179,49 +183,41 @@
|
|
|
179
183
|
ensureRegistered(language);
|
|
180
184
|
if (session && sessionLanguageName === language.name) {
|
|
181
185
|
// Not a pure append (an LLM "regenerate the last paragraph", say):
|
|
182
|
-
// patch
|
|
183
|
-
//
|
|
184
|
-
const
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
}
|
|
192
|
-
let suffixLen = 0;
|
|
193
|
-
const maxSuffix = common - prefixLen;
|
|
194
|
-
while (
|
|
195
|
-
suffixLen < maxSuffix &&
|
|
196
|
-
code.charCodeAt(code.length - 1 - suffixLen) ===
|
|
197
|
-
fedCode.charCodeAt(fedCode.length - 1 - suffixLen)
|
|
198
|
-
) {
|
|
199
|
-
suffixLen++;
|
|
200
|
-
}
|
|
201
|
-
session.replace(
|
|
202
|
-
prefixLen,
|
|
203
|
-
fedCode.length - suffixLen,
|
|
204
|
-
code.slice(prefixLen, code.length - suffixLen),
|
|
205
|
-
);
|
|
186
|
+
// patch the session in place instead of restarting it and losing
|
|
187
|
+
// every sealed chunk.
|
|
188
|
+
const next = regenerate({
|
|
189
|
+
session,
|
|
190
|
+
fedCode,
|
|
191
|
+
code,
|
|
192
|
+
sealedChunks,
|
|
193
|
+
completedHtml,
|
|
194
|
+
chunkLines: SEAL_CHUNK_LINES,
|
|
195
|
+
});
|
|
206
196
|
fedCode = code;
|
|
207
197
|
previewCache = undefined;
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
completedHtml.reset();
|
|
215
|
-
completedHtml.appendLines(result.completedLines);
|
|
216
|
-
sealedChunks = [];
|
|
217
|
-
sealedLineCount = 0;
|
|
218
|
-
unsealedLines = result.completedLines;
|
|
219
|
-
while (unsealedLines.length >= SEAL_CHUNK_LINES) sealChunk();
|
|
198
|
+
finalizedPendingHtml = next.pendingHtml;
|
|
199
|
+
finalizedOpenScopes = next.openScopes;
|
|
200
|
+
renderedCommittedCount = next.committedCount;
|
|
201
|
+
sealedChunks = next.sealedChunks;
|
|
202
|
+
sealedLineCount = next.sealedLineCount;
|
|
203
|
+
unsealedLines = next.unsealedLines;
|
|
220
204
|
tailLines = unsealedLines;
|
|
221
205
|
return;
|
|
222
206
|
}
|
|
207
|
+
resetStreamingState();
|
|
223
208
|
session = registry.createSession(language.name);
|
|
224
209
|
sessionLanguageName = language.name;
|
|
210
|
+
}
|
|
211
|
+
|
|
212
|
+
// Drops the session and everything rendered from it. Also runs after the
|
|
213
|
+
// done pass: from then on the template shows only `highlighted`, and a
|
|
214
|
+
// repeat done pass reuses the memoized final HTML without a session, so a
|
|
215
|
+
// closed stream holds little more than its final HTML. If streaming
|
|
216
|
+
// resumes, ensureSession starts over from the whole buffer, which renders
|
|
217
|
+
// the same lines - bench/markdown-stream.bench.ts.
|
|
218
|
+
function resetStreamingState() {
|
|
219
|
+
session = undefined;
|
|
220
|
+
sessionLanguageName = "";
|
|
225
221
|
fedCode = "";
|
|
226
222
|
finalizedPendingHtml = "";
|
|
227
223
|
finalizedOpenScopes = [];
|
|
@@ -249,16 +245,18 @@
|
|
|
249
245
|
}
|
|
250
246
|
|
|
251
247
|
function repaint() {
|
|
252
|
-
ensureSession();
|
|
253
|
-
if (code.length > fedCode.length) {
|
|
254
|
-
session.append(code.slice(fedCode.length));
|
|
255
|
-
fedCode = code;
|
|
256
|
-
}
|
|
257
|
-
|
|
258
248
|
if (done) {
|
|
259
249
|
// Full re-parse for multi-line lookahead (heredocs, etc.).
|
|
260
|
-
|
|
250
|
+
ensureRegistered(language);
|
|
251
|
+
highlighted = finalHighlighter.highlight(registry, code, language.name);
|
|
252
|
+
if (session) resetStreamingState();
|
|
261
253
|
} else {
|
|
254
|
+
ensureSession();
|
|
255
|
+
if (code.length > fedCode.length) {
|
|
256
|
+
session.append(code.slice(fedCode.length));
|
|
257
|
+
fedCode = code;
|
|
258
|
+
}
|
|
259
|
+
|
|
262
260
|
// Newly committed events (append only tokenizes complete lines).
|
|
263
261
|
const committed = session.events();
|
|
264
262
|
if (committed.length > renderedCommittedCount) {
|
|
@@ -371,11 +369,9 @@
|
|
|
371
369
|
dispatchedWindowStart = vStart;
|
|
372
370
|
dispatchedWindowEnd = vEnd;
|
|
373
371
|
dispatchedWindowLineCount = vLineCount;
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
lineCount: vLineCount,
|
|
378
|
-
});
|
|
372
|
+
// Dispatch once the new rows are in the DOM (see HighlightVirtual).
|
|
373
|
+
const detail = { start: vStart, end: vEnd, lineCount: vLineCount };
|
|
374
|
+
tick().then(() => dispatch("windowchange", detail));
|
|
379
375
|
}
|
|
380
376
|
}
|
|
381
377
|
|
package/HighlightStyle.svelte
CHANGED
|
@@ -1,25 +1,11 @@
|
|
|
1
1
|
<script context="module">
|
|
2
|
-
import {
|
|
2
|
+
import { createStyleRegistry } from "./style-registry.js";
|
|
3
3
|
|
|
4
4
|
const isBrowser = typeof document !== "undefined";
|
|
5
5
|
|
|
6
|
-
//
|
|
7
|
-
//
|
|
8
|
-
|
|
9
|
-
// subscribers reactively re-derive a new owner instead of the tag being
|
|
10
|
-
// dropped while siblings still need it.
|
|
11
|
-
/** @type {Map<string, import("svelte/store").Writable<symbol[]>>} */
|
|
12
|
-
const registries = new Map();
|
|
13
|
-
|
|
14
|
-
/** @param {string} key */
|
|
15
|
-
function registryFor(key) {
|
|
16
|
-
let registry = registries.get(key);
|
|
17
|
-
if (!registry) {
|
|
18
|
-
registry = writable([]);
|
|
19
|
-
registries.set(key, registry);
|
|
20
|
-
}
|
|
21
|
-
return registry;
|
|
22
|
-
}
|
|
6
|
+
// Shared across instances: identical styles render one `<style>` tag,
|
|
7
|
+
// owned by the oldest still-mounted instance (see style-registry.js).
|
|
8
|
+
const styleRegistry = createStyleRegistry();
|
|
23
9
|
</script>
|
|
24
10
|
|
|
25
11
|
<script>
|
|
@@ -132,7 +118,7 @@
|
|
|
132
118
|
let registry;
|
|
133
119
|
|
|
134
120
|
function unregister() {
|
|
135
|
-
registry
|
|
121
|
+
if (registry) styleRegistry.unregister(registeredKey, registry, token);
|
|
136
122
|
}
|
|
137
123
|
|
|
138
124
|
$: {
|
|
@@ -140,8 +126,10 @@
|
|
|
140
126
|
if (key !== registeredKey) {
|
|
141
127
|
unregister();
|
|
142
128
|
registeredKey = key;
|
|
143
|
-
registry =
|
|
144
|
-
|
|
129
|
+
registry =
|
|
130
|
+
isBrowser && key !== undefined
|
|
131
|
+
? styleRegistry.register(key, token)
|
|
132
|
+
: undefined;
|
|
145
133
|
}
|
|
146
134
|
}
|
|
147
135
|
|
package/HighlightVirtual.svelte
CHANGED
|
@@ -21,6 +21,16 @@
|
|
|
21
21
|
*/
|
|
22
22
|
export let checkpointInterval = 100;
|
|
23
23
|
|
|
24
|
+
/**
|
|
25
|
+
* Tokenize the rest of the document in idle time after the first paint,
|
|
26
|
+
* so a far jump (scrollToLine, dragging the scrollbar) doesn't stall on
|
|
27
|
+
* tokenizing everything before it. Off by default: the engine session
|
|
28
|
+
* keeps every event it produces, so a full pass retains about 117 MB
|
|
29
|
+
* per 100k lines of TypeScript, even if nobody scrolls.
|
|
30
|
+
* @type {boolean}
|
|
31
|
+
*/
|
|
32
|
+
export let tokenizeAhead = false;
|
|
33
|
+
|
|
24
34
|
import { createEventDispatcher, onMount, tick } from "svelte";
|
|
25
35
|
import { createTokenizedDocument } from "./tokenized-document.js";
|
|
26
36
|
import { watchLineHeight, windowRange } from "./virtual-window.js";
|
|
@@ -107,7 +117,11 @@
|
|
|
107
117
|
dispatchedWindowStart = start;
|
|
108
118
|
dispatchedWindowEnd = end;
|
|
109
119
|
dispatchedWindowLineCount = lineCount;
|
|
110
|
-
|
|
120
|
+
// Dispatch once the new rows are in the DOM, so a listener that paints
|
|
121
|
+
// into them (e.g. search's highlightMatches) doesn't paint the old
|
|
122
|
+
// rows Svelte is about to replace.
|
|
123
|
+
const detail = { start, end, lineCount };
|
|
124
|
+
tick().then(() => dispatch("windowchange", detail));
|
|
111
125
|
}
|
|
112
126
|
}
|
|
113
127
|
|
|
@@ -167,6 +181,62 @@
|
|
|
167
181
|
lineCount = doc.lineCount();
|
|
168
182
|
computeWindow();
|
|
169
183
|
syncFromContainer();
|
|
184
|
+
scheduleTokenizeAhead();
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
$: if (hydrated) {
|
|
188
|
+
if (tokenizeAhead) scheduleTokenizeAhead();
|
|
189
|
+
else cancelTokenizeAhead();
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
// Idle-time tokenizing ahead. A first jump to the end of a 500k-line file
|
|
193
|
+
// otherwise tokenizes ~24 MB synchronously (seconds); after this pass,
|
|
194
|
+
// checkpoints cover the whole document and any jump is a few ms.
|
|
195
|
+
const requestIdle =
|
|
196
|
+
typeof requestIdleCallback === "function"
|
|
197
|
+
? (/** @type {IdleRequestCallback} */ callback) =>
|
|
198
|
+
requestIdleCallback(callback, { timeout: 1000 })
|
|
199
|
+
: (/** @type {IdleRequestCallback} */ callback) =>
|
|
200
|
+
setTimeout(
|
|
201
|
+
() => callback({ didTimeout: false, timeRemaining: () => 8 }),
|
|
202
|
+
16,
|
|
203
|
+
);
|
|
204
|
+
const cancelIdle =
|
|
205
|
+
typeof cancelIdleCallback === "function"
|
|
206
|
+
? cancelIdleCallback
|
|
207
|
+
: clearTimeout;
|
|
208
|
+
|
|
209
|
+
/** @type {any} */
|
|
210
|
+
let aheadHandle;
|
|
211
|
+
// Bumped on every (re)schedule so a callback from an older document stops.
|
|
212
|
+
let aheadGeneration = 0;
|
|
213
|
+
|
|
214
|
+
function cancelTokenizeAhead() {
|
|
215
|
+
aheadGeneration++;
|
|
216
|
+
if (aheadHandle !== undefined) cancelIdle(aheadHandle);
|
|
217
|
+
aheadHandle = undefined;
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
function scheduleTokenizeAhead() {
|
|
221
|
+
cancelTokenizeAhead();
|
|
222
|
+
if (!tokenizeAhead || !doc) return;
|
|
223
|
+
const generation = aheadGeneration;
|
|
224
|
+
/** @param {IdleDeadline} deadline */
|
|
225
|
+
const step = (deadline) => {
|
|
226
|
+
aheadHandle = undefined;
|
|
227
|
+
if (generation !== aheadGeneration || !doc) return;
|
|
228
|
+
let done = false;
|
|
229
|
+
// At least one batch per callback, so a busy page still progresses.
|
|
230
|
+
do {
|
|
231
|
+
done = doc.tokenizeThrough(doc.tokenizedThrough() + checkpointInterval);
|
|
232
|
+
} while (!done && deadline.timeRemaining() > 2);
|
|
233
|
+
dispatch("tokenize", {
|
|
234
|
+
through: done ? doc.lineCount() : doc.tokenizedThrough(),
|
|
235
|
+
lineCount: doc.lineCount(),
|
|
236
|
+
});
|
|
237
|
+
if (!done) aheadHandle = requestIdle(step);
|
|
238
|
+
};
|
|
239
|
+
aheadHandle = requestIdle(step);
|
|
170
240
|
}
|
|
171
241
|
|
|
172
242
|
// Scroll/resize/overscan/lineHeight-driven window recompute.
|
|
@@ -180,12 +250,19 @@
|
|
|
180
250
|
}
|
|
181
251
|
|
|
182
252
|
/**
|
|
183
|
-
* Scroll a given line into the rendered window.
|
|
253
|
+
* Scroll a given line into the rendered window. Jumps instantly (sets
|
|
254
|
+
* `scrollTop`), so there's no scroll animation.
|
|
184
255
|
* @param {number} line
|
|
256
|
+
* @param {{ align?: "start" | "center" }} [options] Where the line lands
|
|
257
|
+
* in the viewport: the top edge (default) or the middle.
|
|
185
258
|
*/
|
|
186
|
-
export function scrollToLine(line) {
|
|
259
|
+
export function scrollToLine(line, options = {}) {
|
|
187
260
|
if (!container) return;
|
|
188
|
-
const
|
|
261
|
+
const lineTop = Math.max(0, Math.min(line, lineCount)) * lineHeight;
|
|
262
|
+
const target =
|
|
263
|
+
options.align === "center"
|
|
264
|
+
? lineTop - (container.clientHeight - lineHeight) / 2
|
|
265
|
+
: lineTop;
|
|
189
266
|
const maxScrollTop = Math.max(
|
|
190
267
|
0,
|
|
191
268
|
container.scrollHeight - container.clientHeight,
|
|
@@ -209,6 +286,7 @@
|
|
|
209
286
|
|
|
210
287
|
return () => {
|
|
211
288
|
cancelFrame();
|
|
289
|
+
cancelTokenizeAhead();
|
|
212
290
|
resizeObserver?.disconnect();
|
|
213
291
|
};
|
|
214
292
|
});
|
|
@@ -27,6 +27,13 @@ export type HighlightVirtualProps = HTMLAttributes<HTMLPreElement> & {
|
|
|
27
27
|
* @default 100
|
|
28
28
|
*/
|
|
29
29
|
checkpointInterval?: number;
|
|
30
|
+
|
|
31
|
+
/**
|
|
32
|
+
* Tokenize the rest of the document in idle time after the first paint,
|
|
33
|
+
* so far jumps don't stall. Costs memory for the whole document up front.
|
|
34
|
+
* @default false
|
|
35
|
+
*/
|
|
36
|
+
tokenizeAhead?: boolean;
|
|
30
37
|
};
|
|
31
38
|
|
|
32
39
|
export type HighlightVirtualEvents = {
|
|
@@ -34,6 +41,12 @@ export type HighlightVirtualEvents = {
|
|
|
34
41
|
* Fired whenever the rendered window changes.
|
|
35
42
|
*/
|
|
36
43
|
windowchange: CustomEvent<{ start: number; end: number; lineCount: number }>;
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* Fired after each idle slice of `tokenizeAhead`, with how many lines
|
|
47
|
+
* are tokenized so far. `through === lineCount` once it's done.
|
|
48
|
+
*/
|
|
49
|
+
tokenize: CustomEvent<{ through: number; lineCount: number }>;
|
|
37
50
|
};
|
|
38
51
|
|
|
39
52
|
export default class HighlightVirtual extends SvelteComponentTyped<
|
|
@@ -41,6 +54,10 @@ export default class HighlightVirtual extends SvelteComponentTyped<
|
|
|
41
54
|
HighlightVirtualEvents,
|
|
42
55
|
Record<string, never>
|
|
43
56
|
> {
|
|
44
|
-
/**
|
|
45
|
-
|
|
57
|
+
/**
|
|
58
|
+
* Scroll a given line into the rendered window, without animation.
|
|
59
|
+
* `align` places the line at the viewport's top edge (default) or
|
|
60
|
+
* middle.
|
|
61
|
+
*/
|
|
62
|
+
scrollToLine(line: number, options?: { align?: "start" | "center" }): void;
|
|
46
63
|
}
|
package/LangTag.svelte
CHANGED
package/LineNumbers.svelte
CHANGED
|
@@ -0,0 +1,209 @@
|
|
|
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
|
+
*
|
|
105
|
+
* Takes the cache key, not the segment, so the result doesn't depend on
|
|
106
|
+
* the segment object. Svelte 5's legacy mode marks every keyed `{#each}`
|
|
107
|
+
* item as changed whenever `segments` changes, and treats any object as
|
|
108
|
+
* changed. A `language` read off the segment would reach every closed
|
|
109
|
+
* fence's HighlightStream on every chunk. Through the (string) key, it
|
|
110
|
+
* only changes when the key or a grammar does -
|
|
111
|
+
* tests/markdown-stream-updates.test.ts.
|
|
112
|
+
* @param {Record<string, import("./languages").LanguageType<string>>} languages
|
|
113
|
+
* @param {string} key
|
|
114
|
+
*/
|
|
115
|
+
function languageFor(languages, key) {
|
|
116
|
+
return languages[key] ?? plaintext;
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
// Feed the splitter, then re-read its (identity-stable) segment list.
|
|
120
|
+
$: {
|
|
121
|
+
if (text !== previousText) {
|
|
122
|
+
if (text.startsWith(previousText)) {
|
|
123
|
+
splitter.append(text.slice(previousText.length));
|
|
124
|
+
} else {
|
|
125
|
+
splitter.set(text);
|
|
126
|
+
}
|
|
127
|
+
previousText = text;
|
|
128
|
+
segments = splitter.segments();
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
$: for (const segment of segments) {
|
|
133
|
+
if (segment.kind !== "fence") continue;
|
|
134
|
+
if (!seenFenceIds.has(segment.id)) {
|
|
135
|
+
seenFenceIds.add(segment.id);
|
|
136
|
+
dispatch("fence", { id: segment.id, lang: segment.lang });
|
|
137
|
+
}
|
|
138
|
+
ensureLanguage(segment);
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
let doneDispatched = false;
|
|
142
|
+
$: if (done) {
|
|
143
|
+
if (!doneDispatched) {
|
|
144
|
+
doneDispatched = true;
|
|
145
|
+
dispatch("done");
|
|
146
|
+
}
|
|
147
|
+
} else {
|
|
148
|
+
doneDispatched = false;
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
// Only the trailing segment can be an open fence (the parser is still
|
|
152
|
+
// inside it), so caret placement never needs to scan the whole document.
|
|
153
|
+
$: lastSegment = segments[segments.length - 1];
|
|
154
|
+
$: lastOpenFenceId =
|
|
155
|
+
lastSegment !== undefined &&
|
|
156
|
+
lastSegment.kind === "fence" &&
|
|
157
|
+
lastSegment.open
|
|
158
|
+
? lastSegment.id
|
|
159
|
+
: undefined;
|
|
160
|
+
|
|
161
|
+
$: lastFenceId = findLastFenceId(segments);
|
|
162
|
+
|
|
163
|
+
/** @param {readonly import("./fence.d.ts").MarkdownSegment[]} list */
|
|
164
|
+
function findLastFenceId(list) {
|
|
165
|
+
for (let i = list.length - 1; i >= 0; i -= 1) {
|
|
166
|
+
const segment = /** @type {import("./fence.d.ts").MarkdownSegment} */ (
|
|
167
|
+
list[i]
|
|
168
|
+
);
|
|
169
|
+
if (segment.kind === "fence") return segment.id;
|
|
170
|
+
}
|
|
171
|
+
return undefined;
|
|
172
|
+
}
|
|
173
|
+
</script>
|
|
174
|
+
|
|
175
|
+
<div class="shl-md" aria-busy={!done} {...$$restProps}>
|
|
176
|
+
{#each segments as segment (segment.id)}
|
|
177
|
+
{@const languageKey =
|
|
178
|
+
segment.kind === "fence" ? cacheKey(segment.lang) : ""}
|
|
179
|
+
{@const language = languageFor(resolvedLanguages, languageKey)}
|
|
180
|
+
{#if segment.kind === "text"}
|
|
181
|
+
<slot name="text" {segment}>
|
|
182
|
+
<div class="shl-md-text">{segment.text}</div>
|
|
183
|
+
</slot>
|
|
184
|
+
{:else}
|
|
185
|
+
<slot name="fence" {segment} {language}>
|
|
186
|
+
<HighlightStream
|
|
187
|
+
code={segment.code}
|
|
188
|
+
{language}
|
|
189
|
+
done={done || !segment.open}
|
|
190
|
+
caret={caret && segment.id === lastOpenFenceId}
|
|
191
|
+
{autoScroll}
|
|
192
|
+
doneText={segment.id === lastFenceId ? doneText : ""}
|
|
193
|
+
/>
|
|
194
|
+
</slot>
|
|
195
|
+
{/if}
|
|
196
|
+
{/each}
|
|
197
|
+
</div>
|
|
198
|
+
|
|
199
|
+
<style>
|
|
200
|
+
.shl-md {
|
|
201
|
+
display: flex;
|
|
202
|
+
flex-direction: column;
|
|
203
|
+
gap: var(--md-gap, 1em);
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
.shl-md-text {
|
|
207
|
+
white-space: var(--md-text-white-space, pre-wrap);
|
|
208
|
+
}
|
|
209
|
+
</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
|
+
> {}
|