Eine Live-Coding-Musik-App bauen · Teil 11 von 18 der Serie
Teil 11: Wenn der Code falsch ist
Fang jeden Fehler ab, den der Code machen kann: Optionen werden gegen das Schema geprüft, mit einem „Did you mean“, ein Fehler wird an seiner Zeile im Editor markiert, und ein Worker mit Zeitlimit beendet Code, der nie endet. Die Musik spielt bei alldem weiter.
Eine Live-Coding-Musik-App bauenTeil 11 von 18
Auf dieser Seite
Quest-Ziele
- Die Optionen gegen das Schema prüfen und den ähnlichsten Namen vorschlagen
- Die Zeile eines Fehlers im Stacktrace von Code aus new Function finden
- Den Parser des Editors fragen, wo ein Syntaxfehler steckt
- Die Zeile im Editor markieren und die Meldung darunter zeigen
- Den Code in einem Worker ausführen und ihn nach 3 Sekunden beenden
- Zeigen, was der Code mit console.log ausgibt
Wer Code ändert, während die Musik spielt, macht Fehler, während die Musik spielt. Die App aus Teil 10 übersteht die meisten schon: Scheitert ein Durchlauf, spielt der letzte Patch weiter. Aber sie sagt wenig darüber, was schiefging, und eine Art von Fehler reißt immer noch die ganze Seite mit:
monoSynth({ cutof: 900 })ist gar kein Fehler. Das Skript liest nur die Optionen, die es kennt, also fällt die falsch geschriebene weg, und der Cutoff bleibt bei 300. Du hörst keine Änderung und bekommst keinen Hinweis, warum.kitt.to(out)ergibtkitt is not definedin der Statuszeile, aber nicht die Zeile, in der es steht.while (true) {}kommt nie zurück. Die Seite friert ein, die Uhr kann nichts mehr einplanen, die Musik endet nach der Zehntelsekunde, die schon eingeplant war, und kein Button reagiert.
Dieser Teil gibt jedem Fehler eine Meldung und, wo es eine gibt, eine Zeile. Und er sorgt dafür, dass keiner davon die Musik anhält.
Die Optionen prüfen
Das Schema aus Teil 9 weiß alles über eine Option: ihren Namen, ob sie eine Zahl oder ein Text ist, ihren Bereich, die Wörter, die sie sein kann. Bisher hat es nur die Standardwerte geliefert. Ab jetzt prüft das Skript damit, was der Code angibt. Der größte Teil von src/script.ts ändert sich, ersetze also die Datei. Sie kommt in fünf Blöcken, die in der Datei aufeinander folgen, mit einer Leerzeile dazwischen. Der erste ist der Kopf der Datei:
import { mini, MiniError } from './mini.ts';
import type { Options, Patch, Value } from './patch.ts';
import { OUT, UNITS, type UnitType } from './schema.ts';
/** What a run of the code comes to: a patch, or the reason why there is none. */
export type Outcome =
| { ok: true; patch: Patch; logs: string[] }
| { ok: false; message: string; line: number | undefined; logs: string[] };
/** A mistake in the code that we found, as opposed to one JavaScript found. */
export class ScriptError extends Error {}
/** What the code holds in its variables: a unit of the patch, which can be connected. */
class Handle {
readonly id: string;
readonly type: string;
private readonly spec: UnitType;
private readonly patch: Patch;
constructor(id: string, type: string, spec: UnitType, patch: Patch) {
this.id = id;
this.type = type;
this.spec = spec;
this.patch = patch;
}
/** Connects this unit to another one. Gives back the other one, so that calls can be chained. */
to(target: Handle): Handle {
if (!(target instanceof Handle)) throw new ScriptError(`${this.type}.to() needs something to connect to, such as out`);
const gives = this.spec.gives;
const takes = target.spec.takes;
if (!gives) throw new ScriptError(`${this.type} has no output`);
if (gives !== takes) {
throw new ScriptError(`${this.type} gives ${gives}, but ${target.type} ${takes ? `takes ${takes}` : 'has no input'}`);
}
this.patch.cables.push({ from: this.id, to: target.id, kind: gives });
return target;
}
}Handle ist das aus Teil 9. Neu ist Outcome: das, was bei einem Durchlauf des Codes herauskommt. Bisher gab runScript() einen Patch zurück oder warf einen Fehler. Ab jetzt wirft es nie. Es gibt entweder einen Patch zurück oder eine Meldung mit einer Zeile, und in beiden Fällen das, was der Code ausgegeben hat. Der Grund kommt am Ende dieses Teils: Das Ergebnis muss von einem Worker zur Seite reisen, und reine Daten reisen am besten.
Ein falsch geschriebener Name verdient mehr als „unbekannte Option“. Der zweite Block findet das Wort, das wahrscheinlich gemeint war:
// ---------------------------------------------------------------------------
// Checking the options
/** How many letters have to be changed, added or removed to turn one word into another. */
function distance(a: string, b: string): number {
let row = Array.from({ length: b.length + 1 }, (_, index) => index);
for (let i = 1; i <= a.length; i += 1) {
const next = [i];
for (let j = 1; j <= b.length; j += 1) {
next[j] = Math.min(row[j] + 1, next[j - 1] + 1, row[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
}
row = next;
}
return row[b.length];
}
/** " Did you mean cutoff?", if one of the words is close to what was written. */
function didYouMean(word: string, words: readonly string[]): string {
const typed = word.toLowerCase();
const [best] = words
// A word that starts with what was typed is as close as it gets: "saw" means "sawtooth".
.map((candidate) => ({
candidate,
far: candidate.toLowerCase().startsWith(typed) ? 0 : distance(typed, candidate.toLowerCase()),
}))
.sort((a, b) => a.far - b.far);
return best && best.far <= Math.max(2, word.length / 3) ? ` Did you mean ${best.candidate}?` : '';
}distance() zählt, wie viele einzelne Buchstaben man ändern, einfügen oder entfernen muss, um aus einem Wort das andere zu machen. Von cutof zu cutoff ist es 1. Diese Zahl heißt Editierdistanz. Die Funktion arbeitet sich durch eine Tabelle mit einer Zeile pro Buchstabe des ersten Worts und einer Spalte pro Buchstabe des zweiten. Eine Zelle enthält die Distanz zwischen den beiden Wortanfängen bis dorthin, und sie ist der billigste von drei Wegen zu ihr:
einen Buchstaben entfernen: die Zelle darüber, plus 1 (
row[j] + 1)einen Buchstaben einfügen: die Zelle links, plus 1 (
next[j - 1] + 1)in beiden Wörtern weitergehen: die Zelle links darüber, plus 1, wenn die beiden Buchstaben verschieden sind (
row[j - 1] + …)
Die Antwort ist die letzte Zelle der letzten Zeile. Eine Zeile braucht nur die Zeile über ihr, also behält die Funktion zwei Zeilen statt der ganzen Tabelle.
didYouMean() misst jeden Kandidaten und nimmt den nächsten. Ein Fall kommt dem Zählen zuvor: Ein Kandidat, der mit dem Getippten beginnt, hat die Distanz 0. saw ist fünf Buchstaben von sawtooth entfernt, und trotzdem kann nichts anderes gemeint sein. Das nächste Wort wird nur vorgeschlagen, wenn es nah ist: höchstens 2 Änderungen, oder ein Drittel der Länge des getippten Worts, wenn das mehr ist. Für wave: 'noise' wird nichts vorgeschlagen.
Der dritte Block ist die Prüfung selbst:
/** The options of a unit: what the code gave, checked against the schema, on top of the defaults. */
function readOptions(type: string, spec: UnitType, given: unknown): Options {
if (given !== undefined && (typeof given !== 'object' || given === null)) {
throw new ScriptError(`${type}() takes its options in braces, like ${type}({ volume: 0.5 })`);
}
const names = Object.keys(spec.options);
for (const name of Object.keys(given ?? {})) {
if (!names.includes(name)) throw new ScriptError(`${type} has no option "${name}".${didYouMean(name, names)}`);
}
const options: Options = {};
for (const [name, option] of Object.entries(spec.options)) {
const value = (given as Record<string, unknown> | undefined)?.[name];
options[name] = value === undefined ? option.default : readValue(`${name} of ${type}`, option, value);
}
return options;
}
function readValue(what: string, option: UnitType['options'][string], value: unknown): Value {
if (typeof option.default === 'number') {
if (typeof value !== 'number' || Number.isNaN(value)) {
throw new ScriptError(`${what} needs a number, but got ${JSON.stringify(value)}`);
}
// A number outside its range is moved to the nearest end of it.
return Math.min(option.max ?? Infinity, Math.max(option.min ?? -Infinity, value));
}
if (typeof value !== 'string') throw new ScriptError(`${what} needs a text, but got ${JSON.stringify(value)}`);
if (option.choices && !option.choices.includes(value)) {
throw new ScriptError(
`${what} can be ${option.choices.join(', ')}, but not "${value}".${didYouMean(value, option.choices)}`,
);
}
return value;
}readOptions() fragt drei Dinge. Sind die Optionen überhaupt ein Objekt: Auf monoSynth(300) antwortet es mit monoSynth() takes its options in braces, like monoSynth({ volume: 0.5 }). Steht jeder Name im Schema: Wenn nicht, lautet die Meldung monoSynth has no option "cutof". Did you mean cutoff?. Und passt jeder Wert, das ist die Aufgabe von readValue().
Das Schema hat kein Feld für den Typ einer Option. Ihr Standardwert sagt ihn: Eine Option, deren Standardwert eine Zahl ist, nimmt Zahlen. Ein Text, wo eine Zahl hingehört, ergibt cutoff of monoSynth needs a number, but got "high". Eine Zahl außerhalb ihres Bereichs ist kein Fehler. Sie wird ans nächste Ende des Bereichs geschoben, aus cutoff: 20000 wird also 8000. Während du spielst, soll dich ein zu hoher Wert nicht den Durchlauf kosten. Ein Text muss eine der Auswahlmöglichkeiten sein, wenn das Schema welche nennt: wave of monoSynth can be sawtooth, square, triangle, sine, but not "saw". Did you mean sawtooth?
All das wird als ScriptError geworfen, wie die Fehler, die to() seit Teil 9 findet, etwa drums gives audio, but drums takes notes für kit.to(kit). Ein ScriptError ist eine Meldung, die für den geschrieben ist, der den Song tippt. Sie wird gezeigt, wie sie ist.
Die Zeile finden
Eine Meldung sagt, was falsch ist. In einem Song von dreißig Zeilen willst du auch wissen, wo. Jeder Fehler trägt einen stack: einen Text, der die Funktionen auflistet, die liefen, als der Fehler entstand, die innerste zuerst, jede mit Datei, Zeile und Spalte. Der Code des Editors lief als Funktion, die mit new Function gemacht wurde, und die hat keine Datei. Chrome schreibt an ihre Stelle <anonymous>, im Eintrag für den Code des Editors steht also: <anonymous>:9:14. Zeile 9, Spalte 14. Der vierte Block liest diese Zahl:
// ---------------------------------------------------------------------------
// Finding the line of an error
/** The line and column that a stack trace gives for code made with `new Function`. */
const FRAME = /(?:<anonymous>|> Function):(\d+):\d+/;
function frameLine(error: unknown): number | undefined {
const frame = FRAME.exec(error instanceof Error ? (error.stack ?? '') : '');
return frame ? Number(frame[1]) : undefined;
}
/**
* The number an engine gives the first line of a function's body. The engines put a
* different number of lines in front of it, so we ask: an error in a body's first line.
*/
const FIRST_LINE = (() => {
try {
new Function('throw new Error()')();
} catch (error) {
return frameLine(error);
}
return undefined;
})();
/** The line of the code in which an error happened, counted from 1. */
function lineOf(error: unknown): number | undefined {
const line = frameLine(error);
return line === undefined || FIRST_LINE === undefined ? undefined : line - FIRST_LINE + 1;
}Der reguläre Ausdruck FRAME sucht nach <anonymous>: oder > Function:, gefolgt von zwei Zahlen mit einem Doppelpunkt dazwischen, und behält die erste Zahl, die Zeile. Die erste Form ist die von Chrome. Die zweite ist für Firefox gedacht und ungetestet: Ausprobiert wurde diese Serie nur in Chrome. Wo die Suche nichts findet, wird die Meldung ohne Zeile gezeigt.
exec() liefert den ersten Treffer, und der Stack nennt die innerste Funktion zuerst. Ein Fehler, den readOptions() wirft, hat oben Einträge aus den eigenen Dateien des Projekts. Die tragen die Adresse einer Datei, wo der Ausdruck <anonymous> verlangt. Der erste Treffer ist also die Zeile im Code des Editors, die den Aufruf gemacht hat. Das ist die Zeile, die du suchst: die mit monoSynth({ cutof: 300 }) darin.
Die Zahl ist noch nicht die Zeile im Editor. Um aus einem Text eine Funktion zu machen, schreibt die JavaScript-Engine des Browsers den Kopf einer Funktion davor, und der Kopf belegt eigene Zeilen. In Chrome zählt die erste Zeile des Rumpfs als Zeile 3. Es wäre schnell getan, 2 abzuziehen, aber die Engine eines anderen Browsers kann eine andere Zahl von Zeilen davorsetzen, und dann säße jede Markierung in der falschen Zeile.
Deshalb wird FIRST_LINE gemessen und nicht angenommen. Beim Laden der Datei wird eine Funktion gemacht, deren Rumpf in seiner ersten Zeile einen Fehler wirft, und die Zeile aus dem Stack dieses Fehlers gelesen. Welche Zahl auch herauskommt, es ist die Zahl, die diese JavaScript-Engine der Zeile 1 gibt. lineOf() zieht sie ab: Ein Fehler, den Chrome in Zeile 9 meldet, steht in Zeile 9 − 3 + 1 = 7 des Editors. Die Wörter "use strict";, die runScript() vor den Code setzt, stehen in derselben Zeile wie die erste Zeile des Codes und verschieben also nichts.
Hat der Stack keinen solchen Eintrag, liefert lineOf() undefined, und die Meldung wird ohne Zeile gezeigt.
Den Code ausführen, alles abfangen
Der fünfte und letzte Block führt den Code aus:
// ---------------------------------------------------------------------------
// Running the code
/** Turns a value into the text `console.log` shows for it. */
function show(value: unknown): string {
if (typeof value === 'string') return value;
if (value instanceof Handle) return `[${value.id}]`;
try {
return JSON.stringify(value) ?? String(value);
} catch {
return String(value);
}
}
/** Runs the code and gives back the patch it describes. Never throws. */
export function runScript(code: string): Outcome {
const patch: Patch = { bpm: 120, units: [], cables: [] };
const counts: Record<string, number> = {};
const logs: string[] = [];
/** Adds a unit to the patch. */
function create(type: string, given: unknown): Handle {
const spec = UNITS[type];
const options = readOptions(type, spec, given);
counts[type] = (counts[type] ?? 0) + 1;
const id = `${type}${counts[type]}`;
patch.units.push({ id, type, options });
return new Handle(id, type, spec, patch);
}
/** Everything the code can use, by name. */
const api: Record<string, unknown> = {
out: new Handle('out', 'out', OUT, patch),
bpm(value: unknown) {
if (typeof value !== 'number' || Number.isNaN(value)) {
throw new ScriptError(`bpm() needs a number, but got ${JSON.stringify(value)}`);
}
patch.bpm = Math.min(240, Math.max(40, value));
},
// The code's own console: what it logs is shown on the page.
console: {
log(...values: unknown[]) {
if (logs.length < 100) logs.push(values.map(show).join(' '));
},
},
};
for (const type of Object.keys(UNITS)) api[type] = (options?: unknown) => create(type, options);
// A pattern takes its text first. Reading it here finds mistakes before anything plays.
api.pattern = (source: unknown, options?: unknown) => {
if (typeof source !== 'string') throw new ScriptError(`pattern() needs its notes as a text, like pattern('bd sd')`);
try {
mini(source);
} catch (error) {
if (error instanceof MiniError) throw new ScriptError(`${error.message} at character ${error.position + 1} of "${source}"`);
throw error;
}
const handle = create('pattern', options);
patch.units[patch.units.length - 1].options.source = source;
return handle;
};
try {
// The code becomes the body of a function whose parameters are the names of the API.
const run = new Function(...Object.keys(api), `"use strict";${code}`);
run(...Object.values(api));
return { ok: true, patch, logs };
} catch (error) {
const message = error instanceof ScriptError ? error.message : String(error);
return { ok: false, message, line: lineOf(error), logs };
}
}Gegenüber Teil 9 sind vier Dinge anders.
create()bekommt seine Optionen vonreadOptions(), das wirft, bevor der Baustein angelegt wird, wenn mit ihnen etwas nicht stimmt.bpm()undpattern()bestehen auf dem, was sie brauchen. Ausbpm('fast')wurde bisher wortlos 120, jetzt ergibt esbpm() needs a number, but got "fast". Der Text eines Patterns wird nicht mehr unter die Optionen gemischt, bevor sie geprüft sind. Er wird in den Baustein geschrieben, nachdemcreate()ihn angelegt hat.Der Code bekommt eine eigene
console. Sie ist ein Eintrag der API wie die anderen und wird damit ein Parameter der Funktion, der dieconsoledes Browsers mit demselben Namen verdeckt. Ihrlog()sammelt bis zu 100 Zeilen.show()macht aus jedem Wert einen Text: Ein Text bleibt, wie er ist, ein Baustein wird zu seiner ID in eckigen Klammern, alles andere zu JSON.console.log(bass)zeigt also[monoSynth1], die ID, unter der die Engine aus Teil 10 den Bass kennt.Das Erzeugen der Funktion und ihr Aufruf stehen in einem
try. Was auch schiefgeht, endet alsOutcome. EinScriptErrorgibt seine Meldung, wie sie ist. Jeder andere Fehler ist einer, den JavaScript gefunden hat, undString(error)setzt seinen Namen davor:ReferenceError: kitt is not defined.
Syntaxfehler
Eine Art von Fehler hat keine Zeile in ihrem Stack. Ist der Code gar kein JavaScript, etwa weil eine Klammer fehlt, wirft schon new Function einen SyntaxError, bevor eine Zeile des Codes lief. Keine Funktion des Codes lief, also hat der Stack keinen Eintrag für ihn. In Chrome steht im Stack nur at new Function (<anonymous>), ohne Zahlen, und FRAME findet nichts. Die Meldung sagt, was JavaScript erwartet hat, aber nicht, wo.
Der Editor weiß, wo. CodeMirror färbt den Code mit einem eigenen Parser ein, und der ist für Code gemacht, der gerade getippt wird und deshalb die meiste Zeit kaputt ist. Wo der Text nicht zur Sprache passt, setzt er einen Fehlerknoten in seinen Baum und liest weiter. Der erste Fehlerknoten ist die Stelle.
Zwei weitere Pakete von CodeMirror geben Zugriff auf den Baum und auf Markierungen im Text. Beide liegen schon in node_modules, weil der Editor aus ihnen besteht. Wenn du sie ausdrücklich installierst, stehen sie in package.json, und das Projekt stützt sich nicht auf Pakete, die es nie verlangt hat:
$ npm install @codemirror/language @codemirror/lintup to date, audited 37 packages in 443ms
Ergänze in src/editor.ts zwei Funktionen am Ende der Datei. Sie brauchen zwei Importe unter dem von javascript: ensureSyntaxTree aus @codemirror/language sowie setDiagnostics und den Typ Diagnostic aus @codemirror/lint:
/** Underlines a line of the code and shows the message on it. Without a line, takes the mark away. */
export function markError(view: EditorView, message?: string, line?: number) {
const diagnostics: Diagnostic[] = [];
if (message !== undefined && line !== undefined && line >= 1 && line <= view.state.doc.lines) {
const { from, to } = view.state.doc.line(line);
diagnostics.push({ from, to, severity: 'error', message });
}
view.dispatch(setDiagnostics(view.state, diagnostics));
}
/**
* The line of the first place where the code isn't JavaScript. The editor's own parser
* knows: it reads on after a mistake and leaves a mark in its tree.
*/
export function syntaxErrorLine(view: EditorView): number | undefined {
const tree = ensureSyntaxTree(view.state, view.state.doc.length, 500);
let position: number | undefined;
tree?.iterate({
enter(node) {
if (position !== undefined) return false;
if (node.type.isError) position = node.from;
return undefined;
},
});
return position === undefined ? undefined : view.state.doc.lineAt(position).number;
}Ein Diagnostic ist bei CodeMirror eine Anmerkung zu einem Stück des Texts: wo es beginnt und endet, wie schwer sie wiegt, und eine Meldung. setDiagnostics() ersetzt alle auf einmal. Steht eines in der Liste, wird die Zeile rot unterstrichen, und die Meldung erscheint, wenn die Maus darauf ruht. Eine leere Zeile hat nichts zum Unterstreichen und bekommt stattdessen eine kleine rote Marke an ihrem Anfang. Mit einer leeren Liste verschwindet die Markierung. Die Zeile wird vorher gegen die Länge des Texts geprüft, denn doc.line() wirft bei einer Zeile, die es nicht gibt.
syntaxErrorLine() fragt nach dem Baum. Der Editor parst nur so weit, wie er muss, also sagt ihm ensureSyntaxTree(), dass er bis zum Ende des Texts fertig werden soll, und gibt ihm dafür eine halbe Sekunde. iterate() läuft durch den Baum und ruft enter für jeden Knoten auf. Der erste Knoten, dessen Typ ein Fehler ist, liefert die Position, und false hält den Lauf danach davon ab, tiefer zu gehen.
Ein Worker mit Zeitlimit
Bleibt die Schleife, die nie endet. Sie wirft keinen Fehler, den man abfangen könnte. Das JavaScript einer Seite läuft in einem einzigen Thread, und dieser Thread kümmert sich auch um die Klicks und um den Timer der Uhr. Eine Schleife, die nicht endet, gibt ihn nie zurück, und die Seite hat kein Mittel, laufenden Code anzuhalten.
Ein Worker ist ein zweiter Thread: ein Skript, das neben der Seite läuft, keinen Zugriff auf die Seite hat und nur über Nachrichten mit ihr spricht. Und einen Worker kann man von außen beenden, mit terminate(), egal was er gerade tut. Also zieht der Code des Editors in einen Worker um. Die Seite wartet auf die Antwort, und wenn in 3 Sekunden keine kommt, beendet sie den Worker.
Das geht wegen einer Entscheidung aus Teil 9: Den Code auszuführen macht keinen Ton. Es ergibt einen Patch, und ein Patch besteht aus reinen Daten, die man als Nachricht schicken kann. Der Worker braucht kein Audio und keine Seite. Lege src/worker.ts an:
import { runScript, type Outcome } from './script.ts';
export interface Request {
id: number;
code: string;
}
export type Reply = Outcome & { id: number };
// A worker has no page: all it does is run the code it is sent, and send back what came of it.
self.addEventListener('message', (event: MessageEvent<Request>) => {
const reply: Reply = { ...runScript(event.data.code), id: event.data.id };
self.postMessage(reply);
});Der Worker importiert src/script.ts und damit auch den Parser der Patterns und das Schema. Der Code des Editors läuft ab jetzt hier, und auch FIRST_LINE wird hier gemessen, dort, wo der Code läuft. Jede Anfrage trägt eine Nummer, und die Antwort trägt sie zurück, damit die Seite weiß, zu welchem Durchlauf eine Antwort gehört.
Das Gegenstück läuft in der Seite. Lege src/runner.ts an:
import type { Outcome } from './script.ts';
import type { Reply, Request } from './worker.ts';
/** Longer than any song's code takes. Whatever runs longer is most likely an endless loop. */
const TIMEOUT = 3000;
let worker: Worker | undefined;
let lastId = 0;
const waiting = new Map<number, (outcome: Outcome) => void>();
function getWorker(): Worker {
if (!worker) {
worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' });
worker.addEventListener('message', (event: MessageEvent<Reply>) => {
const { id, ...outcome } = event.data;
waiting.get(id)?.(outcome);
});
}
return worker;
}
/** Runs the code away from the page, in a worker. Always answers, even if the code never ends. */
export function run(code: string): Promise<Outcome> {
lastId += 1;
const id = lastId;
return new Promise((resolve) => {
const timer = window.setTimeout(() => {
// The only way to stop code that doesn't end: end the worker it runs in. The next
// run starts a new one.
worker?.terminate();
worker = undefined;
const seconds = TIMEOUT / 1000;
for (const answer of waiting.values()) {
answer({
ok: false,
message: `The code ran for more than ${seconds} seconds and was stopped. Is there a loop that never ends?`,
line: undefined,
logs: [],
});
}
}, TIMEOUT);
waiting.set(id, (outcome) => {
window.clearTimeout(timer);
waiting.delete(id);
resolve(outcome);
});
const request: Request = { id, code };
getWorker().postMessage(request);
});
}new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' }) ist die Form, nach der Vite sucht: Es findet die Datei und baut den Worker als eigenes Skript. Der Worker entsteht beim ersten Durchlauf und bleibt für die nächsten.
run() gibt ein Promise zurück. Es legt unter der Nummer der Anfrage eine Funktion in waiting ab, startet einen Timer von 3 Sekunden und schickt den Code los. Kommt die Antwort, hält die Funktion den Timer an und löst das Promise ein. Kommt der Timer zuerst, beendet er den Worker, vergisst ihn und beantwortet alles, was wartet, mit einer eigenen Meldung: The code ran for more than 3 seconds and was stopped. Is there a loop that never ends? Der nächste Durchlauf findet keinen Worker vor und startet einen neuen.
Auf der Seite zeigen
Die Seite muss jetzt auf den Worker warten, also werden run() und start() async, und das Ergebnis ist ein Outcome statt eines Patches oder eines Fehlers. Ersetze src/main.ts durch:
import { audio } from './audio.ts';
import { createEditor, markError, syntaxErrorLine } from './editor.ts';
import { Engine } from './engine.ts';
import { run as runCode } from './runner.ts';
import { SONG } from './song.ts';
import './style.css';
const engine = new Engine();
const play = document.querySelector<HTMLButtonElement>('#play')!;
const status = document.querySelector<HTMLElement>('#status')!;
const bpm = document.querySelector<HTMLSpanElement>('#bpm')!;
/** Runs the code in the editor. If it fails, what was playing plays on. */
async function run(): Promise<boolean> {
const outcome = await runCode(editor.state.doc.toString());
const lines = [...outcome.logs];
if (outcome.ok) {
const { kept, created, removed } = engine.apply(outcome.patch);
bpm.textContent = String(outcome.patch.bpm);
lines.push(`${outcome.patch.units.length} units: ${kept} kept, ${created} new, ${removed} removed`);
markError(editor);
} else {
// JavaScript doesn't say where code is that it couldn't read at all. The editor does.
const line = outcome.line ?? syntaxErrorLine(editor);
lines.push(line === undefined ? outcome.message : `Line ${line}: ${outcome.message}`);
markError(editor, outcome.message, line);
}
status.textContent = lines.join('\n');
status.classList.toggle('error', !outcome.ok);
status.scrollTop = status.scrollHeight;
return outcome.ok;
}
async function start() {
void audio().resume();
if (!engine.clock.playing && (await run())) engine.start();
showPlaying();
}
function stop() {
engine.stop();
showPlaying();
}
function showPlaying() {
play.textContent = engine.clock.playing ? '■ Stop' : '▶ Play';
play.classList.toggle('on', engine.clock.playing);
}
const editor = createEditor(document.querySelector<HTMLElement>('#editor')!, SONG, {
// Ctrl+Enter starts the music, or runs the changed code while it plays.
run: () => void (engine.clock.playing ? run() : start()),
stop,
});
play.addEventListener('click', () => void (engine.clock.playing ? stop() : start()));
document.querySelector<HTMLButtonElement>('#run')!.addEventListener('click', () => {
void (engine.clock.playing ? run() : start());
});
/** Shows where the music is, as bar.beat, once per frame. */
const position = document.querySelector<HTMLSpanElement>('#position')!;
function draw() {
const { clock } = engine;
const cycle = clock.playing ? Math.max(0, clock.cycleAt(audio().currentTime)) : 0;
position.textContent = `${Math.floor(cycle) + 1}.${Math.floor((cycle % 1) * 4) + 1}`;
requestAnimationFrame(draw);
}
draw();run() sammelt die Zeilen für die Leiste unter dem Editor: zuerst, was der Code ausgegeben hat, dann das Ergebnis. War der Durchlauf gut, geht der Patch wie bisher an die Engine, und markError(editor) ohne Meldung nimmt eine alte Markierung weg. War er es nicht, wird engine.apply() nicht aufgerufen, und was spielte, spielt weiter. Die Zeile kommt vom Skript, und wenn das Skript keine hat, vom Parser des Editors. Mit einer Zeile wird die Meldung als Line 7: … gezeigt, und die Zeile wird im Code markiert.
Die Aufrufer warten nicht auf das Promise. Das void vor den Aufrufen sagt, dass das so gemeint ist.
Die Leiste kann jetzt mehrere Zeilen fassen. Ersetze in src/style.css die Regel für .status:
.status {
min-height: 2.2em;
max-height: 6.4em;
overflow-y: auto;
padding: 6px 12px;
background: var(--night);
border-top: 2px solid var(--edge);
color: var(--muted);
white-space: pre-wrap;
}Sie wächst auf etwa vier Zeilen und scrollt danach. run() scrollt sie ans Ende, damit das Ergebnis immer zu sehen ist, unter allem, was der Code ausgegeben hat.
Probier es aus
Drück Play und mach den Song kaputt, während er spielt. Drück nach jeder Änderung Strg+Enter. Die Musik spielt jedes Mal weiter.
Ändere
cutoffin Zeile 7 incutof. Die Leiste zeigtLine 7: monoSynth has no option "cutof". Did you mean cutoff?, und Zeile 7 ist unterstrichen. Setz den Buchstaben wieder ein und führ den Code aus: Die Markierung ist weg, und die Leiste zeigt wieder die Zähler aus Teil 10.Schreib
cutoff: 'high':Line 7: cutoff of monoSynth needs a number, but got "high".Schreib
cutoff: 20000. Kein Fehler: Der Filter des Basses ruht so hoch, wie der Bereich es erlaubt, bei 8000 Hertz.Ändere Zeile 5 in
kit.to(kit):Line 5: drums gives audio, but drums takes notes. Mach die Änderung rückgängig.Lösch die letzte Klammer einer Zeile. Die Leiste zeigt einen
SyntaxError, mit einer Zeile, die der Parser des Editors gefunden hat. Setz die Klammer wieder ein.Wenn der Song wieder in Ordnung ist, ergänze
console.log(bass)als letzte Zeile. Über dem Ergebnis erscheint[monoSynth1].Ergänze
while (true) {}als letzte Zeile. Drei Sekunden lang passiert nichts, außer dass die Musik weiterspielt und der Zähler in der Kopfzeile weiterzählt. Dann zeigt die LeisteThe code ran for more than 3 seconds and was stopped. Is there a loop that never ends?Entferne die Schleife und führ den Code noch einmal aus: Er läuft wie zuvor.
Kommentare
Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.
Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.