songsheet 7.6.0 → 7.7.0

package/index.d.ts

@@ -7,6 +7,8 @@ export interface Chord {
   push?: boolean
   stop?: boolean
   splitMeasure?: Chord[]
+  splitOpen?: boolean
+  splitClose?: boolean
 }
 
 export interface PositionedChord extends Chord {

package/package.json

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

package/src/lexer.js

@@ -95,6 +95,7 @@ export function scanChordLine(line, options = {}) {
     tokens.push({
       type: 'SPLIT_CLOSE',
       column,
+      rawTokens: closeChords,
       chords: closeChords.map(c => {
         const sc = { root: c.root, type: c.quality }
         if (c.bass) sc.bass = c.bass

package/src/parser.js

@@ -15,6 +15,8 @@ function tokenToChord(token) {
   if (token.push) chord.push = true
   if (token.stop) chord.stop = true
   if (token.splitMeasure) chord.splitMeasure = token.splitMeasure
+  if (token.splitOpen) chord.splitOpen = true
+  if (token.splitClose) chord.splitClose = true
   return chord
 }
 
@@ -275,19 +277,29 @@ function parseChordLyricBlock(text) {
         const closeToken = contTokens.find(t => t.type === 'SPLIT_CLOSE')
         if (closeToken) {
           const allSplitChords = [...pendingSplit.openChords, ...closeToken.chords]
-          const splitMeasure = allSplitChords
-          // Update the chord on the earlier line with the complete splitMeasure
+          // Update the chord on the earlier line: add splitMeasure + splitOpen flag
           const earlierChord = pendingSplit.lineData.chords[pendingSplit.chordIndex]
-          earlierChord.splitMeasure = splitMeasure
+          earlierChord.splitMeasure = allSplitChords
+          earlierChord.splitOpen = true
           // Also update the allChords entry
           const allChordsEntry = allChords[pendingSplit.allChordsIndex]
           if (allChordsEntry) {
-            allChordsEntry.splitMeasure = splitMeasure
+            allChordsEntry.splitMeasure = allSplitChords
+            allChordsEntry.splitOpen = true
           }
 
-          // Now process the rest of the tokens on this line (chords/bars after the ] )
-          const restTokens = contTokens.filter(t => t.type !== 'SPLIT_CLOSE')
-          const restChords = restTokens.filter(t => t.type === 'CHORD').map(t => tokenToPositionedChord(t))
+          // Build chords for this continuation line:
+          // - close chords get splitClose flag + the shared splitMeasure
+          // - remaining chords after ] are normal
+          const closeChordPositioned = []
+          for (const rawTok of closeToken.rawTokens) {
+            const chord = tokenToPositionedChord(rawTok)
+            chord.splitClose = true
+            chord.splitMeasure = allSplitChords
+            closeChordPositioned.push(chord)
+          }
+          const restChords = contTokens.filter(t => t.type === 'CHORD').map(t => tokenToPositionedChord(t))
+          const lineChords = [...closeChordPositioned, ...restChords]
 
           // Build barLines for this line
           const sortedTokens = [...contTokens].sort((a, b) => a.column - b.column)
@@ -296,12 +308,17 @@ function parseChordLyricBlock(text) {
           for (const tok of sortedTokens) {
             if (tok.type === 'CHORD') {
               currentChord = tokenToChord(tok)
+            } else if (tok.type === 'SPLIT_CLOSE') {
+              // Update currentChord to the last close chord
+              const lastClose = closeToken.chords[closeToken.chords.length - 1]
+              currentChord = { root: lastClose.root, type: lastClose.type }
+              if (lastClose.bass) currentChord.bass = lastClose.bass
+              if (lastClose.nashville) currentChord.nashville = true
             } else if (tok.type === 'BAR_LINE') {
               const bar = { column: tok.column }
               if (currentChord) bar.chord = currentChord
               barLines.push(bar)
             }
-            // SPLIT_CLOSE doesn't update currentChord (those chords belong to the previous line)
           }
           if (currentChord) lastChord = currentChord
 
@@ -311,7 +328,6 @@ function parseChordLyricBlock(text) {
           // Find the paired lyric line
           let lyricLine = ''
           if (i < rawLines.length) {
-            // Check if next line is a chord line (with or without continueSplit)
             const nextIsChord = scanChordLine(rawLines[i])
             if (!nextIsChord) {
               lyricLine = rawLines[i]
@@ -319,7 +335,8 @@ function parseChordLyricBlock(text) {
             }
           }
 
-          allChords.push(...restChords.map(c => {
+          // Add close chords + rest chords to allChords
+          allChords.push(...lineChords.map(c => {
             const ch = { root: c.root, type: c.type }
             if (c.bass) ch.bass = c.bass
             if (c.nashville) ch.nashville = true
@@ -327,15 +344,22 @@ function parseChordLyricBlock(text) {
             if (c.push) ch.push = true
             if (c.stop) ch.stop = true
             if (c.splitMeasure) ch.splitMeasure = c.splitMeasure
+            if (c.splitClose) ch.splitClose = true
             return ch
           }))
           if (lyricLine) allLyrics.push(lyricLine)
 
+          // Build alignment tokens from the close chord raw tokens + rest tokens
+          const alignTokens = [
+            ...closeToken.rawTokens,
+            ...contTokens.filter(t => t.type !== 'SPLIT_CLOSE'),
+          ]
+
           lines.push({
-            chords: restChords,
+            chords: lineChords,
             barLines,
             lyrics: lyricLine,
-            characters: buildCharacterAlignment(restTokens, lyricLine),
+            characters: buildCharacterAlignment(alignTokens, lyricLine),
           })
           continue
         }
@@ -350,26 +374,31 @@ function parseChordLyricBlock(text) {
       // Check for SPLIT_OPEN token (cross-line split)
       const splitOpenToken = tokens.find(t => t.type === 'SPLIT_OPEN')
 
-      // This is a chord line — next non-chord line is its paired lyric
-      const chordTokens = tokens.filter(t => t.type !== 'SPLIT_OPEN')
-      // For SPLIT_OPEN, create a positioned chord from the first open chord at the [ column
+      // This is a chord line
+      // For alignment, use all tokens except SPLIT_OPEN (which becomes a regular chord)
+      const chordTokens = []
       const chords = []
       for (const t of tokens) {
         if (t.type === 'CHORD') {
           chords.push(tokenToPositionedChord(t))
+          chordTokens.push(t)
         } else if (t.type === 'SPLIT_OPEN') {
-          // Add the first chord of the split as a positioned chord
+          // Add the first chord of the split as a positioned chord at the [ column
           const first = t.chords[0]
           const chord = { root: first.root, type: first.type, column: t.column }
           if (first.bass) chord.bass = first.bass
           if (first.nashville) chord.nashville = true
-          // splitMeasure will be set later when we find the SPLIT_CLOSE
+          // splitOpen flag — splitMeasure will be set when we find the SPLIT_CLOSE
+          chord.splitOpen = true
           chords.push(chord)
+          // For alignment, create a synthetic CHORD token
+          chordTokens.push({ type: 'CHORD', column: t.column, root: first.root, quality: first.type })
+        } else {
+          chordTokens.push(t)
         }
       }
 
       // Build barLines as objects with chord context
-      // Sort all tokens by column, walk left-to-right tracking currentChord
       const sortedTokens = [...tokens].sort((a, b) => a.column - b.column)
       let currentChord = lastChord
       const barLines = []
@@ -378,7 +407,6 @@ function parseChordLyricBlock(text) {
           if (tok.type === 'CHORD') {
             currentChord = tokenToChord(tok)
           } else {
-            // Use first chord of split open
             const first = tok.chords[0]
             currentChord = { root: first.root, type: first.type }
             if (first.bass) currentChord.bass = first.bass
@@ -390,17 +418,15 @@ function parseChordLyricBlock(text) {
           barLines.push(bar)
         }
       }
-      // Update lastChord for the next line
       if (currentChord) lastChord = currentChord
 
       i++
       // Find the paired lyric line (next line that isn't a chord line)
       let lyricLine = ''
       if (i < rawLines.length) {
-        // When pendingSplit would be set, also check continueSplit before treating as lyrics
         const nextIsChord = scanChordLine(rawLines[i])
         if (!nextIsChord) {
-          // Also check if it's a split continuation line
+          // Also check if it's a split continuation line — don't consume as lyrics
           if (!splitOpenToken || !scanChordLine(rawLines[i], { continueSplit: true })) {
             lyricLine = rawLines[i]
             i++
@@ -417,6 +443,8 @@ function parseChordLyricBlock(text) {
         if (c.push) ch.push = true
         if (c.stop) ch.stop = true
         if (c.splitMeasure) ch.splitMeasure = c.splitMeasure
+        if (c.splitOpen) ch.splitOpen = true
+        if (c.splitClose) ch.splitClose = true
         return ch
       }))
       if (lyricLine) allLyrics.push(lyricLine)
@@ -431,7 +459,7 @@ function parseChordLyricBlock(text) {
 
       // If we found a SPLIT_OPEN, set up pendingSplit for cross-line merging
       if (splitOpenToken) {
-        const splitChordIndex = chords.length - 1 // the split chord is the last one we added
+        const splitChordIndex = chords.length - 1
         pendingSplit = {
           lineData,
           chordIndex: splitChordIndex,

package/src/playback.js

@@ -85,6 +85,8 @@ export function buildPlaybackTimeline(structure, timeSignature) {
         for (let mi = 0; mi < markers.length; mi++) {
           const m = markers[mi]
           if (m.type === 'chord') {
+            // splitClose chords are already accounted for by the open chord's splitMeasure
+            if (m.chord.splitClose) continue
             lastExpanded = expandChord(m.chord, mi)
             measures.push(buildMeasure(lastExpanded, measureIndex, si, li, ts))
             measureIndex++

package/test/parser.test.js

@@ -303,7 +303,7 @@ describe('time signature parsing', () => {
 })
 
 describe('cross-line split measure parsing', () => {
-  it('parses cross-line split [F ... C] across chord lines', () => {
+  it('parses cross-line split with chords on separate lines at original columns', () => {
     const song = parse(
       'TEST - AUTHOR\n\n' +
       'G                               [F\n' +
@@ -312,17 +312,27 @@ describe('cross-line split measure parsing', () => {
       " I've been to Asheville once before"
     )
     const lines = song.structure[0].lines
-    // First line should have G and the split chord (F + C)
+    // Line 0: G at col 0, F at col 32 with splitOpen + splitMeasure
     expect(lines[0].chords.length).toBe(2)
     expect(lines[0].chords[0].root).toBe('G')
+    expect(lines[0].chords[0].column).toBe(0)
     expect(lines[0].chords[1].root).toBe('F')
+    expect(lines[0].chords[1].column).toBe(32)
+    expect(lines[0].chords[1].splitOpen).toBe(true)
     expect(lines[0].chords[1].splitMeasure).toEqual([
       { root: 'F', type: '' },
       { root: 'C', type: '' },
     ])
-    // Second line should have G (after the ])
-    expect(lines[1].chords.length).toBe(1)
-    expect(lines[1].chords[0].root).toBe('G')
+    expect(lines[0].lyrics).toBe(' Blue mountain road, North Carolina,')
+
+    // Line 1: C at col 15 with splitClose, G at col 33
+    expect(lines[1].chords.length).toBe(2)
+    expect(lines[1].chords[0].root).toBe('C')
+    expect(lines[1].chords[0].column).toBe(15)
+    expect(lines[1].chords[0].splitClose).toBe(true)
+    expect(lines[1].chords[1].root).toBe('G')
+    expect(lines[1].chords[1].column).toBe(33)
+    expect(lines[1].lyrics).toBe(" I've been to Asheville once before")
   })
 
   it('pairs lyrics correctly with cross-line split', () => {
@@ -338,7 +348,7 @@ describe('cross-line split measure parsing', () => {
     expect(lines[1].lyrics).toBe(' Asheville town')
   })
 
-  it('includes split measure chords in section allChords', () => {
+  it('includes split chords in section allChords with flags', () => {
     const song = parse(
       'TEST - AUTHOR\n\n' +
       'G [F\n' +
@@ -346,16 +356,19 @@ describe('cross-line split measure parsing', () => {
       'C] D\n' +
       ' Lyrics two'
     )
-    // allChords should include G, the split chord (F+C), and D
     const chords = song.structure[0].chords
-    expect(chords.length).toBe(3)
+    // G, F (splitOpen), C (splitClose), D
+    expect(chords.length).toBe(4)
     expect(chords[0].root).toBe('G')
     expect(chords[1].root).toBe('F')
+    expect(chords[1].splitOpen).toBe(true)
     expect(chords[1].splitMeasure).toEqual([
       { root: 'F', type: '' },
       { root: 'C', type: '' },
     ])
-    expect(chords[2].root).toBe('D')
+    expect(chords[2].root).toBe('C')
+    expect(chords[2].splitClose).toBe(true)
+    expect(chords[3].root).toBe('D')
   })
 })