songsheet 7.0.0 → 7.2.0

package/package.json

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

package/src/playback.js

@@ -44,6 +44,62 @@ function buildMeasure(chords, measureIndex, structureIndex, lineIndex, ts) {
   }
 }
 
+/**
+ * Check if barlines on this line actually separate chords (e.g., | G | C | D |)
+ * vs. just trailing after all chords (e.g., A C D |).
+ * Returns true only when a barline appears between two chords.
+ */
+function detectInterBarlines(markers) {
+  let seenChord = false
+  let seenBarAfterChord = false
+  for (const m of markers) {
+    if (m.type === 'chord') {
+      if (seenBarAfterChord) return true
+      seenChord = true
+    } else if (m.type === 'bar' && seenChord) {
+      seenBarAfterChord = true
+    }
+  }
+  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.
  *
@@ -75,9 +131,7 @@ export function buildPlaybackTimeline(structure, timeSignature) {
         }
         markers.sort((a, b) => a.col - b.col)
 
-        const hasBarlines = line.barLines.length > 0
-
-        if (hasBarlines) {
+        if (shouldGroupByBarlines(markers)) {
           // Group chords by barline boundaries
           let currentChords = []
           for (const m of markers) {
@@ -99,11 +153,18 @@ export function buildPlaybackTimeline(structure, timeSignature) {
             measureIndex++
           }
         } else {
-          // No barlines: each chord is its own measure
-          for (const chord of line.chords) {
-            const expanded = expandChord(chord)
-            measures.push(buildMeasure(expanded, measureIndex, si, li, ts))
-            measureIndex++
+          // 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) {
+            if (m.type === 'chord') {
+              lastExpanded = expandChord(m.chord)
+              measures.push(buildMeasure(lastExpanded, measureIndex, si, li, ts))
+              measureIndex++
+            } else if (m.type === 'bar' && lastExpanded) {
+              measures.push(buildMeasure([...lastExpanded], measureIndex, si, li, ts))
+              measureIndex++
+            }
           }
         }
       }

package/test/playback.test.js

@@ -37,10 +37,20 @@ describe('buildPlaybackTimeline', () => {
       }
     })
 
-    it('| C D | creates 1 measure with 2 chords at beats 0 and 2', () => {
-      const song = parse('TITLE\n\n| C D |\n Lyrics')
+    it('trailing barline repeats last chord: C D | → C, D, D', () => {
+      const song = parse('TITLE\n\nC D |\n Lyrics')
       const playback = song.playback
-      expect(playback.length).toBe(1)
+      expect(playback.length).toBe(3)
+      expect(playback[0].chords[0].root).toBe('C')
+      expect(playback[1].chords[0].root).toBe('D')
+      expect(playback[2].chords[0].root).toBe('D')
+    })
+
+    it('| C D | G | groups by barlines when inter-barlines present', () => {
+      const song = parse('TITLE\n\n| C D | G |\n Lyrics')
+      const playback = song.playback
+      // Barline between D and G → barline grouping applies
+      expect(playback.length).toBe(2)
       expect(playback[0].chords.length).toBe(2)
       expect(playback[0].chords[0].root).toBe('C')
       expect(playback[0].chords[0].beatStart).toBe(0)
@@ -48,22 +58,38 @@ describe('buildPlaybackTimeline', () => {
       expect(playback[0].chords[1].root).toBe('D')
       expect(playback[0].chords[1].beatStart).toBe(2)
       expect(playback[0].chords[1].durationInBeats).toBe(2)
+      expect(playback[1].chords[0].root).toBe('G')
     })
 
-    it('D | creates 1 measure with D getting full measure', () => {
+    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('D | creates 2 measures: D then barline repeats D', () => {
       const song = parse('TITLE\n\nD |\n Lyrics')
       const playback = song.playback
-      expect(playback.length).toBe(1)
-      expect(playback[0].chords.length).toBe(1)
+      expect(playback.length).toBe(2)
       expect(playback[0].chords[0].root).toBe('D')
-      expect(playback[0].chords[0].durationInBeats).toBe(4)
+      expect(playback[1].chords[0].root).toBe('D')
     })
 
-    it('leading | with no preceding chords is discarded', () => {
+    it('| G | with no inter-barlines: G then barline repeats G', () => {
       const song = parse('TITLE\n\n| G |\n Lyrics')
       const playback = song.playback
-      expect(playback.length).toBe(1)
+      // Leading | has no preceding chord → ignored. G then trailing | repeats G.
+      expect(playback.length).toBe(2)
       expect(playback[0].chords[0].root).toBe('G')
+      expect(playback[1].chords[0].root).toBe('G')
     })
   })
 
@@ -111,16 +137,24 @@ describe('buildPlaybackTimeline', () => {
   })
 
   describe('3/4 time signature', () => {
-    it('divides beats by 3', () => {
-      const song = parse('TITLE\n(3/4 time)\n\n| G C D |\n Lyrics')
+    it('uses 3 beats per measure', () => {
+      const song = parse('TITLE\n(3/4 time)\n\nG\n Lyrics')
       const playback = song.playback
       expect(playback.length).toBe(1)
-      expect(playback[0].chords.length).toBe(3)
-      expect(playback[0].chords[0].durationInBeats).toBe(1)
-      expect(playback[0].chords[1].durationInBeats).toBe(1)
-      expect(playback[0].chords[2].durationInBeats).toBe(1)
+      expect(playback[0].chords[0].durationInBeats).toBe(3)
       expect(playback[0].timeSignature.beats).toBe(3)
     })
+
+    it('inter-barline grouping divides beats by 3', () => {
+      const song = parse('TITLE\n(3/4 time)\n\n| G | C D |\n Lyrics')
+      const playback = song.playback
+      expect(playback.length).toBe(2)
+      expect(playback[0].chords[0].root).toBe('G')
+      expect(playback[0].chords[0].durationInBeats).toBe(3)
+      expect(playback[1].chords.length).toBe(2)
+      expect(playback[1].chords[0].durationInBeats).toBe(1.5)
+      expect(playback[1].chords[1].durationInBeats).toBe(1.5)
+    })
   })
 
   describe('back-references', () => {
@@ -153,18 +187,14 @@ describe('buildPlaybackTimeline', () => {
       }
     })
 
-    it('uses barline grouping for chord lines with barlines', () => {
-      // The verse has patterns like "D  |" — D followed by barline = 1 measure
-      // Check that the first structure entry (verse) doesn't duplicate chords at barlines
+    it('trailing barlines repeat last chord: D|, G|, A C D| → D D G G A C D D', () => {
       const verseMeasures = song.playback.filter(m => m.structureIndex === 0)
-      // Verse line 1: "D                        |" — 1 chord D before barline = 1 measure
-      // Verse line 2: "G                                 |" — 1 chord G before barline = 1 measure
-      // Verse line 3: "        A                               C                                   D     |"
-      //   — 3 chords (A, C, D) before barline = 1 measure with 3 chords
-      expect(verseMeasures.length).toBe(3)
-      expect(verseMeasures[0].chords[0].root).toBe('D')
-      expect(verseMeasures[1].chords[0].root).toBe('G')
-      expect(verseMeasures[2].chords.length).toBe(3)
+      // Line 1: "D |" → D, D (barline repeats)
+      // Line 2: "G |" → G, G (barline repeats)
+      // Line 3: "A C D |" → A, C, D, D (barline repeats last)
+      expect(verseMeasures.length).toBe(8)
+      const roots = verseMeasures.map(m => m.chords[0].root)
+      expect(roots).toEqual(['D', 'D', 'G', 'G', 'A', 'C', 'D', 'D'])
     })
 
     it('measure indices are sequential', () => {