songsheet 7.1.0 → 7.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "songsheet",
-  "version": "7.1.0",
+  "version": "7.3.0",
   "description": "A songsheet interpreter",
   "type": "module",
   "exports": "./index.js",

package/src/notation.js

@@ -173,7 +173,9 @@ function convertSong(song, key, toNNS) {
         ...measure,
         chords: measure.chords.map(c => {
           const converted = convertChord(c, keySemitone, toNNS, preferFlats)
-          return { ...converted, beatStart: c.beatStart, durationInBeats: c.durationInBeats }
+          const playbackChord = { ...converted, beatStart: c.beatStart, durationInBeats: c.durationInBeats }
+          if (c.markerIndex !== undefined) playbackChord.markerIndex = c.markerIndex
+          return playbackChord
         }),
       }))
     : undefined

package/src/playback.js

@@ -2,7 +2,7 @@
  * Expand a chord into PlaybackChord(s). If the chord has a splitMeasure,
  * each sub-chord becomes a separate PlaybackChord; otherwise a single one.
  */
-function expandChord(chord) {
+function expandChord(chord, markerIndex) {
   if (chord.splitMeasure && chord.splitMeasure.length > 0) {
     return chord.splitMeasure.map(sc => {
       const pc = { root: sc.root, type: sc.type }
@@ -11,6 +11,7 @@ function expandChord(chord) {
       if (sc.diamond) pc.diamond = true
       if (sc.push) pc.push = true
       if (sc.stop) pc.stop = true
+      if (markerIndex !== undefined) pc.markerIndex = markerIndex
       return pc
     })
   }
@@ -20,6 +21,7 @@ function expandChord(chord) {
   if (chord.diamond) pc.diamond = true
   if (chord.push) pc.push = true
   if (chord.stop) pc.stop = true
+  if (markerIndex !== undefined) pc.markerIndex = markerIndex
   return [pc]
 }
 
@@ -63,6 +65,43 @@ function detectInterBarlines(markers) {
   return false
 }
 
+/**
+ * Detect consecutive barlines (e.g., C || D), which usually indicate
+ * repeated held measures rather than explicit bar-delimited grouping.
+ */
+function hasConsecutiveBars(markers) {
+  let prevWasBar = false
+  for (const m of markers) {
+    if (m.type === 'bar') {
+      if (prevWasBar) return true
+      prevWasBar = true
+    } else {
+      prevWasBar = false
+    }
+  }
+  return false
+}
+
+/**
+ * Decide whether a line should be grouped by explicit barline boundaries.
+ *
+ * Heuristic:
+ * - require at least one barline between chords
+ * - require barline density to be at least chord density
+ * - reject consecutive barlines (treated as hold repeats)
+ *
+ * Sparse barlines like "C C/B Am G F | Fsus4 F" stay in chord-per-measure mode.
+ */
+function shouldGroupByBarlines(markers) {
+  const chordCount = markers.filter(m => m.type === 'chord').length
+  const barCount = markers.length - chordCount
+  if (chordCount === 0 || barCount === 0) return false
+  if (!detectInterBarlines(markers)) return false
+  if (barCount < chordCount) return false
+  if (hasConsecutiveBars(markers)) return false
+  return true
+}
+
 /**
  * Build the playback timeline from the song's structure array.
  *
@@ -90,21 +129,17 @@ export function buildPlaybackTimeline(structure, timeSignature) {
           markers.push({ col: chord.column, type: 'chord', chord })
         }
         for (const bar of line.barLines) {
-          markers.push({ col: bar.column, type: 'bar' })
+          markers.push({ col: bar.column, type: 'bar', bar })
         }
         markers.sort((a, b) => a.col - b.col)
 
-        // Detect whether barlines actually separate chords on this line.
-        // Pattern: chord...bar...chord means barlines are measure separators.
-        // Pattern: chord chord... bar (trailing only) means barlines are phrase markers.
-        const hasInterBarlines = detectInterBarlines(markers)
-
-        if (hasInterBarlines) {
+        if (shouldGroupByBarlines(markers)) {
           // Group chords by barline boundaries
           let currentChords = []
-          for (const m of markers) {
+          for (let mi = 0; mi < markers.length; mi++) {
+            const m = markers[mi]
             if (m.type === 'chord') {
-              currentChords.push(...expandChord(m.chord))
+              currentChords.push(...expandChord(m.chord, mi))
             } else {
               // Bar line: flush accumulated chords as a measure
               if (currentChords.length > 0) {
@@ -124,22 +159,36 @@ export function buildPlaybackTimeline(structure, timeSignature) {
           // No inter-barlines: each chord is its own measure.
           // Trailing barlines repeat the preceding chord for one additional measure.
           let lastExpanded = null
-          for (const m of markers) {
+          for (let mi = 0; mi < markers.length; mi++) {
+            const m = markers[mi]
             if (m.type === 'chord') {
-              lastExpanded = expandChord(m.chord)
+              lastExpanded = expandChord(m.chord, mi)
               measures.push(buildMeasure(lastExpanded, measureIndex, si, li, ts))
               measureIndex++
-            } else if (m.type === 'bar' && lastExpanded) {
-              measures.push(buildMeasure([...lastExpanded], measureIndex, si, li, ts))
-              measureIndex++
+            } else if (m.type === 'bar') {
+              // Use parser-provided bar chord context when available.
+              // This enables leading bars on a new line (e.g. "| | G |")
+              // to repeat the previous line's carried chord.
+              let repeatedAtBar = null
+              if (m.bar && m.bar.chord) {
+                repeatedAtBar = expandChord(m.bar.chord, mi)
+              } else if (lastExpanded) {
+                repeatedAtBar = lastExpanded.map(c => ({ ...c, markerIndex: mi }))
+              }
+              if (repeatedAtBar) {
+                measures.push(buildMeasure(repeatedAtBar, measureIndex, si, li, ts))
+                measureIndex++
+                lastExpanded = repeatedAtBar
+              }
             }
           }
         }
       }
     } else {
       // Expression-only entries (FILL, INSTRUMENTAL, etc.) — chords only, no lines
-      for (const chord of entry.chords) {
-        const expanded = expandChord(chord)
+      for (let ci = 0; ci < entry.chords.length; ci++) {
+        const chord = entry.chords[ci]
+        const expanded = expandChord(chord, ci)
         measures.push(buildMeasure(expanded, measureIndex, si, -1, ts))
         measureIndex++
       }

package/src/transpose.js

@@ -114,7 +114,9 @@ export function transpose(song, semitones, options = {}) {
         ...measure,
         chords: measure.chords.map(c => {
           const transposed = transposeChordObj(c, semitones, preferFlats)
-          return { ...transposed, beatStart: c.beatStart, durationInBeats: c.durationInBeats }
+          const playbackChord = { ...transposed, beatStart: c.beatStart, durationInBeats: c.durationInBeats }
+          if (c.markerIndex !== undefined) playbackChord.markerIndex = c.markerIndex
+          return playbackChord
         }),
       }))
     : undefined

package/test/playback.test.js

@@ -61,6 +61,32 @@ describe('buildPlaybackTimeline', () => {
       expect(playback[1].chords[0].root).toBe('G')
     })
 
+    it('sparse inter-barline usage stays chord-per-measure with bar repeat', () => {
+      const song = parse('TITLE\n(3/4 time)\n\nC C/B Am G F | Fsus4 F\n Lyrics')
+      const playback = song.playback
+      expect(playback.length).toBe(8)
+      const roots = playback.map(m => m.chords[0].root + (m.chords[0].bass ? '/' + m.chords[0].bass : ''))
+      expect(roots).toEqual(['C', 'C/B', 'A', 'G', 'F', 'F', 'F', 'F'])
+      for (const m of playback) {
+        expect(m.chords.length).toBe(1)
+        expect(m.chords[0].durationInBeats).toBe(3)
+      }
+      expect(playback[6].chords[0].type).toBe('sus4')
+      expect(playback[7].chords[0].type).toBe('')
+    })
+
+    it('leading bars on next line repeat carried chord context', () => {
+      const song = parse(
+        'TITLE\n(3/4 time)\n\nC   |   F  C\nA way out on-line\n  |        |               G         |\nA thousand miles from what I know as mine'
+      )
+      const playback = song.playback
+      const roots = playback.map(m => m.chords[0].root + (m.chords[0].bass ? '/' + m.chords[0].bass : ''))
+      expect(roots).toEqual(['C', 'C', 'F', 'C', 'C', 'C', 'G', 'G'])
+      for (const m of playback) {
+        expect(m.chords[0].durationInBeats).toBe(3)
+      }
+    })
+
     it('D | creates 2 measures: D then barline repeats D', () => {
       const song = parse('TITLE\n\nD |\n Lyrics')
       const playback = song.playback
@@ -157,6 +183,20 @@ describe('buildPlaybackTimeline', () => {
       expect(song.playback[0].measureIndex).toBe(0)
       expect(song.playback[1].measureIndex).toBe(1)
     })
+
+    it('assigns playback markerIndex values for chords and bar repeats', () => {
+      const song = parse('TITLE\n\nC D |\n Lyrics')
+      expect(song.playback[0].chords[0].markerIndex).toBe(0) // C marker
+      expect(song.playback[1].chords[0].markerIndex).toBe(1) // D marker
+      expect(song.playback[2].chords[0].markerIndex).toBe(2) // trailing bar marker
+    })
+
+    it('assigns markerIndex for grouped barline measures', () => {
+      const song = parse('TITLE\n\n| C D | G |\n Lyrics')
+      expect(song.playback[0].chords[0].markerIndex).toBe(1) // C marker
+      expect(song.playback[0].chords[1].markerIndex).toBe(2) // D marker
+      expect(song.playback[1].chords[0].markerIndex).toBe(4) // G marker
+    })
   })
 
   describe('fixture: spent-some-time-in-buffalo.txt', () => {