@scorelabs/viewer 1.0.1

package/dist/models/Score.d.ts

@@ -0,0 +1,120 @@
+import { TimeSignature, KeySignature, Duration } from './types';
+import { Part, PartJSON } from './Part';
+import { Staff } from './Staff';
+import { Note } from './Note';
+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;
+    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);
+    withTitle(title: string): Score;
+    withComposer(composer: string): Score;
+    withSubtitle(subtitle: string): Score;
+    /**
+     * Get total number of measures in the score
+     */
+    getMeasureCount(): number;
+    /**
+     * Get the active time signature at a specific measure index.
+     */
+    getTimeSignatureAt(measureIndex: number): TimeSignature;
+    /**
+     * Get the active key signature at a specific measure index.
+     */
+    getKeySignatureAt(measureIndex: number): KeySignature;
+    /**
+     * Get all staves across all parts (flattened)
+     */
+    getAllStaves(): {
+        partIndex: number;
+        staffIndex: number;
+        staff: Staff;
+    }[];
+    /**
+     * Create a completely empty Score
+     */
+    static empty(): Score;
+    /**
+     * Create a Score from JSON data
+     */
+    static fromJSON(data: ScoreJSON): Score;
+    /**
+     * Create a Score from MusicXML string
+     */
+    static fromMusicXML(xmlString: string): Score;
+    /**
+     * Transpose the entire score by semitones.
+     * Returns a new Score with all notes transposed.
+     * Key signature is also adjusted.
+     */
+    transpose(semitones: number): Score;
+    /**
+     * Replaces a note and automatically updates beams in the affected measure.
+     */
+    replaceNote(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newNote: Note, voiceIndex?: number): Score;
+    /**
+     * Replaces a measure and optionally automatically updates beams.
+     */
+    replaceMeasure(partIndex: number, staffIndex: number, measureIndex: number, newMeasure: Measure, autoBeam?: boolean): Score;
+    /**
+     * Delete a note in a specific part/staff/measure
+     */
+    deleteNote(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, voiceIndex?: number): Score;
+    /**
+     * Change note duration in a specific part/staff/measure
+     */
+    changeNoteDuration(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Score;
+    /**
+     * Paste notes starting at a specific location, handling measure overflow
+     */
+    pasteNotes(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, notesToPaste: Note[]): Score;
+    /**
+     * Update tempo settings
+     */
+    withTempo(bpm: number, duration: Duration, isDotted: boolean): Score;
+    withSwing(swing: boolean): Score;
+    withLyricist(lyricist: string): Score;
+    withCopyright(copyright: string): Score;
+    /**
+     * Convert to JSON
+     */
+    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;
+    /**
+     * Returns an unrolled sequence of measure indices for playback,
+     * considering repeat markers and Voltas (endings).
+     */
+    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;
+}

package/dist/models/Staff.d.ts

