Spaces:
Runtime error
Runtime error
| import type { AbcMark, AbcNote, AbcScore } from "@/lib/abc/model"; | |
| import { unitsPerBar } from "@/lib/abc/model"; | |
| import { accidentalsFor } from "@/lib/abc/parse"; | |
| /** | |
| * Writes the note model back out as ABC. | |
| * | |
| * Headers come through verbatim, so a rewrite can never reword the tune's | |
| * title, meter or key. Only the music is regenerated, and only from what the | |
| * grid actually holds. | |
| * | |
| * Simultaneous notes in one voice are emitted as chords, rests fill the gaps, | |
| * and a note crossing a bar line is tied across it rather than being truncated | |
| * or allowed to run past the barline, either of which would change the music. | |
| */ | |
| export function serializeAbc(score: AbcScore): string { | |
| const bar = unitsPerBar(score); | |
| const lines = [...score.header]; | |
| for (let voice = 0; voice < score.voices.length; voice++) { | |
| const meta = score.voices[voice]; | |
| lines.push(`V:${meta.id}${meta.rest ? ` ${meta.rest}` : ""}`); | |
| const notes = score.notes | |
| .filter((note) => note.voice === voice) | |
| .sort((a, b) => a.start - b.start || a.midi - b.midi); | |
| const marks = (score.marks ?? []) | |
| .filter((mark) => mark.voice === voice) | |
| .sort((a, b) => a.start - b.start); | |
| lines.push(...voiceLines(notes, marks, bar, score.key)); | |
| } | |
| return lines.join("\n"); | |
| } | |
| function voiceLines(notes: AbcNote[], marks: AbcMark[], bar: number, key: string): string[] { | |
| if (!notes.length) return ["z8 |"]; | |
| // Chord symbols sit immediately before the note they belong to, which is | |
| // where ABC expects them and where a reader looks for them. | |
| const marksAt = new Map<number, AbcMark[]>(); | |
| for (const mark of marks) { | |
| const list = marksAt.get(mark.start); | |
| if (list) list.push(mark); | |
| else marksAt.set(mark.start, [mark]); | |
| } | |
| const emitted = new Set<number>(); | |
| const markToken = (at: number) => { | |
| if (emitted.has(at)) return ""; | |
| const list = marksAt.get(at); | |
| if (!list) return ""; | |
| emitted.add(at); | |
| return list.map((mark) => `"${mark.text}"`).join(""); | |
| }; | |
| // Accidentals carry to the end of the bar, so writing one changes how every | |
| // later note on that pitch reads. The serializer has to track exactly what | |
| // the parser will track, or a natural written after a sharp comes back as a | |
| // sharp. The fuzz test found this; the fixed cases never did, because they | |
| // happened not to put a natural after an accidental in one bar. | |
| const signature = accidentalsFor(key); | |
| let barAccidentals: Record<string, number> = {}; | |
| // Group by onset so a chord is written once rather than as stacked notes. | |
| const byStart = new Map<number, AbcNote[]>(); | |
| for (const note of notes) { | |
| const list = byStart.get(note.start); | |
| if (list) list.push(note); | |
| else byStart.set(note.start, [note]); | |
| } | |
| const onsets = [...byStart.keys()].sort((a, b) => a - b); | |
| const end = Math.max(...notes.map((note) => note.start + note.duration)); | |
| const totalBars = Math.max(1, Math.ceil(end / bar)); | |
| const out: string[] = []; | |
| let tokens: string[] = []; | |
| let cursor = 0; | |
| let index = 0; | |
| for (let barIndex = 0; barIndex < totalBars; barIndex++) { | |
| const barEnd = (barIndex + 1) * bar; | |
| const parts: string[] = []; | |
| barAccidentals = {}; | |
| while (index < onsets.length && onsets[index] < barEnd) { | |
| const start = onsets[index]; | |
| if (start > cursor) { | |
| parts.push(`z${lengthToken(start - cursor)}`); | |
| cursor = start; | |
| } | |
| const group = byStart.get(start)!; | |
| // A chord's length is its shortest member, so nothing in it overruns. | |
| const want = Math.min(...group.map((note) => note.duration)); | |
| // Split at the bar line and tie, so the written bar still adds up. | |
| const fits = Math.min(want, barEnd - start); | |
| parts.push( | |
| markToken(start) + chordToken(group, fits, key, barAccidentals, signature) + (fits < want ? "-" : ""), | |
| ); | |
| cursor = start + fits; | |
| if (fits < want) { | |
| // The remainder becomes a fresh onset in the next bar. | |
| const remainder = group.map((note) => ({ ...note, start: cursor, duration: want - fits })); | |
| const existing = byStart.get(cursor); | |
| if (existing) existing.push(...remainder); | |
| else { | |
| byStart.set(cursor, remainder); | |
| onsets.splice(index + 1, 0, cursor); | |
| } | |
| } | |
| index++; | |
| } | |
| if (cursor < barEnd && barIndex < totalBars) { | |
| const rest = barEnd - cursor; | |
| // Trailing silence past the last note is not worth writing. | |
| if (index < onsets.length || barIndex < totalBars - 1) { | |
| parts.push(`z${lengthToken(rest)}`); | |
| cursor = barEnd; | |
| } | |
| } | |
| if (parts.length) tokens.push(parts.join(" "), "|"); | |
| // Four bars to a line keeps the text readable next to the grid. | |
| if ((barIndex + 1) % 4 === 0 && tokens.length) { | |
| out.push(tokens.join(" ")); | |
| tokens = []; | |
| } | |
| } | |
| if (tokens.length) out.push(tokens.join(" ")); | |
| return out.length ? out : ["z8 |"]; | |
| } | |
| function chordToken( | |
| group: AbcNote[], | |
| duration: number, | |
| key: string, | |
| barAccidentals: Record<string, number>, | |
| signature: Record<string, number>, | |
| ): string { | |
| const spell = (note: AbcNote) => pitchToken(note.midi, key, barAccidentals, signature); | |
| if (group.length === 1) return spell(group[0]) + lengthToken(duration); | |
| return `[${group.map(spell).join("")}]${lengthToken(duration)}`; | |
| } | |
| const SHARP_SPELLING = ["C", "^C", "D", "^D", "E", "F", "^F", "G", "^G", "A", "^A", "B"]; | |
| const FLAT_SPELLING = ["C", "_D", "D", "_E", "E", "F", "_G", "G", "_A", "A", "_B", "B"]; | |
| /** | |
| * Spells a MIDI note, writing an accidental whenever one is needed to be read | |
| * back as this exact pitch. | |
| * | |
| * "Needed" covers three cases, and missing any of them silently transposes a | |
| * note on the next parse: the pitch is a black key; the key signature already | |
| * alters this letter and we want the natural; or an accidental earlier in this | |
| * bar altered it and we want something else now. The last two both require an | |
| * explicit natural sign, which is easy to forget because the note itself has | |
| * no accidental in it. | |
| */ | |
| function pitchToken( | |
| midi: number, | |
| key: string, | |
| barAccidentals: Record<string, number>, | |
| signature: Record<string, number>, | |
| ): string { | |
| const flats = /b/.test(key) || /^(F|Dm|Gm|Cm|Fm|Bbm|Ebm)\b/.test(key.trim()); | |
| const spelling = flats ? FLAT_SPELLING : SHARP_SPELLING; | |
| const step = spelling[((midi % 12) + 12) % 12]; | |
| const letter = step.replace(/[\^_]/, ""); | |
| const wanted = step.startsWith("^") ? 1 : step.startsWith("_") ? -1 : 0; | |
| const octave = Math.floor(midi / 12) - 1; | |
| const slot = `${letter}${octave}`; | |
| const inForce = slot in barAccidentals ? barAccidentals[slot] : (signature[letter] ?? 0); | |
| let mark = ""; | |
| if (wanted !== inForce) { | |
| mark = wanted === 1 ? "^" : wanted === -1 ? "_" : "="; | |
| barAccidentals[slot] = wanted; | |
| } | |
| // Lower case is the octave above upper case. | |
| const body = octave >= 5 ? letter.toLowerCase() + "'".repeat(octave - 5) : letter + ",".repeat(Math.max(0, 4 - octave)); | |
| return mark + body; | |
| } | |
| /** Writes a length in units the way ABC spells it. */ | |
| function lengthToken(units: number): string { | |
| if (Math.abs(units - 1) < 1e-9) return ""; | |
| if (units >= 1 && Math.abs(units - Math.round(units)) < 1e-9) return String(Math.round(units)); | |
| // Halves and quarters have their own shorthand; anything else is a fraction. | |
| const rounded = Math.round(units * 16) / 16; | |
| if (Math.abs(rounded - 0.5) < 1e-9) return "/"; | |
| if (Math.abs(rounded - 0.25) < 1e-9) return "//"; | |
| for (let denominator = 2; denominator <= 16; denominator++) { | |
| const numerator = rounded * denominator; | |
| if (Math.abs(numerator - Math.round(numerator)) < 1e-9) { | |
| const top = Math.round(numerator); | |
| return top === 1 ? `/${denominator}` : `${top}/${denominator}`; | |
| } | |
| } | |
| return String(Math.max(1, Math.round(units))); | |
| } | |
| /** Exposed for the round-trip tests only. */ | |
| export const __testables = { lengthToken, pitchToken }; | |