@k-l-lambda/lilylet 0.1.63 → 0.1.64

package/lib/lilylet/meiEncoder.js

@@ -741,7 +741,8 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     const pedals = [];
     // Track octave spans - initialize from previous measure if continuing
     const octaves = [];
-    let currentOctave = initialOctave ? { dis: initialOctave.dis, disPlace: initialOctave.disPlace, startId: initialOctave.startId } : null;
+    const octaveEndReplacements = {};
+    let currentOctave = initialOctave ? { dis: initialOctave.dis, disPlace: initialOctave.disPlace, startId: initialOctave.startId, continued: initialOctave.continued, emitted: initialOctave.emitted, endToken: initialOctave.endToken, endFallbackId: initialOctave.endFallbackId } : null;
     let pendingOttava = null; // Track ottava to apply to next note
     let currentOttavaShift = initialOctave?.shift || 0; // Track current ottava shift for pitch encoding
     let lastNoteId = null; // Track last note id for ending ottava spans
@@ -833,6 +834,9 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                 const result = noteEventToMEI(effectiveNoteEvent, currentIndent, voice.staff, tieEnd, currentStemDirection, keyFifths, currentOttavaShift, measureAccidentals);
                 xml += result.xml;
                 lastNoteId = result.elementId;
+                if (currentOctave?.endToken) {
+                    octaveEndReplacements[currentOctave.endToken] = result.elementId;
+                }
                 // Flush any pending markups onto this note
                 flushPendingMarkups(result.elementId);
                 // If there's a pending ottava, start the span on this note
@@ -841,9 +845,14 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                     const disPlace = pendingOttava > 0 ? 'above' : 'below';
                     // Close existing span first if it has a different value
                     if (currentOctave && (currentOctave.dis !== dis || currentOctave.disPlace !== disPlace)) {
-                        // Different value - close the old span
-                        // Use the lastNoteId from before this note (which we saved before processing)
-                        // Note: The span from previous measure will be closed by encodeMeasure
+                        if (lastNoteId) {
+                            octaves.push({
+                                dis: currentOctave.dis,
+                                disPlace: currentOctave.disPlace,
+                                startId: currentOctave.startId,
+                                endId: lastNoteId,
+                            });
+                        }
                         currentOctave = null;
                     }
                     // Start new span if we don't already have one with the same value
@@ -852,6 +861,12 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                     }
                     pendingOttava = null;
                 }
