@scorelabs/core 1.0.1

package/dist/models/Pitch.js

@@ -0,0 +1,110 @@
+import { Clef } from './types';
+/**
+ * Pitch representation using MIDI numbers and explicit spelling (step, alter, octave).
+ */
+export class Pitch {
+    midiNumber;
+    step; // 0=C, 1=D, 2=E, 3=F, 4=G, 5=A, 6=B
+    alter; // -1=flat, 0=natural, 1=sharp, etc.
+    octave;
+    constructor(midiNumber, step, alter, octave) {
+        this.midiNumber = midiNumber;
+        if (step !== undefined && alter !== undefined && octave !== undefined) {
+            this.step = step;
+            this.alter = alter;
+            this.octave = octave;
+        }
+        else {
+            // Default spelling based on MIDI number (favors sharps)
+            this.octave = Math.floor(midiNumber / 12) - 1;
+            const chromaticToDiatonic = [0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6];
+            this.step = chromaticToDiatonic[midiNumber % 12];
+            const diatonicToChromatic = [0, 2, 4, 5, 7, 9, 11];
+            this.alter = (midiNumber % 12) - diatonicToChromatic[this.step];
+        }
+    }
+    getNoteName() {
+        const noteNames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+        return noteNames[this.midiNumber % 12];
+    }
+    getOctave() {
+        return this.octave;
+    }
+    getStaffPosition(clef) {
+        const middleLineAbsStep = {
+            [Clef.Treble]: 4 * 7 + 6, // B4
+            [Clef.Bass]: 3 * 7 + 1, // D3
+            [Clef.Alto]: 4 * 7 + 0, // C4
+            [Clef.Tenor]: 3 * 7 + 5, // A3
+            [Clef.Percussion]: 4 * 7 + 6, // B4
+            [Clef.Tab]: 4 * 7 + 0, // C4
+        };
+        const referenceAbsStep = middleLineAbsStep[clef];
+        return this.getAbsoluteDiatonicStep() - referenceAbsStep;
+    }
+    getAbsoluteDiatonicStep() {
+        return this.octave * 7 + this.step;
+    }
+    getDiatonicStep() {
+        return this.step;
+    }
+    transposeDiatonic(steps) {
+        const totalSteps = this.octave * 7 + this.step + steps;
+        const newOctave = Math.floor(totalSteps / 7);
+        const newStep = ((totalSteps % 7) + 7) % 7;
+        const diatonicToChromatic = [0, 2, 4, 5, 7, 9, 11];
+        const newMidi = (newOctave + 1) * 12 + diatonicToChromatic[newStep];
+        return new Pitch(newMidi, newStep, 0, newOctave);
+    }
+    withEnharmonicNext() {
+        const diatonicToChromatic = [0, 2, 4, 5, 7, 9, 11];
+        const candidates = [];
+        for (let o = this.octave - 1; o <= this.octave + 1; o++) {
+            for (let s = 0; s < 7; s++) {
+                const baseMidi = (o + 1) * 12 + diatonicToChromatic[s];
+                const diff = this.midiNumber - baseMidi;
+                if (Math.abs(diff) <= 2) {
+                    candidates.push({ step: s, alter: diff, octave: o });
+                }
+            }
+        }
+        candidates.sort((a, b) => a.octave * 7 + a.step - (b.octave * 7 + b.step));
+        const currentIndex = candidates.findIndex((c) => c.step === this.step && c.alter === this.alter && c.octave === this.octave);
+        const nextIndex = (currentIndex + 1) % candidates.length;
+        const next = candidates[nextIndex];
+        return new Pitch(this.midiNumber, next.step, next.alter, next.octave);
+    }
+    static fromNoteName(note, octave) {
+        const baseSteps = {
+            C: 0, D: 1, E: 2, F: 3, G: 4, A: 5, B: 6,
+        };
+        const stepLabel = note[0].toUpperCase();
+        const step = baseSteps[stepLabel] ?? 0;
+        let alter = 0;
+        if (note.includes('#'))
+            alter = note.split('#').length - 1;
+        if (note.includes('b'))
+            alter = -(note.split('b').length - 1);
+        if (note.includes('x'))
+            alter = (note.split('x').length - 1) * 2;
+        const diatonicToChromatic = [0, 2, 4, 5, 7, 9, 11];
+        const midiNumber = (octave + 1) * 12 + diatonicToChromatic[step] + alter;
+        return new Pitch(midiNumber, step, alter, octave);
+    }
+    static fromStaffPosition(clef, staffPosition) {
+        const middleLineAbsStep = {
+            [Clef.Treble]: 4 * 7 + 6, // B4
+            [Clef.Bass]: 3 * 7 + 1, // D3
+            [Clef.Alto]: 4 * 7 + 0, // C4
+            [Clef.Tenor]: 3 * 7 + 5, // A3
+            [Clef.Percussion]: 4 * 7 + 0,
+            [Clef.Tab]: 4 * 7 + 0,
+        };
+        const targetAbsStep = middleLineAbsStep[clef] + staffPosition;
+        const newOctave = Math.floor(targetAbsStep / 7);
+        const newStep = ((targetAbsStep % 7) + 7) % 7;
+        const diatonicToChromatic = [0, 2, 4, 5, 7, 9, 11];
+        const newMidi = (newOctave + 1) * 12 + diatonicToChromatic[newStep];
+        return new Pitch(newMidi, newStep, 0, newOctave);
+    }
+}