@@ -0,0 +1,57 @@
+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);
+    /**
+     * Get total number of measures
+     */
+    getMeasureCount(): number;
+    /**
+     * Create a Staff from JSON data
+     */
+    static fromJSON(data: StaffJSON): Staff;
+    /**
+     * Transpose all measures in this staff by semitones
+     */
+    transpose(semitones: number): Staff;
+    /**
+     * Replace a note in a specific measure
+     */
+    replaceNote(measureIndex: number, noteIndex: number, newNote: Note, voiceIndex?: number): Staff;
+    replaceMeasure(measureIndex: number, newMeasure: Measure): Staff;
+    /**
+     * Delete a note in a specific measure
+     */
+    deleteNote(measureIndex: number, noteIndex: number, voiceIndex?: number): Staff;
+    /**
+     * Change note duration in a specific measure
+     */
+    changeNoteDuration(measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Staff;
+    /**
+     * Convert to JSON
+     */
+    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/__tests__/Note.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/models/__tests__/Pitch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/models/index.d.ts

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

package/dist/models/types.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Shared types and enums for the score viewer
+ */
+export declare enum StemDirection {
+    Up = "up",
+    Down = "down"
+}
+export declare enum Clef {
+    Treble = "treble",
+    Bass = "bass",
+    Alto = "alto",
+    Tenor = "tenor",
+    Percussion = "percussion",
+    Tab = "tab"
+}
+export declare enum Duration {
+    Whole = "whole",
+    Half = "half",
+    Quarter = "quarter",
+    Eighth = "eighth",
+    Sixteenth = "sixteenth",
+    ThirtySecond = "thirty-second",
+    SixtyFourth = "sixty-fourth",
+    OneHundredTwentyEighth = "one-hundred-twenty-eighth",
+    TwoHundredFiftySixth = "two-hundred-fifty-sixth"
+}
+export declare enum Accidental {
+    Sharp = "sharp",
+    Flat = "flat",
+    Natural = "natural",
+    DoubleSharp = "double-sharp",
+    DoubleFlat = "double-flat"
+}
+export declare enum Articulation {
+    Staccato = "staccato",
+    Accent = "accent",
+    Tenuto = "tenuto",
+    Marcato = "marcato",
+    Fermata = "fermata",
+    Staccatissimo = "staccatissimo"
+}
+export declare enum Bowing {
+    DownBow = "down-bow",
+    UpBow = "up-bow"
+}
+export declare enum NoteheadShape {
+    Normal = "normal",
+    Cross = "cross",// X shape (percussion, spoken)
+    Diamond = "diamond",// Harmonics
+    Slash = "slash",// Rhythmic notation
+    Triangle = "triangle",// Percussion
+    Square = "square"
+}
+export declare enum Dynamic {
+    PPP = "ppp",
+    PP = "pp",
+    P = "p",
+    MP = "mp",
+    MF = "mf",
+    F = "f",
+    FF = "ff",
+    FFF = "fff"
+}
+export interface TimeSignature {
+    beats: number;
+    beatType: number;
+}
+export interface KeySignature {
+    fifths: number;
+}
+export interface Tempo {
+    bpm: number;
+    duration: Duration;
+    isDotted: boolean;
+    text?: string;
+}
+export interface Slur {
+    placement: 'start' | 'stop';
+    direction?: 'up' | 'down';
+}
+export interface Tuplet {
+    actual: number;
+    normal: number;
+    type: 'start' | 'stop' | 'middle';
+}
+export declare enum HairpinType {
+    Crescendo = "crescendo",
+    Decrescendo = "decrescendo"
+}
+export interface Hairpin {
+    type: HairpinType;
+    placement: 'start' | 'stop';
+}
+export interface Repeat {
+    type: 'start' | 'end';
+    times?: number;
+}
+export interface Volta {
+    type: 'start' | 'stop';
+    number: number;
+}
+export declare enum GlissandoType {
+    Wavy = "wavy",
+    Straight = "straight"
+}
+export interface Glissando {
+    type: GlissandoType;
+    placement: 'start' | 'stop';
+}
+export declare enum Arpeggio {
+    Normal = "normal",
+    Up = "up",
+    Down = "down"
+}
+export declare enum OttavaType {
+    OttavaAlta = "8va",
+    OttavaBassa = "8vb",
+    QuindicesimaAlta = "15ma",
+    QuindicesimaBassa = "15mb"
+}
+export interface Ottava {
+    type: OttavaType;
+    placement: 'start' | 'stop';
+}
+export interface Pedal {
+    type: 'sustain' | 'una-corda';
+    placement: 'start' | 'stop';
+}
+export declare enum Ornament {
+    Trill = "trill",
+    Mordent = "mordent",
+    InvertedMordent = "inverted-mordent",
+    Turn = "turn",
+    InvertedTurn = "inverted-turn"
+}
+export declare const DURATION_VALUES: Record<Duration, number>;
+/**
+ * Decomposes a duration value (quarter = 1) into a list of duration/dot pairs.
+ */
+export declare function decomposeDuration(value: number): {
+    duration: Duration;
+    isDotted: boolean;
+    val: number;
+}[];
+export interface FretboardDot {
+    string: number;
+    fret: number;
+    label?: string;
+}
+export interface FretboardBarre {
+    fret: number;
+    startString: number;
+    endString: number;
+}
+export interface FretboardDiagram {
+    strings: number;
+    frets: number;
+    startingFret?: number;
+    dots: FretboardDot[];
+    barres?: FretboardBarre[];
+    openStrings?: number[];
+    mutedStrings?: number[];
+}

package/dist/new_score.json

@@ -0,0 +1,112 @@
+{
+  "title": "New Score",
+  "composer": "Anonymous",
+  "timeSignature": {
+    "beats": 4,
+    "beatType": 4
+  },
+  "keySignature": {
+    "fifths": 0
+  },
+  "bpm": 120,
+  "parts": [
+    {
+      "name": "Violin",
+      "staves": [
+        {
+          "clef": "treble",
+          "measures": [
+            {
+              "voices": [
+                [
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  }
+                ]
+              ]
+            },
+            {
+              "voices": [
+                [
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  }
+                ]
+              ]
+            },
+            {
+              "voices": [
+                [
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  }
+                ]
+              ]
+            },
+            {
+              "voices": [
+                [
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  },
+                  {
+                    "duration": "quarter",
+                    "isRest": true
+                  }
+                ]
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/dist/rendering/NoteRenderer.d.ts

@@ -0,0 +1,52 @@
+import { NoteLayout, MeasureLayout, StaffLayout } from '../layouts';
+/**
+ * Renders notes, rests, stems, beams, and related elements.
+ */
+export declare class NoteRenderer {
+    private ctx;
+    private staffLineSpacing;
+    private noteDotDistance;
+    private noteNameMode;
+    private musicFont;
+    constructor(ctx: CanvasRenderingContext2D, staffLineSpacing: number, noteDotDistance?: number, // Default distance
+    noteNameMode?: 'none' | 'alphabetical' | 'solfege', musicFont?: 'Standard' | 'Jazz');
+    /**
+     * Draw a single note with stem
+     */
+    drawNote(noteLayout: NoteLayout, skipStem?: boolean): void;
+    private drawFingering;
+    private drawFretNumber;
+    private drawLyric;
+    private drawChordSymbol;
+    private drawFretboardDiagram;
+    /**
+     * Draw note name above staff
+     */
+    private drawNoteName;
+    /**
+     * Draw a note stem
+     */
+    private drawStem;
+    private drawStaffText;
+    private drawGraceSlash;
+    /**
+     * Draw beams connecting notes in a beam group
+     */
+    drawBeamGroup(noteLayouts: NoteLayout[]): void;
+    /**
+     * Draw all notes in a measure, handling beam groups
+     */
+    drawMeasureNotes(measureLayout: MeasureLayout): void;
+    /**
+     * Draw connections (Ties and Slurs) for all notes in a staff layout
+     */
+    drawStaffConnections(staffLayout: StaffLayout): void;
+    private drawHairpin;
+    private drawTupletGroup;
+    private drawArticulation;
+    private drawGlissLine;
+    private drawArpeggio;
+    private drawOttavaLine;
+    private drawPedalLine;
+    private drawOrnament;
+}

package/dist/rendering/ScoreRenderer.d.ts

@@ -0,0 +1,35 @@
+import { Score } from '../models';
+import { ScoreLayout, LayoutConfig } from '../layouts';
+/**
+ * Main renderer that orchestrates all drawing operations.
+ */
+export declare class ScoreRenderer {
+    private ctx;
+    private staffRenderer;
+    private noteRenderer;
+    private config;
+    constructor(ctx: CanvasRenderingContext2D, config?: Partial<LayoutConfig>);
+    /**
+     * Render a specific page of the score
+     */
+    render(score: Score, layout: ScoreLayout, pageIndex?: number): void;
+    /**
+     * Draw part names for a system
+     */
+    private drawPartNames;
+    /**
+     * Render measure numbers for a system
+     */
+    private renderMeasureNumbers;
+    /**
+     * Draw title and composer
+     */
+    private drawTitle;
+    /**
+     * Render notes for a staff (including mid-measure signature changes)
+     */
+    private renderStaffNotes;
+    private drawSystemBrace;
+    private drawSystemText;
+    private drawRehearsalMark;
+}

package/dist/rendering/StaffRenderer.d.ts

@@ -0,0 +1,67 @@
+import { StaffLayout, TextStyle } from '../layouts';
+import { TimeSignature, KeySignature, Clef, Duration } from '../models/types';
+/**
+ * Renders staff lines, clefs, and signatures.
+ */
+export declare class StaffRenderer {
+    private ctx;
+    private staffLineSpacing;
+    private clefWidth;
+    private trebleClefYOffset;
+    private bassClefYOffset;
+    private musicFont;
+    private tempoStyle;
+    private clefKeySignatureSpacing;
+    private bassClefScale;
+    private trebleClefScale;
+    private clefLeftPadding;
+    constructor(ctx: CanvasRenderingContext2D, staffLineSpacing: number, clefWidth: number, trebleClefYOffset?: number, bassClefYOffset?: number, musicFont?: 'Standard' | 'Jazz', tempoStyle?: TextStyle, clefKeySignatureSpacing?: number, bassClefScale?: number, trebleClefScale?: number, clefLeftPadding?: number);
+    /**
+     * Draw the staff lines (5 horizontal lines)
+     */
+    drawStaffLines(layout: StaffLayout): void;
+    /**
+     * Draw the clef
+     */
+    drawClef(layout: StaffLayout): void;
+    private drawTabClef;
+    /**
+     * Draw time signature
+     */
+    /**
+     * Draw time signature
+     */
+    drawTimeSignature(layout: StaffLayout, timeSignature: TimeSignature, keySignature?: KeySignature): void;
+    /**
+     * Draw key signature
+     */
+    drawKeySignature(layout: StaffLayout, keySignature: KeySignature): number;
+    private getClefWidth;
+    private getKeySignatureWidth;
+    /**
+     * Draw key signature at a specific X position
+     */
+    drawKeySignatureAt(x: number, y: number, fifths: number, clef: Clef): void;
+    /**
+     * Draw time signature at a specific X position
+     */
+    drawTimeSignatureAt(x: number, y: number, beats: number, beatType: number): void;
+    /**
+     * Draw barlines
+     */
+    /**
+     * Draw barlines for the entire staff system, spanning across all staves.
+     * Draw barlines for multiple staves in a system
+     */
+    drawSystemBarlines(staffLayouts: StaffLayout[], totalMeasures?: number): void;
+    private drawRepeatBarline;
+    private drawVolta;
+    /**
+     * Draw ledger lines for notes outside the staff
+     */
+    drawLedgerLines(x: number, staffPosition: number, middleY: number): void;
+    /**
+     * Draw tempo marking
+     */
+    drawTempoMarking(layout: StaffLayout, bpm: number, duration: Duration, isDotted?: boolean, overrideX?: number): void;
+}

package/dist/rendering/glyphs/AccidentalGlyphs.d.ts

@@ -0,0 +1,5 @@
+import { Accidental } from '../../models/types';
+/**
+ * Draw an accidental
+ */
+export declare function drawAccidental(ctx: CanvasRenderingContext2D, x: number, y: number, accidental: Accidental, staffLineSpacing: number, color?: string): void;

package/dist/rendering/glyphs/ClefGlyphs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Clef rendering functions.
+ */
+/**
+ * Draw a treble clef (G-clef)
+ */
+export declare function drawTrebleClef(ctx: CanvasRenderingContext2D, x: number, y: number, staffLineSpacing: number, yOffsetFactor?: number, scaleFactor?: number): void;
+/**
+ * Draw a bass clef (F-clef)
+ */
+export declare function drawBassClef(ctx: CanvasRenderingContext2D, x: number, y: number, staffLineSpacing: number, yOffset?: number, scaleFactor?: number): void;
+/**
+ * Draw a C-clef (Alto/Tenor)
+ */
+export declare function drawCClef(ctx: CanvasRenderingContext2D, x: number, y: number, staffLineSpacing: number, staffPosition: number): void;
+/**
+ * Draw a percussion clef (neutral clef)
+ */
+export declare function drawPercussionClef(ctx: CanvasRenderingContext2D, x: number, y: number, staffLineSpacing: number): void;

package/dist/rendering/glyphs/DecorationGlyphs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Draw dynamic marking
+ */
+export declare function drawDynamic(ctx: CanvasRenderingContext2D, x: number, y: number, // Reference Y marking position (usually separate from note Y)
+dynamic: string, // Cast from enum or pass string
+staffLineSpacing: number, color?: string, musicFont?: 'Standard' | 'Jazz'): void;
+/**
+ * Draw a tie or slur curve (Bezier)
+ */
+export declare function drawCurve(ctx: CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number, direction: 'up' | 'down', staffLineSpacing: number, curvature?: number, // Height of the curve in staff spaces (default 0.8)
+color?: string): void;

package/dist/rendering/glyphs/NoteGlyphs.d.ts

@@ -0,0 +1,19 @@
+import { Duration, NoteheadShape, Bowing } from '../../models/types';
+/**
+ * Draw a notehead
+ */
+export declare function drawNotehead(ctx: CanvasRenderingContext2D, x: number, y: number, duration: Duration, staffLineSpacing: number, color?: string, shape?: NoteheadShape): void;
+/**
+ * Draw a flag for eighth/sixteenth notes
+ */
+export declare function drawFlag(ctx: CanvasRenderingContext2D, x: number, y: number, // Stem end position
+direction: 'up' | 'down', duration: Duration, staffLineSpacing: number, color?: string): void;
+/**
+ * Draw a dot for dotted notes
+ */
+export declare function drawDot(ctx: CanvasRenderingContext2D, x: number, y: number, staffLineSpacing: number, distanceFactor?: number, // Default distance factor
+color?: string): void;
+/**
+ * Draw bowing mark
+ */
+export declare function drawBowing(ctx: CanvasRenderingContext2D, x: number, y: number, bowing: Bowing, staffLineSpacing: number, color?: string): void;