musicxml-io 0.6.0 → 0.7.0

package/dist/{chunk-MCKPGXUF.mjs → chunk-CCSOG7HU.mjs}

@@ -171,6 +171,344 @@ function getMeasureEndPosition(measure) {
   return state.position;
 }
 
+// src/query/playback-sequence.ts
+function parseEndingNumbers(numberStr) {
+  const numbers = [];
+  const parts = numberStr.split(/[,\s]+/);
+  for (const part of parts) {
+    if (part.includes("-")) {
+      const [start, end] = part.split("-").map((s) => parseInt(s.trim(), 10));
+      if (!isNaN(start) && !isNaN(end)) {
+        for (let i = start; i <= end; i++) {
+          numbers.push(i);
+        }
+      }
+    } else {
+      const num = parseInt(part.trim(), 10);
+      if (!isNaN(num)) {
+        numbers.push(num);
+      }
+    }
+  }
+  return numbers.length > 0 ? numbers : [1];
+}
+function parseJumpText(text) {
+  const t = text.toLowerCase().replace(/\s+/g, " ").trim();
+  if (t.includes("d.c. al coda") || t.includes("da capo al coda")) return "dc_al_coda";
+  if (t.includes("d.c. al fine") || t.includes("da capo al fine")) return "dc_al_fine";
+  if (t.includes("d.c.") || t.includes("da capo")) return "dc";
+  if (t.includes("d.s. al coda") || t.includes("dal segno al coda")) return "ds_al_coda";
+  if (t.includes("d.s. al fine") || t.includes("dal segno al fine")) return "ds_al_fine";
+  if (t.includes("d.s.") || t.includes("dal segno")) return "ds";
+  if (t === "fine") return "fine";
+  if (t.includes("to coda") || t.includes("al coda")) return "to_coda";
+  if (t === "coda" || t === "\u{1D14C}") return "coda";
+  if (t === "segno" || t === "\u{1D10B}") return "segno";
+  return null;
+}
+function getFirstWordsText(entry) {
+  for (const dt of entry.directionTypes) {
+    if (dt.kind === "words" && dt.text) return dt.text;
+  }
+  return void 0;
+}
+function hasDirectionKind(entry, kind) {
+  return entry.directionTypes.some((dt) => dt.kind === kind);
+}
+function extractPlaybackControls(part) {
+  const controls = {
+    repeatStarts: [],
+    repeatEnds: [],
+    voltas: [],
+    jumps: [],
+    segnoIndex: null,
+    codaIndex: null,
+    fineIndex: null,
+    toCodaIndex: null
+  };
+  const soundJumps = [];
+  for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    if (measure.barlines) {
+      for (const barline of measure.barlines) {
+        if (barline.repeat) {
+          if (barline.repeat.direction === "forward") {
+            controls.repeatStarts.push(measureIndex);
+          } else if (barline.repeat.direction === "backward") {
+            controls.repeatEnds.push({
+              measureIndex,
+              times: barline.repeat.times ?? 2
+            });
+          }
+        }
+        if (barline.ending) {
+          const numbers = parseEndingNumbers(barline.ending.number);
+          controls.voltas.push({
+            measureIndex,
+            numbers,
+            type: barline.ending.type
+          });
+        }
+      }
+    }
+    for (const entry of measure.entries) {
+      if (entry.type === "direction") {
+        const dir = entry;
+        if (hasDirectionKind(dir, "segno") && controls.segnoIndex === null) {
+          controls.segnoIndex = measureIndex;
+        }
+        if (hasDirectionKind(dir, "coda") && controls.codaIndex === null) {
+          controls.codaIndex = measureIndex;
+        }
+        const words = getFirstWordsText(dir);
+        if (words) {
+          const jt = parseJumpText(words);
+          if (jt === "fine") {
+            if (controls.fineIndex === null) controls.fineIndex = measureIndex;
+          } else if (jt === "to_coda") {
+            if (controls.toCodaIndex === null) controls.toCodaIndex = measureIndex;
+          } else if (jt === "coda") {
+            if (controls.codaIndex === null) controls.codaIndex = measureIndex;
+          } else if (jt === "segno") {
+            if (controls.segnoIndex === null) controls.segnoIndex = measureIndex;
+          } else if (jt) {
+            controls.jumps.push({ measureIndex, type: jt });
+          }
+        }
+      } else if (entry.type === "sound") {
+        const sound = entry;
+        if (sound.segno && controls.segnoIndex === null) controls.segnoIndex = measureIndex;
+        if (sound.coda && controls.codaIndex === null) controls.codaIndex = measureIndex;
+        if (sound.tocoda && controls.toCodaIndex === null) controls.toCodaIndex = measureIndex;
+        if (sound.fine && controls.fineIndex === null) controls.fineIndex = measureIndex;
+        if (sound.dacapo) soundJumps.push({ measureIndex, base: "dc" });
+        if (sound.dalsegno) soundJumps.push({ measureIndex, base: "ds" });
+      }
+    }
+  }
+  for (const sj of soundJumps) {
+    if (controls.jumps.some((j) => j.measureIndex === sj.measureIndex)) continue;
+    let type;
+    if (controls.fineIndex !== null) {
+      type = sj.base === "dc" ? "dc_al_fine" : "ds_al_fine";
+    } else if (controls.toCodaIndex !== null || controls.codaIndex !== null) {
+      type = sj.base === "dc" ? "dc_al_coda" : "ds_al_coda";
+    } else {
+      type = sj.base;
+    }
+    controls.jumps.push({ measureIndex: sj.measureIndex, type });
+  }
+  return controls;
+}
+function buildVoltaRanges(voltas, measureCount) {
+  const voltaRanges = /* @__PURE__ */ new Map();
+  let currentVoltaStart = null;
+  let currentVoltaNumbers = [];
+  for (const volta of voltas) {
+    if (volta.type === "start") {
+      currentVoltaStart = volta.measureIndex;
+      currentVoltaNumbers = volta.numbers;
+    } else if ((volta.type === "stop" || volta.type === "discontinue") && currentVoltaStart !== null) {
+      for (let i = currentVoltaStart; i <= volta.measureIndex; i++) {
+        voltaRanges.set(i, currentVoltaNumbers);
+      }
+      currentVoltaStart = null;
+    }
+  }
+  if (currentVoltaStart !== null) {
+    for (let i = currentVoltaStart; i < measureCount; i++) {
+      voltaRanges.set(i, currentVoltaNumbers);
+    }
+  }
+  return voltaRanges;
+}
+function generatePlaybackSequence(score, options) {
+  const partIndex = options?.partIndex ?? 0;
+  const part = score.parts[partIndex];
+  if (!part) return [];
+  const measureCount = part.measures.length;
+  const sequence = [];
+  if (measureCount === 0) return sequence;
+  const controls = extractPlaybackControls(part);
+  if (controls.repeatStarts.length === 0 && controls.repeatEnds.length === 0 && controls.voltas.length === 0 && controls.jumps.length === 0) {
+    for (let i = 0; i < measureCount; i++) {
+      sequence.push({ measureIndex: i, repeatIteration: 0 });
+    }
+    return sequence;
+  }
+  const voltaRanges = buildVoltaRanges(controls.voltas, measureCount);
+  const sortedRepeatStarts = [...controls.repeatStarts].sort((a, b) => a - b);
+  const sortedRepeatEnds = [...controls.repeatEnds].sort((a, b) => a.measureIndex - b.measureIndex);
+  const repeatSections = /* @__PURE__ */ new Map();
+  const voltaToRepeatEnd = /* @__PURE__ */ new Map();
+  const usedRepeatStarts = /* @__PURE__ */ new Set();
+  let lastRepeatEndMeasure = -1;
+  for (const repeatEnd of sortedRepeatEnds) {
+    let startIndex = null;
+    for (const startMeasure of sortedRepeatStarts) {
+      if (startMeasure <= repeatEnd.measureIndex && startMeasure > lastRepeatEndMeasure && !usedRepeatStarts.has(startMeasure)) {
+        startIndex = startMeasure;
+      } else if (startMeasure > repeatEnd.measureIndex) {
+        break;
+      }
+    }
+    if (startIndex === null) {
+      startIndex = lastRepeatEndMeasure + 1;
+    } else {
+      usedRepeatStarts.add(startIndex);
+    }
+    repeatSections.set(repeatEnd.measureIndex, {
+      startIndex,
+      times: repeatEnd.times
+    });
+    lastRepeatEndMeasure = repeatEnd.measureIndex;
+    voltaRanges.forEach((_iterations, voltaMeasure) => {
+      const isInsideRepeat = voltaMeasure >= startIndex && voltaMeasure <= repeatEnd.measureIndex;
+      const isImmediatelyAfter = voltaMeasure > repeatEnd.measureIndex && !voltaToRepeatEnd.has(voltaMeasure);
+      if (isInsideRepeat) {
+        voltaToRepeatEnd.set(voltaMeasure, repeatEnd.measureIndex);
+      } else if (isImmediatelyAfter) {
+        let belongsToLaterRepeat = false;
+        for (const otherEnd of sortedRepeatEnds) {
+          if (otherEnd.measureIndex > repeatEnd.measureIndex) {
+            const otherSection = repeatSections.get(otherEnd.measureIndex);
+            if (otherSection && voltaMeasure >= otherSection.startIndex && voltaMeasure <= otherEnd.measureIndex) {
+              belongsToLaterRepeat = true;
+              break;
+            }
+          }
+        }
+        if (!belongsToLaterRepeat) {
+          voltaToRepeatEnd.set(voltaMeasure, repeatEnd.measureIndex);
+        }
+      }
+    });
+  }
+  let currentMeasure = 0;
+  const repeatCounts = /* @__PURE__ */ new Map();
+  let lastRepeatEndIndex = null;
+  let lastRepeatIteration = 0;
+  let inRepeatJump = false;
+  let stopAtFine = false;
+  let jumpToCoda = false;
+  const maxIterations = measureCount * 10 + 10;
+  let iterations = 0;
+  while (currentMeasure < measureCount && iterations < maxIterations) {
+    iterations++;
+    const voltaIterations = voltaRanges.get(currentMeasure);
+    let repeatIteration = 0;
+    let inRepeatSection = false;
+    let currentRepeatEndIndex = null;
+    for (const [endIndex, section] of repeatSections) {
+      if (currentMeasure >= section.startIndex && currentMeasure <= endIndex) {
+        inRepeatSection = true;
+        currentRepeatEndIndex = endIndex;
+        repeatIteration = repeatCounts.get(endIndex) || 1;
+        break;
+      }
+    }
+    if (inRepeatSection && currentRepeatEndIndex !== null) {
+      lastRepeatEndIndex = currentRepeatEndIndex;
+      lastRepeatIteration = repeatIteration;
+    }
+    if (voltaIterations) {
+      let effectiveIteration = repeatIteration;
+      if (!inRepeatSection) {
+        const associatedRepeatEnd = voltaToRepeatEnd.get(currentMeasure);
+        if (associatedRepeatEnd !== void 0) {
+          effectiveIteration = repeatCounts.get(associatedRepeatEnd) || 1;
+        } else if (lastRepeatEndIndex !== null) {
+          effectiveIteration = lastRepeatIteration;
+        }
+      }
+      if (!voltaIterations.includes(effectiveIteration)) {
+        currentMeasure++;
+        continue;
+      }
+    }
+    sequence.push({
+      measureIndex: currentMeasure,
+      repeatIteration: inRepeatSection ? repeatIteration : 0
+    });
+    if (stopAtFine && controls.fineIndex === currentMeasure) {
+      break;
+    }
+    if (jumpToCoda && controls.toCodaIndex === currentMeasure && controls.codaIndex !== null) {
+      currentMeasure = controls.codaIndex;
+      jumpToCoda = false;
+      continue;
+    }
+    const repeatSection = repeatSections.get(currentMeasure);
+    if (repeatSection) {
+      const currentCount = repeatCounts.get(currentMeasure) || 1;
+      if (currentCount < repeatSection.times) {
+        repeatCounts.set(currentMeasure, currentCount + 1);
+        currentMeasure = repeatSection.startIndex;
+        continue;
+      }
+    }
+    if (voltaIterations && !inRepeatSection) {
+      const associatedRepeatEnd = voltaToRepeatEnd.get(currentMeasure);
+      if (associatedRepeatEnd !== void 0) {
+        const repeatSectionForVolta = repeatSections.get(associatedRepeatEnd);
+        if (repeatSectionForVolta) {
+          const currentCount = repeatCounts.get(associatedRepeatEnd) || 1;
+          if (currentCount < repeatSectionForVolta.times) {
+            repeatCounts.set(associatedRepeatEnd, currentCount + 1);
+            currentMeasure = repeatSectionForVolta.startIndex;
+            continue;
+          }
+        }
+      }
+    }
+    const jumpAtMeasure = controls.jumps.find((j) => j.measureIndex === currentMeasure);
+    if (jumpAtMeasure && !inRepeatJump) {
+      inRepeatJump = true;
+      switch (jumpAtMeasure.type) {
+        case "dc":
+          currentMeasure = 0;
+          continue;
+        case "dc_al_fine":
+          currentMeasure = 0;
+          stopAtFine = true;
+          continue;
+        case "dc_al_coda":
+          currentMeasure = 0;
+          jumpToCoda = true;
+          continue;
+        case "ds":
+          if (controls.segnoIndex !== null) {
+            currentMeasure = controls.segnoIndex;
+            continue;
+          }
+          break;
+        case "ds_al_fine":
+          if (controls.segnoIndex !== null) {
+            currentMeasure = controls.segnoIndex;
+            stopAtFine = true;
+            continue;
+          }
+          break;
+        case "ds_al_coda":
+          if (controls.segnoIndex !== null) {
+            currentMeasure = controls.segnoIndex;
+            jumpToCoda = true;
+            continue;
+          }
+          break;
+      }
+    }
+    currentMeasure++;
+  }
+  return sequence;
+}
+function hasPlaybackControls(score, options) {
+  const part = score.parts[options?.partIndex ?? 0];
+  if (!part) return false;
+  const controls = extractPlaybackControls(part);
+  return controls.repeatStarts.length > 0 || controls.repeatEnds.length > 0 || controls.voltas.length > 0 || controls.jumps.length > 0 || controls.segnoIndex !== null || controls.codaIndex !== null;
+}
+
 // src/query/index.ts
 function getNotesForVoice(measure, filter) {
   return measure.entries.filter((entry) => {
@@ -1721,6 +2059,9 @@ function pitchesEqual(a, b) {
 }
 
 export {
+  extractPlaybackControls,
+  generatePlaybackSequence,
+  hasPlaybackControls,
   STEPS,
   STEP_SEMITONES,
   pitchToSemitone,