package/dist/models/Score.d.ts

@@ -0,0 +1,71 @@
+import { TimeSignature, KeySignature, Duration, Genre } from './types';
+import { Part, PartJSON } from './Part';
+import { Staff } from './Staff';
+import { NoteSet } from './NoteSet';
+import { Measure } from './Measure';
+/**
+ * Represents a complete musical score.
+ */
+export declare class Score {
+    readonly title: string;
+    readonly composer: string;
+    readonly timeSignature: TimeSignature;
+    readonly keySignature: KeySignature;
+    readonly parts: Part[];
+    readonly bpm: number;
+    readonly tempoDuration: Duration;
+    readonly tempoIsDotted: boolean;
+    readonly copyright: string;
+    readonly lyricist: string;
+    readonly swing: boolean;
+    readonly subtitle: string;
+    readonly genre: Genre | string;
+    constructor(title: string, composer: string, timeSignature: TimeSignature, keySignature: KeySignature, parts: Part[], bpm?: number, tempoDuration?: Duration, tempoIsDotted?: boolean, copyright?: string, lyricist?: string, swing?: boolean, subtitle?: string, genre?: Genre | string);
+    withTitle(title: string): Score;
+    withComposer(composer: string): Score;
+    withSubtitle(subtitle: string): Score;
+    withGenre(genre: Genre | string): Score;
+    getMeasureCount(): number;
+    getTimeSignatureAt(measureIndex: number): TimeSignature;
+    getKeySignatureAt(measureIndex: number): KeySignature;
+    getAllStaves(): {
+        partIndex: number;
+        staffIndex: number;
+        staff: Staff;
+    }[];
+    static empty(): Score;
+    static fromJSON(data: ScoreJSON): Score;
+    transpose(semitones: number): Score;
+    replaceNote(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newNote: NoteSet, voiceIndex?: number): Score;
+    replaceMeasure(partIndex: number, staffIndex: number, measureIndex: number, newMeasure: Measure, autoBeam?: boolean): Score;
+    deleteNote(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, voiceIndex?: number): Score;
+    changeNoteDuration(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Score;
+    pasteNotes(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, notesToPaste: NoteSet[]): Score;
+    withTempo(bpm: number, duration: Duration, isDotted: boolean): Score;
+    withSwing(swing: boolean): Score;
+    withLyricist(lyricist: string): Score;
+    withCopyright(copyright: string): Score;
+    toJSON(): ScoreJSON;
+    replacePart(partIndex: number, newPart: Part): Score;
+    addPart(newPart: Part): Score;
+    removePart(partIndex: number): Score;
+    replaceStaff(partIndex: number, staffIndex: number, newStaff: Staff): Score;
+    addMeasure(index: number, measure: Measure): Score;
+    deleteMeasure(index: number): Score;
+    getPlaybackSequence(): number[];
+}
+export interface ScoreJSON {
+    title: string;
+    composer: string;
+    timeSignature: TimeSignature;
+    keySignature: KeySignature;
+    parts: PartJSON[];
+    bpm?: number;
+    tempoDuration?: Duration;
+    tempoIsDotted?: boolean;
+    copyright?: string;
+    lyricist?: string;
+    swing?: boolean;
+    subtitle?: string;
+    genre?: Genre | string;
+}

package/dist/models/Score.js

@@ -0,0 +1,284 @@
+import { Duration, decomposeDuration, Genre } from './types';
+import { Part } from './Part';
+/**
+ * Represents a complete musical score.
+ */
+export class Score {
+    title;
+    composer;
+    timeSignature;
+    keySignature;
+    parts;
+    bpm;
+    tempoDuration;
+    tempoIsDotted;
+    copyright;
+    lyricist;
+    swing;
+    subtitle;
+    genre;
+    constructor(title, composer, timeSignature, keySignature, parts, bpm = 120, tempoDuration = Duration.Quarter, tempoIsDotted = false, copyright = '', lyricist = '', swing = false, subtitle = '', genre = Genre.Unknown) {
+        this.title = title;
+        this.composer = composer;
+        this.timeSignature = timeSignature;
+        this.keySignature = keySignature;
+        this.parts = parts;
+        this.bpm = bpm;
+        this.tempoDuration = tempoDuration;
+        this.tempoIsDotted = tempoIsDotted;
+        this.copyright = copyright;
+        this.lyricist = lyricist;
+        this.swing = swing;
+        this.subtitle = subtitle;
+        this.genre = genre;
+    }
+    withTitle(title) {
+        return new Score(title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    withComposer(composer) {
+        return new Score(this.title, composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    withSubtitle(subtitle) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, subtitle, this.genre);
+    }
+    withGenre(genre) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, genre);
+    }
+    getMeasureCount() {
+        return this.parts[0]?.getMeasureCount() ?? 0;
+    }
+    getTimeSignatureAt(measureIndex) {
+        let current = this.timeSignature;
+        const part = this.parts[0];
+        if (part && part.staves[0]) {
+            const measures = part.staves[0].measures;
+            for (let i = 0; i <= measureIndex && i < measures.length; i++) {
+                if (measures[i].timeSignature)
+                    current = measures[i].timeSignature;
+            }
+        }
+        return current;
+    }
+    getKeySignatureAt(measureIndex) {
+        let current = this.keySignature;
+        const part = this.parts[0];
+        if (part && part.staves[0]) {
+            const measures = part.staves[0].measures;
+            for (let i = 0; i <= measureIndex && i < measures.length; i++) {
+                if (measures[i].keySignature)
+                    current = measures[i].keySignature;
+            }
+        }
+        return current;
+    }
+    getAllStaves() {
+        const result = [];
+        this.parts.forEach((part, partIndex) => {
+            part.staves.forEach((staff, staffIndex) => {
+                result.push({ partIndex, staffIndex, staff });
+            });
+        });
+        return result;
+    }
+    static empty() {
+        return new Score('', '', { beats: 4, beatType: 4 }, { fifths: 0 }, []);
+    }
+    static fromJSON(data) {
+        const parts = data.parts.map((p) => Part.fromJSON(p));
+        return new Score(data.title, data.composer, data.timeSignature, data.keySignature, parts, data.bpm ?? 120, data.tempoDuration ?? Duration.Quarter, data.tempoIsDotted ?? false, data.copyright ?? '', data.lyricist ?? '', data.swing ?? false, data.subtitle ?? '', data.genre || Genre.Unknown);
+    }
+    transpose(semitones) {
+        const semitoneToFifths = {
+            0: 0, 1: 7, 2: 2, 3: -3, 4: 4, 5: -1, 6: 6, 7: 1, 8: -4, 9: 3, 10: -2, 11: 5
+        };
+        const normalizedSemitones = ((semitones % 12) + 12) % 12;
+        const fifthsChange = semitoneToFifths[normalizedSemitones];
+        let newFifths = this.keySignature.fifths + fifthsChange;
+        while (newFifths > 7)
+            newFifths -= 12;
+        while (newFifths < -7)
+            newFifths += 12;
+        return new Score(this.title, this.composer, this.timeSignature, { fifths: newFifths }, this.parts.map((p) => p.transpose(semitones)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    replaceNote(partIndex, staffIndex, measureIndex, noteIndex, newNote, voiceIndex = 0) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        const measure = this.parts[partIndex].staves[staffIndex].measures[measureIndex];
+        const updatedMeasure = measure.replaceNoteSet(noteIndex, newNote, voiceIndex);
+        return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
+    }
+    replaceMeasure(partIndex, staffIndex, measureIndex, newMeasure, autoBeam = true) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        let measureToUse = newMeasure;
+        if (autoBeam) {
+            const ts = this.getTimeSignatureAt(measureIndex);
+            measureToUse = newMeasure.autoBeam(ts);
+        }
+        const newParts = [...this.parts];
+        newParts[partIndex] = newParts[partIndex].replaceMeasure(staffIndex, measureIndex, measureToUse);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    deleteNote(partIndex, staffIndex, measureIndex, noteIndex, voiceIndex = 0) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        const measure = this.parts[partIndex].staves[staffIndex].measures[measureIndex];
+        const updatedMeasure = measure.deleteNote(noteIndex, voiceIndex);
+        return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
+    }
+    changeNoteDuration(partIndex, staffIndex, measureIndex, noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        const measure = this.parts[partIndex].staves[staffIndex].measures[measureIndex];
+        const updatedMeasure = measure.changeNoteDuration(noteIndex, newDuration, isDotted, voiceIndex);
+        return this.replaceMeasure(partIndex, staffIndex, measureIndex, updatedMeasure, true);
+    }
+    pasteNotes(partIndex, staffIndex, measureIndex, noteIndex, notesToPaste) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        let newScore = this;
+        let currentMeasureIdx = measureIndex;
+        let currentNoteIdx = noteIndex;
+        const queue = [...notesToPaste];
+        while (queue.length > 0) {
+            const noteToPaste = queue.shift();
+            const part = newScore.parts[partIndex];
+            if (!part)
+                break;
+            const staff = part.staves[staffIndex];
+            if (!staff || currentMeasureIdx >= staff.measures.length)
+                break;
+            const measure = staff.measures[currentMeasureIdx];
+            if (currentNoteIdx >= measure.notes.length) {
+                currentMeasureIdx++;
+                currentNoteIdx = 0;
+                queue.unshift(noteToPaste);
+                continue;
+            }
+            let available = 0;
+            for (let i = currentNoteIdx; i < measure.notes.length; i++)
+                available += measure.notes[i].getDurationValue();
+            const needed = noteToPaste.getDurationValue();
+            if (needed <= available + 0.001) {
+                newScore = newScore.changeNoteDuration(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, noteToPaste.duration, noteToPaste.isDotted);
+                newScore = newScore.replaceNote(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, noteToPaste);
+                currentNoteIdx++;
+            }
+            else {
+                const parts = decomposeDuration(available);
+                if (parts.length === 0) {
+                    currentMeasureIdx++;
+                    currentNoteIdx = 0;
+                    queue.unshift(noteToPaste);
+                    continue;
+                }
+                const fillPart = parts[0];
+                const filledNote = noteToPaste.withDuration(fillPart.duration, fillPart.isDotted).withTie(true);
+                newScore = newScore.changeNoteDuration(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, fillPart.duration, fillPart.isDotted);
+                newScore = newScore.replaceNote(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, filledNote);
+                const remainderParts = decomposeDuration(needed - fillPart.val);
+                const remainderNotes = remainderParts.map((p, idx) => {
+                    const isLast = idx === remainderParts.length - 1;
+                    return noteToPaste.withDuration(p.duration, p.isDotted).withTie(isLast ? !!noteToPaste.tie : true);
+                });
+                queue.unshift(...remainderNotes);
+                currentNoteIdx++;
+            }
+        }
+        return newScore;
+    }
+    withTempo(bpm, duration, isDotted) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, duration, isDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    withSwing(swing) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, swing, this.subtitle, this.genre);
+    }
+    withLyricist(lyricist) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, lyricist, this.swing, this.subtitle, this.genre);
+    }
+    withCopyright(copyright) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    toJSON() {
+        return {
+            title: this.title, composer: this.composer, timeSignature: this.timeSignature, keySignature: this.keySignature,
+            parts: this.parts.map((p) => p.toJSON()), bpm: this.bpm, tempoDuration: this.tempoDuration,
+            tempoIsDotted: this.tempoIsDotted, copyright: this.copyright, lyricist: this.lyricist,
+            swing: this.swing, subtitle: this.subtitle, genre: this.genre,
+        };
+    }
+    replacePart(partIndex, newPart) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        const newParts = [...this.parts];
+        newParts[partIndex] = newPart;
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    addPart(newPart) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, [...this.parts, newPart], this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    removePart(partIndex) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        const newParts = this.parts.filter((_, i) => i !== partIndex);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    replaceStaff(partIndex, staffIndex, newStaff) {
+        if (partIndex < 0 || partIndex >= this.parts.length)
+            return this;
+        const newParts = [...this.parts];
+        newParts[partIndex] = newParts[partIndex].replaceStaff(staffIndex, newStaff);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    addMeasure(index, measure) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.addMeasure(index, measure)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    deleteMeasure(index) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.deleteMeasure(index)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+    }
+    getPlaybackSequence() {
+        const measures = this.parts[0]?.staves[0]?.measures || [];
+        const sequence = [];
+        let i = 0;
+        let blockStart = 0;
+        const repeatCount = new Map();
+        while (i < measures.length) {
+            const m = measures[i];
+            if (m.repeats.some((r) => r.type === 'start'))
+                blockStart = i;
+            const endRepeat = m.repeats.find((r) => r.type === 'end');
+            let iteration = 1;
+            if (endRepeat)
+                iteration = (repeatCount.get(i) || 0) + 1;
+            else {
+                let nextEndIdx = -1;
+                for (let j = i; j < measures.length; j++) {
+                    if (measures[j].repeats.some((r) => r.type === 'end')) {
+                        nextEndIdx = j;
+                        break;
+                    }
+                }
+                if (nextEndIdx !== -1)
+                    iteration = (repeatCount.get(nextEndIdx) || 0) + 1;
+            }
+            if (m.volta && m.volta.number !== iteration) {
+                i++;
+                continue;
+            }
+            sequence.push(i);
+            if (endRepeat) {
+                const maxTimes = endRepeat.times || 2;
+                const currentCount = repeatCount.get(i) || 0;
+                if (currentCount + 1 < maxTimes) {
+                    repeatCount.set(i, currentCount + 1);
+                    i = blockStart;
+                    continue;
+                }
+                else
+                    repeatCount.set(i, 0);
+            }
+            i++;
+        }
+        return sequence;
+    }
+}

