@k-l-lambda/lilylet 0.1.81 → 0.1.83

package/lib/lilylet/abcDecoder.js

@@ -189,6 +189,70 @@ const convertDuration = (abcDuration, unitLength) => {
     const log2 = Math.round(Math.log2(division));
     return { division: Math.pow(2, Math.max(0, log2)), dots: 0 };
 };
+// A whole note is WHOLE_TICKS ticks. 2^7·3^3·5·7 = 120960 divides by every dot (·3/2, ·7/4),
+// tuplet (÷3, ÷5, ÷7), and common division, so a voice's played length is an exact integer —
+// no float rounding when we compare it to the bar length (unlike calculateDuration's Math.round).
+const WHOLE_TICKS = 120960;
+// A resolved Duration's tick length (dots + optional lilylet tuplet ratio num/den applied).
+const durationTicks = (d) => {
+    let t = WHOLE_TICKS / d.division;
+    if (d.dots) {
+        let dot = t / 2;
+        for (let i = 0; i < d.dots; i++) {
+            t += dot;
+            dot /= 2;
+        }
+    }
+    if (d.tuplet)
+        t = t * d.tuplet.numerator / d.tuplet.denominator;
+    return t;
+};
+// Sum the played tick length of an event list. Context / barline / markup / dynamic events
+// take no time, and GRACE notes steal none (they carry a nominal duration but do not advance
+// the beat). A tuplet/times group scales its inner notes by ratio num/den (e.g. \tuplet 3/2 of
+// eighths = a quarter). This mirrors the parser's own \partial check so the emitted \partial
+// never trips a partial-mismatch warning. Used to measure a voice against its bar length.
+const eventsTicks = (events) => {
+    let total = 0;
+    for (const ev of events) {
+        if (ev.type === "note" || ev.type === "rest") {
+            if (ev.grace)
+                continue;
+            total += durationTicks(ev.duration);
+        }
+        else if (ev.type === "tuplet" || ev.type === "times") {
+            const t = ev;
+            const factor = t.ratio ? t.ratio.numerator / t.ratio.denominator : 1;
+            for (const inner of t.events || []) {
+                if ((inner.type === "note" || inner.type === "rest") && !inner.grace)
+                    total += durationTicks(inner.duration) * factor;
+            }
+        }
+        else if (ev.type === "tremolo") {
+            const tr = ev;
+            total += 2 * (WHOLE_TICKS / tr.division);
+        }
+    }
+    return total;
+};
+// Build a \partial Duration (single {division, dots}) for a pickup of `ticks` whole-note ticks.
+// LilyPond's \partial takes one duration token, so only power-of-2 divisions with up to 2 dots
+// are expressible; a length that isn't (e.g. a 5/8 pickup) returns null and no \partial is added
+// (the bar simply renders short) rather than emitting a wrong duration.
+const ticksToPartialDuration = (ticks) => {
+    if (ticks <= 0)
+        return null;
+    for (let division = 1; division <= 128; division *= 2) {
+        const base = WHOLE_TICKS / division;
+        if (ticks === base)
+            return { division, dots: 0 };
+        if (ticks === base * 1.5)
+            return { division, dots: 1 };
+        if (ticks === base * 1.75)
+            return { division, dots: 2 };
+    }
+    return null;
+};
 /**
  * Apply broken rhythm adjustment.
  * broken > 0 (A>B): current note gets dotted, next gets halved
@@ -492,6 +556,12 @@ const collectAbcRepeatInfo = (bars) => {
         // ("|:" forward, ":|:"/"::"/":||:" end-and-start).
         const startsNext = trailBar.includes("|:") || isEndStart;
         if (startsNext && idx < n) {
+            // A new repeat section opening here also CLOSES any still-open ending
+            // (a volta cannot span into the next repeat section). abc2xml back-patches
+            // the ending-stop onto this measure; without this a final volta (e.g.
+            // ":|2 …|:") would overshoot to the next volta/section bar far ahead.
+            if (openEndingStart >= 1 && openEndingStart <= idx)
+                closeOpenEnding(idx);
             infos[idx].repeatStart = true;
         }
         // A trailing volta digit ("|2", ":|1,2") opens an ending on the NEXT measure.
@@ -660,6 +730,13 @@ const abcLayoutToStaves = (layout) => {
  * `voiceInstr` maps an ABC voice number to its {name, shortName}. The layout's staff ids
  * are arc-first voice numbers, so a staff id "5" looks up voice 5's name.
  */