+                else if (currentOctave?.continued) {
+                    if (!currentOctave.endToken) {
+                        currentOctave.startId = result.elementId;
+                    }
+                    currentOctave.continued = false;
+                }
                 // Update pending tie pitches
                 if (result.hasTieStart) {
                     pendingTiePitches = result.pitches;
@@ -997,12 +1012,14 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                     if (ctx.ottava === 0) {
                         // End current ottava span
                         if (currentOctave && lastNoteId) {
-                            octaves.push({
-                                dis: currentOctave.dis,
-                                disPlace: currentOctave.disPlace,
-                                startId: currentOctave.startId,
-                                endId: lastNoteId,
-                            });
+                            if (!currentOctave.emitted) {
+                                octaves.push({
+                                    dis: currentOctave.dis,
+                                    disPlace: currentOctave.disPlace,
+                                    startId: currentOctave.startId,
+                                    endId: lastNoteId,
+                                });
+                            }
                             currentOctave = null;
                             ottavaExplicitlyClosed = true; // Mark that we explicitly closed the span
                         }
@@ -1015,7 +1032,7 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
                         const dis = Math.abs(ctx.ottava) === 2 ? 15 : 8;
                         const disPlace = ctx.ottava > 0 ? 'above' : 'below';
                         if (currentOctave && currentOctave.dis === dis && currentOctave.disPlace === disPlace) {
-                            // Continuation - restore the shift but don't change the span
+                            // Continuation - restore the shift and let the existing 8va line reach this measure's first note
                             currentOttavaShift = ctx.ottava;
                         }
                         else {
@@ -1091,13 +1108,24 @@ const encodeLayer = (voice, layerN, indent, initialTiePitches = [], keyFifths =
     if (beamElementOpen) {
         xml += `${baseIndent}</beam>\n`;
     }
-    // Don't close ottava span at measure end - it may continue in the next measure
-    // Build pending octave state to return
+    // Emit one visible octave span for a continuing ottava; a repeated same-value command can extend it to the next measure.
+    if (currentOctave && lastNoteId && !currentOctave.emitted) {
+        const endToken = `__OTTAVA_END_${generateId('octaveEnd')}__`;
+        octaves.push({
+            dis: currentOctave.dis,
+            disPlace: currentOctave.disPlace,
+            startId: currentOctave.startId,
+            endId: endToken,
+        });
+        currentOctave.emitted = true;
+        currentOctave.endToken = endToken;
+        currentOctave.endFallbackId = lastNoteId;
+    }
     const pendingOctave = currentOctave
-        ? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift }
+        ? { dis: currentOctave.dis, disPlace: currentOctave.disPlace, startId: currentOctave.startId, shift: currentOttavaShift, continued: true, emitted: currentOctave.emitted, endToken: currentOctave.endToken, endFallbackId: currentOctave.endFallbackId }
         : null;
     xml += `${indent}</layer>\n`;
-    return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: currentSlur?.startId || null, pendingHairpin: currentHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift };
+    return { xml, hairpins, pedals, octaves, slurs, arpeggios, fermatas, trills, mordents, turns, dynamics, fingerings, navigations, harmonies, barlines, markups, pendingTiePitches, pendingSlur: currentSlur?.startId || null, pendingHairpin: currentHairpin, pendingOctave, ottavaExplicitlyClosed, endingClef: currentClef, lastNoteId, currentOttavaShift, octaveEndReplacements };
 };
 // Encode a staff
 const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hairpinState = {}, ottavaState = {}, keyFifths = 0, initialClef) => {
@@ -1124,6 +1152,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
     const pendingOctaves = {};
     const ottavaExplicitlyClosed = {};
     const lastNoteIds = {};
+    const octaveEndReplacements = {};
     let endingClef = initialClef;
     if (voices.length === 0) {
         xml += `${indent}    <layer xml:id="${generateId('layer')}" n="1" />\n`;
@@ -1153,6 +1182,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
             allHarmonies.push(...result.harmonies);
             allBarlines.push(...result.barlines);
             allMarkups.push(...result.markups);
+            Object.assign(octaveEndReplacements, result.octaveEndReplacements);
             // Track pending ties for this layer
             if (result.pendingTiePitches.length > 0) {
                 pendingTies[tieKey] = result.pendingTiePitches;
@@ -1205,6 +1235,7 @@ const encodeStaff = (voices, staffN, indent, tieState = {}, slurState = {}, hair
         pendingOctaves,
         ottavaExplicitlyClosed,
         lastNoteIds,
+        octaveEndReplacements,
         endingClef,
     };
 };
@@ -1280,7 +1311,7 @@ const BARLINE_TO_MEI = {
 };
 // Encode a measure
 // encodeMeasure accepts mutable tieState, slurState, hairpinState, ottavaState and clefState that persist across measures
-const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, ottavaState, keyFifths = 0, partInfos = [], clefState = {}) => {
+const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurState, hairpinState, ottavaState, keyFifths = 0, partInfos = [], clefState = {}, octaveEndReplacements = {}) => {
     const measureId = generateId("measure");
     let staffContent = ''; // Build staff content first, then add measure tag with barline
     const allHairpins = [];
@@ -1353,39 +1384,22 @@ const encodeMeasure = (measure, measureN, indent, totalStaves, tieState, slurSta
         allHarmonies.push(...result.harmonies);
         allBarlines.push(...result.barlines);
         allMarkups.push(...result.markups);
+        Object.assign(octaveEndReplacements, result.octaveEndReplacements);
         // Update tie state with pending ties from this staff
         Object.assign(tieState, result.pendingTies);
         // Update slur state with pending slurs from this staff
         Object.assign(slurState, result.pendingSlurs);
         // Update hairpin state with pending hairpins from this staff
         Object.assign(hairpinState, result.pendingHairpins);
-        // Update ottava state with pending octaves from this staff
-        // Also handle closing spans when ottava ends
+        // Update ottava state with pending octaves from this staff.
+        // encodeLayer already emits measure-local octave spans, so keep the next measure's start independent.
         const currentStaffPrefix = `${si}-`;
         for (const [key, pending] of Object.entries(result.pendingOctaves)) {
             if (pending) {
-                // Check if this is a continuation or a new span
-                const prevPending = ottavaState[key];
-                if (prevPending && prevPending.shift === pending.shift) {
-                    // Same ottava value continues - keep the original startId
-                    ottavaState[key] = { ...pending, startId: prevPending.startId };
-                }
-                else {
-                    // Different ottava value - close the old span first if exists
-                    if (prevPending) {
-                        const lastNoteId = result.lastNoteIds[key];
-                        if (lastNoteId) {
-                            allOctaves.push({
-                                dis: prevPending.dis,
-                                disPlace: prevPending.disPlace,
-                                startId: prevPending.startId,
-                                endId: lastNoteId,
-                            });
-                        }
-                    }
-                    // Start new span
-                    ottavaState[key] = pending;
+                if (pending.endToken && pending.endFallbackId && !octaveEndReplacements[pending.endToken]) {
+                    octaveEndReplacements[pending.endToken] = pending.endFallbackId;
                 }
+                ottavaState[key] = pending;
             }
         }
         // For layers in this staff that had pending octaves but didn't in this measure, close the spans
@@ -1912,6 +1926,7 @@ const encode = (doc, options = {}) => {
     const hairpinState = {};
     // Track ottava state across measures for cross-measure ottava spans
     const ottavaState = {};
+    const octaveEndReplacements = {};
     // Initialize clef state from partInfos (convert local staff to global staff)
     const clefState = {};
     for (let pi = 0; pi < partInfos.length; pi++) {
@@ -1967,7 +1982,7 @@ const encode = (doc, options = {}) => {
                 mei += `${indent}${indent}${indent}${indent}${indent}${indent}<scoreDef xml:id="${generateId('scoredef')}"${meterSymAttr} meter.count="${currentTimeNum}" meter.unit="${currentTimeDen}" />\n`;
             }
         }
-        mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState);
+        mei += encodeMeasure(measure, mi + 1, `${indent}${indent}${indent}${indent}${indent}${indent}`, totalStaves, tieState, slurState, hairpinState, ottavaState, currentKey, partInfos, clefState, octaveEndReplacements);
     });
     mei += `${indent}${indent}${indent}${indent}${indent}</section>\n`;
     mei += `${indent}${indent}${indent}${indent}</score>\n`;
@@ -1975,6 +1990,9 @@ const encode = (doc, options = {}) => {
     mei += `${indent}${indent}</body>\n`;
     mei += `${indent}</music>\n`;
     mei += '</mei>\n';
+    for (const [token, endId] of Object.entries(octaveEndReplacements)) {
+        mei = mei.replaceAll(token, endId);
+    }
     return mei;
 };
 // Escape XML special characters

package/lib/source/abc/abc.d.ts

@@ -0,0 +1,102 @@
+interface Fraction {
+    numerator: number;
+    denominator: number;
+}
+declare namespace ABC {
+    type Token = string;
+    interface KeyValue {
+        name: string;
+        value: any;
+    }
+    export interface ControlTerm {
+        control: KeyValue;
+    }
+    export interface Triplet {
+        triplet: number;
+        multiplier?: number;
+        n?: number;
+    }
+    export interface OctaveShift {
+        octaveShift: number;
+    }
+    export interface Fingering {
+        fingering: string;
+    }
+    export interface Tremolo {
+        tremolo: number;
+    }
+    interface Grace {
+        grace: boolean;
+        acciaccatura: Token;
+        events: GraceMusicTerm[];
+    }
+    interface Comment {
+        comment: string;
+    }
+    export interface Articulation {
+        articulation: Token;
+        scope?: '(' | ')';
+    }
+    export type Expressive = Articulation | {
+        express: Token;
+    };
+    export interface TextTerm {
+        text: string;
+    }
+    export interface Pitch {
+        acc: number | null;
+        phonet: Token;
+        quotes: number;
+        tie?: boolean;
+    }
+    export interface Chord {
+        pitches: Pitch[];
+        tie?: any;
+    }
+    export interface EventData {
+        chord: Chord;
+        duration?: Fraction;
+    }
+    export interface EventTerm {
+        event: EventData;
+        broken?: number;
+    }
+    export type MusicTerm = Expressive | TextTerm | EventTerm | Grace | ControlTerm | Triplet | OctaveShift | Fingering | Tremolo;
+    export type GraceMusicTerm = Expressive | EventTerm | Fingering;
+    type Header = KeyValue | Comment;
+    export interface BarPatch {
+        control: {
+            [k: string]: any;
+        };
+        terms: MusicTerm[];
+        bar: Token;
+    }
+    export interface StaffGroup {
+        items: (StaffGroup | string)[];
+        bound?: 'arc' | 'square' | 'curly';
+    }
+    export interface StaffLayout {
+        staffLayout: StaffGroup[];
+    }
+    export interface KeySignature {
+        root: string;
+        mode?: string;
+    }
+    export interface ClefValue {
+        clef: string;
+    }
+    interface Measure {
+        index: number;
+        voices: BarPatch[];
+    }
+    interface Body {
+        measures: Measure[];
+    }
+    export interface Tune {
+        header: Header[];
+        body: Body;
+    }
+    export type Document = Tune[];
+    export {};
+}
+export { ABC, };

package/lib/source/abc/abc.js

@@ -0,0 +1,25 @@
+var ABC;
+(function (ABC) {
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+    ;
+})(ABC || (ABC = {}));
+export { ABC, };

package/lib/source/abc/parser.d.ts

@@ -0,0 +1,3 @@
+import { ABC } from "./abc";
+export declare const parse: (code: string) => ABC.Document;
+export default parse;

package/lib/source/abc/parser.js

@@ -0,0 +1,6 @@
+// @ts-ignore - jison generated file
+import grammar from "./grammar.jison.js";
+export const parse = (code) => {
+    return grammar.parse(code);
+};
+export default parse;

package/lib/source/lilylet/abcDecoder.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ABC Notation Decoder for Lilylet
+ *
+ * Converts ABC notation files to Lilylet's internal LilyletDoc format.
+ */
+import { LilyletDoc } from "./types";
+/**
+ * Decode ABC notation string to LilyletDoc.
+ * If the ABC contains multiple tunes, only the first is decoded.
+ */
+export declare const decode: (abcString: string) => LilyletDoc;
+/**
+ * Decode ABC notation string to multiple LilyletDocs (one per tune).
+ */
+export declare const decodeAll: (abcString: string) => LilyletDoc[];
+/**
+ * Decode an ABC file to LilyletDoc
+ */
+export declare const decodeFile: (filePath: string) => Promise<LilyletDoc>;
+declare const _default: {
+    decode: (abcString: string) => LilyletDoc;
+    decodeAll: (abcString: string) => LilyletDoc[];
+    decodeFile: (filePath: string) => Promise<LilyletDoc>;
+};
+export default _default;