@goplayerjuggler/abc-tools 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplayerjuggler/abc-tools",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "sorting algorithm and implementation for ABC tunes; plus other tools for parsing and manipulating ABC tunes",
   "main": "src/index.js",
   "scripts": {

package/src/incipit.js

@@ -308,7 +308,7 @@ function getIncipit(data) {
 
 function getIncipitForContourGeneration(
 	abc,
-	{ numBars = new Fraction(3, 2) } = {}
+	{ numBars = new Fraction(2, 1) } = {}
 ) {
 	return getIncipit({
 		abc,

package/src/index.js

@@ -4,6 +4,7 @@
  */
 
 const parser = require("./parse/parser.js");
+const miscParser = require("./parse/misc-parser.js");
 const manipulator = require("./manipulator.js");
 const sort = require("./sort/contour-sort.js");
 const contourToSvg = require("./sort/contour-svg.js");
@@ -12,10 +13,12 @@ const displayContour = require("./sort/display-contour.js");
 const incipit = require("./incipit.js");
 const javascriptify = require("./javascriptify.js");
 const getContour = require("./sort/get-contour.js");
+const math = require("./math.js");
 
 module.exports = {
 	// Parser functions
 	...parser,
+	...miscParser,
 
 	// Manipulator functions
 	...manipulator,
@@ -29,6 +32,7 @@ module.exports = {
 	// Incipit functions
 	...incipit,
 
-	//
+	// other
 	javascriptify,
+	...math,
 };

package/src/manipulator.js

@@ -1,9 +1,5 @@
 const { Fraction } = require("./math.js");
-const {
-	parseAbc,
-	getMeter,
-	calculateBarDurations,
-} = require("./parse/parser.js");
+const { parseAbc, getMeter } = require("./parse/parser.js");
 
 const { getBarInfo } = require("./parse/getBarInfo.js");
 
@@ -93,20 +89,38 @@ function filterHeaders(headerLines, headersToStrip) {
 }
 
 /**
- * Detect if ABC notation has an anacrusis (pickup bar)
+ * Detect if ABC notation has an anacrusis (pickup bar) from parsed data
  * @param {object} parsed - Parsed ABC data from parseAbc
  * @returns {boolean} - True if anacrusis is present
  */
 function hasAnacrucisFromParsed(parsed) {
-	const barDurations = calculateBarDurations(parsed);
-	const expectedBarDuration = new Fraction(parsed.meter[0], parsed.meter[1]);
+	const { bars, barLines, meter } = parsed;
+
+	if (bars.length === 0 || barLines.length === 0) {
+		return false;
+	}
+
+	// Use getBarInfo to analyse the first bar
+	const barInfo = getBarInfo(bars, barLines, meter, {
+		barNumbers: true,
+		isPartial: true,
+		cumulativeDuration: false,
+	});
+
+	// Find the first bar line with a barNumber (skip initial bar line if present)
+	const firstNumberedBarLine = barInfo.barLines.find(
+		(bl) => bl.barNumber !== null
+	);
 
-	if (parsed.bars.length === 0) {
+	if (!firstNumberedBarLine) {
 		return false;
 	}
 
-	const firstBarDuration = barDurations[0];
-	return firstBarDuration.compare(expectedBarDuration) < 0;
+	// Anacrusis is present if the first numbered bar line is partial with barNumber 0
+	return (
+		firstNumberedBarLine.barNumber === 0 &&
+		firstNumberedBarLine.isPartial === true
+	);
 }
 
 /**
@@ -142,7 +156,7 @@ function hasAnacrucis(abc) {
  * @param {Array<number>} smallMeter - The smaller meter signature [numerator, denominator]
  * @param {Array<number>} largeMeter - The larger meter signature [numerator, denominator]
  * @returns {string} ABC notation with toggled meter
- * @throws {Error} If the current meter doesn't match either smallMeter or largeMeter
+ * @throws {Error} If the current meter doesn’t match either smallMeter or largeMeter
  */
 function toggleMeterDoubling(abc, smallMeter, largeMeter) {
 	const currentMeter = getMeter(abc);
@@ -293,7 +307,7 @@ function toggleMeterDoubling(abc, smallMeter, largeMeter) {
 					decision.action === "remove" &&
 					!decision.variantToken
 				) {
-					// Remove bar line and ensure there's a space
+					// Remove bar line and ensure there’s a space
 					// Check if we already added a space (last char in newMusic)
 					const needsSpace =
 						newMusic.length === 0 || newMusic[newMusic.length - 1] !== " ";
@@ -363,10 +377,10 @@ function toggleMeter_6_8_to_12_8(abc) {
 }
 
 /**
- * Get the first N complete or partial bars from ABC notation, with or without the anacrusis
+ * Get the first N complete or partial musical bars from ABC notation, with or without the anacrusis
  * Preserves all formatting, comments, spacing, and line breaks
  * @param {string} abc - ABC notation
- * @param {number|Fraction} numBars - Number of bars to extract (can be fractional, e.g., 1.5 or new Fraction(3,2))
+ * @param {number|Fraction} numBars - Number of musical bars to extract (can be fractional, e.g., 1.5 or new Fraction(3,2))
  * @param {boolean} withAnacrucis - when flagged, the returned result also includes the anacrusis - incomplete bar (default: false)
  * @param {boolean} countAnacrucisInTotal - when true AND withAnacrucis is true, the anacrusis counts toward numBars duration (default: false)
  * @param {object} headersToStrip - optional header stripping configuration {all:boolean, toKeep:string}
@@ -379,94 +393,160 @@ function getFirstBars(
 	countAnacrucisInTotal = false,
 	headersToStrip
 ) {
-	// Convert numBars to Fraction if it's a number
+	// Convert numBars to Fraction if it’s a number
 	const numBarsFraction =
 		typeof numBars === "number" ? new Fraction(numBars) : numBars;
 
-	// Estimate maxBars needed - simple ceiling with buffer
-	const estimatedMaxBars =
-		Math.ceil(numBarsFraction.num / numBarsFraction.den) + 2;
+	// Estimate maxBars needed for parsing
+	const estimatedMaxBars = Math.ceil(numBarsFraction.toNumber()) * 2 + 2;
 
-	// Parse with estimated maxBars
+	// Parse ABC
 	const parsed = parseAbc(abc, { maxBars: estimatedMaxBars });
 	const { bars, headerLines, barLines, musicText, meter } = parsed;
 
-	const barDurations = calculateBarDurations(parsed);
-	const expectedBarDuration = new Fraction(meter[0], meter[1]);
-	const targetDuration = expectedBarDuration.multiply(numBarsFraction);
-
-	// Find first complete bar index
-	let firstCompleteBarIdx = -1;
-	for (let i = 0; i < bars.length; i++) {
-		const barDuration = barDurations[i];
-		if (barDuration.compare(expectedBarDuration) === 0) {
-			firstCompleteBarIdx = i;
-			break;
-		}
+	if (bars.length === 0 || barLines.length === 0) {
+		throw new Error("No bars found");
 	}
 
-	//todo
-	if (firstCompleteBarIdx === -1) {
-		throw new Error("No complete bars found");
-	}
+	// Determine which bar number to stop after
+	// We need to account for fractional bars, anacrusis handling, etc.
+	const wholeBarsNeeded = Math.ceil(numBarsFraction.toNumber());
+	const stopAfterBarNumber = wholeBarsNeeded + 1; // Add buffer for safety
+
+	// Get bar info up to the bar number we need
+	const barInfo = getBarInfo(bars, barLines, meter, {
+		barNumbers: true,
+		isPartial: true,
+		cumulativeDuration: true,
+		stopAfterBarNumber,
+	});
 
-	const hasPickup = firstCompleteBarIdx > 0;
+	const enrichedBarLines = barInfo.barLines;
+
+	// Detect if there’s an anacrusis
+	const firstNumberedBarLine = enrichedBarLines.find(
+		(bl) => bl.barNumber !== null
+	);
+	const hasPickup =
+		firstNumberedBarLine &&
+		firstNumberedBarLine.barNumber === 0 &&
+		firstNumberedBarLine.isPartial === true;
 
 	// Filter headers if requested
 	const filteredHeaders = filterHeaders(headerLines, headersToStrip);
 
-	// Determine starting position in the music text
+	// Calculate the expected duration per musical bar
+	const expectedBarDuration = new Fraction(meter[0], meter[1]);
+	const targetDuration = expectedBarDuration.multiply(numBarsFraction);
+
+	// Determine starting position and how much duration we need to accumulate
 	let startPos = 0;
-	if (hasPickup && withAnacrucis) {
-		// Include anacrusis in output
-		startPos = 0;
-	} else if (hasPickup && !withAnacrucis) {
-		// Skip anacrusis - start after its bar line
-		const anacrusisBarLine = barLines[firstCompleteBarIdx - 1];
-		if (anacrusisBarLine) {
-			startPos = anacrusisBarLine.sourceIndex + anacrusisBarLine.sourceLength;
+	let remainingDurationNeeded = targetDuration.clone();
+	let countingFromBarNumber = 0;
+
+	if (hasPickup) {
+		if (withAnacrucis) {
+			// Include anacrusis in output
+			startPos = 0;
+			if (countAnacrucisInTotal) {
+				// Subtract anacrusis duration from target
+				const anacrusisBarLine = enrichedBarLines.find(
+					(bl) => bl.barNumber === 0
+				);
+				if (anacrusisBarLine && anacrusisBarLine.cumulativeDuration) {
+					const anacrusisDuration =
+						anacrusisBarLine.cumulativeDuration.sinceLastBarLine;
+					remainingDurationNeeded =
+						remainingDurationNeeded.subtract(anacrusisDuration);
+				}
+				countingFromBarNumber = 1; // Start counting from first complete bar
+			} else {
+				// Don’t count anacrusis - we want full numBars after it
+				countingFromBarNumber = 1;
+			}
+		} else {
+			// Skip anacrusis - start after its bar line
+			const anacrusisBarLineIdx = enrichedBarLines.findIndex(
+				(bl) => bl.barNumber === 0
+			);
+			if (anacrusisBarLineIdx >= 0) {
+				const anacrusisBarLine = enrichedBarLines[anacrusisBarLineIdx];
+				startPos = anacrusisBarLine.sourceIndex + anacrusisBarLine.sourceLength;
+			}
+			countingFromBarNumber = 1;
 		}
+	} else {
+		// No anacrusis
+		startPos = 0;
+		countingFromBarNumber = 0;
 	}
 
-	// Calculate accumulated duration for target calculation
-	let accumulatedDuration = new Fraction(0, 1);
-	if (hasPickup && withAnacrucis && countAnacrucisInTotal) {
-		// Count anacrusis toward target
-		accumulatedDuration = barDurations[0];
-	}
-
-	// Find the end position by accumulating bar durations from first complete bar
+	// Determine which bar numbers we need based on remaining duration
+	const wholeBarsInRemaining = Math.floor(
+		remainingDurationNeeded.divide(expectedBarDuration).toNumber()
+	);
+	const fractionalPart = remainingDurationNeeded.subtract(
+		expectedBarDuration.multiply(new Fraction(wholeBarsInRemaining, 1))
+	);
+
+	const needsFractionalBar = fractionalPart.compare(new Fraction(0, 1)) > 0;
+	const finalTargetBarNumber =
+		countingFromBarNumber +
+		wholeBarsInRemaining +
+		(needsFractionalBar ? 0 : -1);
+
+	// Find end position
 	let endPos = startPos;
+	let foundEnd = false;
+
+	// Find all bar lines with our target bar numbers
+	const relevantBarLines = enrichedBarLines.filter(
+		(bl) =>
+			bl.barNumber !== null &&
+			bl.barNumber >= countingFromBarNumber &&
+			bl.barNumber <= finalTargetBarNumber
+	);
+
+	if (!needsFractionalBar) {
+		// For whole bars, find the bar line at finalTargetBarNumber
+		const finalBarLine = relevantBarLines.find(
+			(bl) => bl.barNumber === finalTargetBarNumber
+		);
+		if (finalBarLine) {
+			endPos = finalBarLine.sourceIndex + finalBarLine.sourceLength;
+			foundEnd = true;
+		}
+	} else {
+		// For fractional bars, we need to do duration counting within bars with finalTargetBarNumber
+		// Note: there may be multiple segments with the same barNumber (partial bars)
 
-	for (let i = firstCompleteBarIdx; i < bars.length; i++) {
-		const barDuration = barDurations[i];
-		const newAccumulated = accumulatedDuration.add(barDuration);
+		let accumulated = new Fraction(0, 1);
 
-		if (newAccumulated.compare(targetDuration) >= 0) {
-			// We've reached or exceeded target
+		// Iterate through bars and accumulate duration for bars with finalTargetBarNumber
+		for (let i = 0; i < bars.length; i++) {
+			const bar = bars[i];
+			if (bar.length === 0) continue;
 
-			if (newAccumulated.compare(targetDuration) === 0) {
-				// Exact match - include full bar with its bar line
-				if (i < barLines.length) {
-					endPos = barLines[i].sourceIndex + barLines[i].sourceLength;
-				}
-			} else {
-				// Need partial bar
-				const remainingDuration = targetDuration.subtract(accumulatedDuration);
-				const bar = bars[i];
-				let barAccumulated = new Fraction(0, 1);
+			// Find the bar line that follows this bar to get its barNumber
+			const barLineIdx = enrichedBarLines.findIndex(
+				(bl) => bl.sourceIndex >= bar[bar.length - 1].sourceIndex
+			);
+
+			if (barLineIdx < 0) continue;
+
+			const barLine = enrichedBarLines[barLineIdx];
 
+			if (barLine.barNumber === finalTargetBarNumber) {
+				// This bar segment is part of our target bar number
 				for (const token of bar) {
-					// Skip tokens with no duration
 					if (!token.duration) {
 						continue;
 					}
 
-					barAccumulated = barAccumulated.add(token.duration);
+					const newAccumulated = accumulated.add(token.duration);
 
-					// Check if we've reached or exceeded the remaining duration
-					if (barAccumulated.compare(remainingDuration) >= 0) {
-						// Include this note
+					if (newAccumulated.compare(fractionalPart) >= 0) {
+						// Found the position - include this token
 						endPos = token.sourceIndex + token.sourceLength;
 
 						// Skip trailing space if present
@@ -478,24 +558,21 @@ function getFirstBars(
 						) {
 							endPos++;
 						}
+						foundEnd = true;
 						break;
 					}
+
+					accumulated = newAccumulated;
 				}
+
+				if (foundEnd) break;
 			}
-			break;
 		}
-
-		accumulatedDuration = newAccumulated;
 	}
 
-	// if (endPos === startPos) {
-	// 	throw new Error(
-	// 		`Not enough bars to satisfy request. Requested ${numBars} bars.`
-	// 	);
-	// }
-
-	if (endPos === startPos) {
-		endPos = musicText.length - 1;
+	// Fallback: if we didn’t find an end, use the last available position
+	if (!foundEnd || endPos === startPos) {
+		endPos = musicText.length;
 	}
 
 	// Reconstruct ABC

package/src/parse/barline-parser.js

@@ -49,11 +49,11 @@ function parseBarLine(barLineStr) {
 	// End repeat
 	if (trimmed.match(/^:/)) {
 		result.isRepeatL = true;
-		result.isSectionBreak = true
+		result.isSectionBreak = true;
 	}
 
-	// Double bar
-	if (trimmed.match(/\|\|/)){
+	// Double bar & other cases: "...ends with one of ||, :| |] or [|"
+	if (trimmed.match(/\|\||\|]|\[\|/)) {
 		result.isSectionBreak = true;
 	}
 	return result;