package/dist/models/Staff.d.ts

@@ -0,0 +1,36 @@
+import { Clef, Duration } from './types';
+import { Measure, MeasureJSON } from './Measure';
+import { Pitch } from './Pitch';
+import { Note } from './Note';
+/**
+ * Represents a single staff (one set of 5 lines with a clef).
+ */
+export declare class Staff {
+    readonly clef: Clef;
+    readonly measures: Measure[];
+    readonly lineCount: number;
+    readonly tuning?: Pitch[] | undefined;
+    constructor(clef: Clef, measures: Measure[], lineCount?: number, tuning?: Pitch[] | undefined);
+    getMeasureCount(): number;
+    static fromJSON(data: StaffJSON): Staff;
+    transpose(semitones: number): Staff;
+    replaceNote(measureIndex: number, noteIndex: number, newNote: Note, voiceIndex?: number): Staff;
+    replaceMeasure(measureIndex: number, newMeasure: Measure): Staff;
+    deleteNote(measureIndex: number, noteIndex: number, voiceIndex?: number): Staff;
+    changeNoteDuration(measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Staff;
+    toJSON(): StaffJSON;
+    withClef(clef: Clef): Staff;
+    withLineCount(lineCount: number): Staff;
+    withTuning(tuning: Pitch[]): Staff;
+    withMeasures(measures: Measure[]): Staff;
+    addMeasure(index: number, measure: Measure): Staff;
+    deleteMeasure(index: number): Staff;
+}
+export interface StaffJSON {
+    clef: string;
+    measures: MeasureJSON[];
+    lineCount?: number;
+    tuning?: {
+        midiNumber: number;
+    }[];
+}

package/dist/models/Staff.js

@@ -0,0 +1,89 @@
+import { Measure } from './Measure';
+import { Pitch } from './Pitch';
+/**
+ * Represents a single staff (one set of 5 lines with a clef).
+ */
+export class Staff {
+    clef;
+    measures;
+    lineCount;
+    tuning;
+    constructor(clef, measures, lineCount = 5, tuning) {
+        this.clef = clef;
+        this.measures = measures;
+        this.lineCount = lineCount;
+        this.tuning = tuning;
+    }
+    getMeasureCount() {
+        return this.measures.length;
+    }
+    static fromJSON(data) {
+        const measures = data.measures.map((m) => Measure.fromJSON(m));
+        const tuning = data.tuning?.map((t) => new Pitch(t.midiNumber));
+        return new Staff(data.clef, measures, data.lineCount ?? 5, tuning);
+    }
+    transpose(semitones) {
+        return new Staff(this.clef, this.measures.map((m) => m.transpose(semitones)), this.lineCount, this.tuning?.map((p) => new Pitch(p.midiNumber + semitones)));
+    }
+    replaceNote(measureIndex, noteIndex, newNote, voiceIndex = 0) {
+        if (measureIndex < 0 || measureIndex >= this.measures.length)
+            return this;
+        const newMeasures = [...this.measures];
+        newMeasures[measureIndex] = newMeasures[measureIndex].replaceNote(noteIndex, newNote, voiceIndex);
+        return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
+    }
+    replaceMeasure(measureIndex, newMeasure) {
+        if (measureIndex < 0 || measureIndex >= this.measures.length)
+            return this;
+        const newMeasures = [...this.measures];
+        newMeasures[measureIndex] = newMeasure;
+        return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
+    }
+    deleteNote(measureIndex, noteIndex, voiceIndex = 0) {
+        if (measureIndex < 0 || measureIndex >= this.measures.length)
+            return this;
+        const newMeasures = [...this.measures];
+        newMeasures[measureIndex] = newMeasures[measureIndex].deleteNote(noteIndex, voiceIndex);
+        return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
+    }
+    changeNoteDuration(measureIndex, noteIndex, newDuration, isDotted = false, voiceIndex = 0) {
+        if (measureIndex < 0 || measureIndex >= this.measures.length)
+            return this;
+        const newMeasures = [...this.measures];
+        newMeasures[measureIndex] = newMeasures[measureIndex].changeNoteDuration(noteIndex, newDuration, isDotted, voiceIndex);
+        return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
+    }
+    toJSON() {
+        return {
+            clef: this.clef,
+            measures: this.measures.map((m) => m.toJSON()),
+            lineCount: this.lineCount,
+            tuning: this.tuning?.map((p) => ({ midiNumber: p.midiNumber })),
+        };
+    }
+    withClef(clef) {
+        return new Staff(clef, this.measures, this.lineCount, this.tuning);
+    }
+    withLineCount(lineCount) {
+        return new Staff(this.clef, this.measures, lineCount, this.tuning);
+    }
+    withTuning(tuning) {
+        return new Staff(this.clef, this.measures, this.lineCount, tuning);
+    }
+    withMeasures(measures) {
+        return new Staff(this.clef, measures, this.lineCount, this.tuning);
+    }
+    addMeasure(index, measure) {
+        const newMeasures = [...this.measures];
+        const insertIndex = Math.min(Math.max(0, index), newMeasures.length);
+        newMeasures.splice(insertIndex, 0, measure);
+        return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
+    }
+    deleteMeasure(index) {
+        if (index < 0 || index >= this.measures.length)
+            return this;
+        const newMeasures = [...this.measures];
+        newMeasures.splice(index, 1);
+        return new Staff(this.clef, newMeasures, this.lineCount, this.tuning);
+    }
+}

package/dist/models/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './Pitch';
+export * from './Note';
+export * from './NoteSet';
+export * from './Measure';
+export * from './Staff';
+export * from './Part';
+export * from './Score';
+export * from './Instrument';

package/dist/models/index.js

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './Pitch';
+export * from './Note';
+export * from './NoteSet';
+export * from './Measure';
+export * from './Staff';
+export * from './Part';
+export * from './Score';
+export * from './Instrument';