+// ABC quoted strings carry literal escape sequences (e.g. `nm="Violin\nsolo"` is the 11
+// characters V-i-o-l-i-n-\-n-s-o-l-o). The lilylet doc model holds DECODED strings — the
+// serializer's escapeString re-encodes a real newline back to `\n`. Without decoding here,
+// the stored backslash would be escaped a second time (`\n` → `\\n`). Mirror the lilylet
+// grammar's `unq` unescape table so both import paths agree.
+const ABC_UNESCAPE = { n: "\n", r: "\r", t: "\t", '"': '"', "\\": "\\" };
+const unescapeAbcString = (s) => s.replace(/\\(.)/g, (m, c) => (c in ABC_UNESCAPE ? ABC_UNESCAPE[c] : m));
 const abcInstrumentsToLilylet = (stavesCode, voiceInstr) => {
     const layout = parseStaffLayout(stavesCode);
     const result = {};
@@ -1339,8 +1416,8 @@ const decodeTune = (tune, options = {}) => {
                     continue;
                 const short = props.snm ?? props.sname;
                 voiceInstr.set(v, typeof short === "string" && short.length
-                    ? { name, shortName: short }
-                    : { name });
+                    ? { name: unescapeAbcString(name), shortName: unescapeAbcString(short) }
+                    : { name: unescapeAbcString(name) });
             }
             if (voiceInstr.size > 0) {
                 const instruments = abcInstrumentsToLilylet(metadata.staves, voiceInstr);
@@ -1369,6 +1446,10 @@ const decodeTune = (tune, options = {}) => {
     // index. Built alongside barInfos' navTexts; attached after each measure's
     // parts are assembled (mirrors the MusicXML path attaching nav to a note).
     const navMarksByMeasure = new Map();
+    // Running effective time signature (seeded from the header M:, updated by any inline
+    // [M:...] change). A bar whose played length is SHORTER than this gets a \partial (see
+    // the pickup/anacrusis handling below the per-measure assembly).
+    let curTime = timeSig;
     for (let mi = 0; mi < measures.length; mi++) {
         const abcMeasure = measures[mi];
         // Group patches by voice number
@@ -1561,6 +1642,66 @@ const decodeTune = (tune, options = {}) => {
                     break;
             }
         }
+        // Pickup / short bar → \partial. Update the running time signature from any inline
+        // [M:...] this bar carried (the LAST \time in the bar wins — a bar may restate then
+        // change meter, e.g. \time 3/4 \time 9/8), then compare the bar's played length (the
+        // longest voice, so a bar that is complete in ANY voice is not treated as short)
+        // against the meter's full-bar length. A strictly shorter bar is an anacrusis (bar 1)
+        // or a truncated final bar; emit \partial <bar-length> on the first voice so LilyPond
+        // renders the incomplete bar. A full-measure rest (Z/R) voice is skipped — it fills the
+        // bar by definition, so it must not drag the measured length down.
+        {
+            for (const part of parts) {
+                for (const voice of part.voices) {
+                    for (const e of voice.events) {
+                        if (e.type === "context" && e.time) {
+                            const t = e.time;
+                            curTime = { numerator: t.numerator, denominator: t.denominator };
+                        }
+                    }
+                }
+            }
+            if (curTime) {
+                const barTicks = WHOLE_TICKS * curTime.numerator / curTime.denominator;
+                // \partial is a GLOBAL timing directive — it shortens the bar for every voice at
+                // once. So it is only correct when every sounding voice has the SAME short length.
+                // Collect each voice's played ticks; a full-measure-rest (Z/R) voice fills the bar
+                // and is ignored. If the voices are ragged (different lengths — e.g. a messy meter
+                // change where some voices are 6/8 and others 8/8), no single \partial fits them
+                // all, so we emit none rather than one that mis-sizes some voices.
+                const lengths = [];
+                let anyFull = false;
+                for (const part of parts) {
+                    for (const voice of part.voices) {
+                        if (voice.events.some(e => e.type === "rest" && e.fullMeasure)) {
+                            anyFull = true;
+                            continue;
+                        }
+                        const t = eventsTicks(voice.events);
+                        if (t > 0)
+                            lengths.push(t);
+                    }
+                }
+                const uniform = lengths.length > 0 && lengths.every(t => t === lengths[0]);
+                const played = uniform ? lengths[0] : 0;
+                if (!anyFull && uniform && played < barTicks) {
+                    const partial = ticksToPartialDuration(played);
+                    if (partial) {
+                        // Insert after any leading key/time context so the emitted order is
+                        // \key … \time … \partial …  (LilyPond wants \partial after \time).
+                        const target = measure.parts[0]?.voices[0];
+                        if (target) {
+                            let at = 0;
+                            while (at < target.events.length && target.events[at].type === "context"
+                                && (target.events[at].key || target.events[at].time)
+                                && !target.events[at].clef)
+                                at++;
+                            target.events.splice(at, 0, { type: "context", partial });
+                        }
+                    }
+                }
+            }
+        }
         lilyletMeasures.push(measure);
     }
     // Add tempo to first measure's first voice if present