@goplayerjuggler/abc-tools 1.0.9 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplayerjuggler/abc-tools",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "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

@@ -3,8 +3,7 @@ const { Fraction } = require("./math.js");
 const { getFirstBars } = require("./manipulator.js");
 
 const { getUnitLength, getMeter } = require("./parse/parser.js");
-
-const { getContour } = require("./sort/contour-sort.js");
+const { getContour } = require("./sort/get-contour.js");
 
 //this file has code that's a fork of some code in  Michael Eskin's abctools
 
@@ -307,20 +306,33 @@ function getIncipit(data) {
 	return getFirstBars(abc, numBars, withAnacrucis, false, { all: true });
 }
 
-function getIncipitForContourGeneration(abc) {
+function getIncipitForContourGeneration(
+	abc,
+	{ numBars = new Fraction(3, 2) } = {}
+) {
 	return getIncipit({
 		abc,
 		withAnacrucis: false,
-		numBars: 1,
+		numBars,
 	});
 }
 
-function getContourFromFullAbc(abc) {
+function getContourFromFullAbc(
+	abc,
+	{
+		withSvg = true,
+		withSwingTransform = false,
+		numBars = new Fraction(3, 2),
+	} = {}
+) {
 	if (Array.isArray(abc)) {
 		if (abc.length === 0) return null;
 		abc = abc[0];
 	}
-	return getContour(getIncipitForContourGeneration(abc), { withSvg: true });
+	return getContour(getIncipitForContourGeneration(abc, { numBars }), {
+		withSvg,
+		withSwingTransform,
+	});
 }
 
 module.exports = {

package/src/index.js

@@ -11,6 +11,7 @@ const displayContour = require("./sort/display-contour.js");
 
 const incipit = require("./incipit.js");
 const javascriptify = require("./javascriptify.js");
+const getContour = require("./sort/get-contour.js");
 
 module.exports = {
 	// Parser functions
@@ -23,6 +24,7 @@ module.exports = {
 	...sort,
 	...displayContour,
 	...contourToSvg,
+	...getContour,
 
 	// Incipit functions
 	...incipit,

package/src/manipulator.js

@@ -5,6 +5,8 @@ const {
 	calculateBarDurations,
 } = require("./parse/parser.js");
 
+const { getBarInfo } = require("./parse/getBarInfo.js");
+
 // ============================================================================
 // ABC manipulation functions
 // ============================================================================
@@ -43,14 +45,14 @@ function normaliseKey(keyHeader) {
 		major: "major",
 		ion: "major",
 		ionian: "major",
+		mix: "mixolydian",
+		mixo: "mixolydian",
+		mixolydian: "mixolydian",
 		m: "minor",
 		min: "minor",
 		minor: "minor",
 		aeo: "minor",
 		aeolian: "minor",
-		mix: "mixolydian",
-		mixo: "mixolydian",
-		mixolydian: "mixolydian",
 		dor: "dorian",
 		dorian: "dorian",
 		phr: "phrygian",
@@ -116,58 +118,31 @@ function hasAnacrucis(abc) {
 	const parsed = parseAbc(abc, { maxBars: 2 });
 	return hasAnacrucisFromParsed(parsed);
 }
-/**
- * Inserts a specified character at multiple positions within a string.
- * Optimised for performance with long strings and repeated usage.
- *
- * @param {string} originalString - The original string to modify.
- * @param {string} charToInsert - The character to insert at the specified positions.
- * @param {number[]} indexes - An array of positions (zero-based) where the character should be inserted.
- * @returns {string} The modified string with characters inserted at the specified positions.
- *
- * // Example usage:
- * const originalString = "hello world";
- * const charToInsert = "!";
- * const indexes = [2, 5, 8, 2, 15];
- * const result = insertCharsAtIndexes(originalString, charToInsert, indexes);
- * console.log(result); // Output: "he!l!lo! world!"
- *
- */
-function insertCharsAtIndexes(originalString, charToInsert, indexes) {
-	// Filter and sort indexes only once: remove duplicates and invalid positions
-	const validIndexes = [...new Set(indexes)]
-		.filter((index) => index >= 0 && index <= originalString.length)
-		.sort((a, b) => a - b);
-
-	const result = [];
-	let prevIndex = 0;
-
-	for (const index of validIndexes) {
-		// Push the substring up to the current index
-		result.push(originalString.slice(prevIndex, index));
-		// Push the character to insert
-		result.push(charToInsert);
-		// Update the previous index
-		prevIndex = index;
-	}
-
-	// Push the remaining part of the string
-	result.push(originalString.slice(prevIndex));
-
-	return result.join("");
-}
 
 /**
  * Toggle meter by doubling or halving bar length
  * Supports 4/4↔4/2 and 6/8↔12/8 transformations
- * This is nearly a true inverse operation - going there and back preserves the ABC except for some
- * edge cases involving spaces around the bar lines. No need to handle them.
- * Handles anacrusis correctly and preserves line breaks
  *
- * @param {string} abc - ABC notation
- * @param {Array<number>} smallMeter - The smaller meter signature [num, den]
- * @param {Array<number>} largeMeter - The larger meter signature [num, den]
- * @returns {string} - ABC with toggled meter
+ * When going from small to large meters (e.g., 4/4→4/2):
+ * - Removes alternate bar lines to combine pairs of bars
+ * - Converts variant ending markers from |1, |2 to [1, [2 format
+ * - Respects section breaks (||, :|, etc.) and resets pairing after them
+ * - Handles bars starting with variant endings by keeping the bar line after them
+ *
+ * When going from large to small meters (e.g., 4/2→4/4):
+ * - Inserts bar lines at halfway points within each bar
+ * - Preserves variant ending markers in [1, [2 format (does not convert back to |1, |2)
+ * - Inserts bar lines before variant endings when they occur at the split point
+ *
+ * This is nearly a true inverse operation - going there and back preserves musical content
+ * but may change spacing around bar lines and normalises variant ending syntax to [1, [2 format.
+ * Correctly handles anacrusis (pickup bars), multi-bar variant endings, partial bars, and preserves line breaks.
+ *
+ * @param {string} abc - ABC notation string
+ * @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
  */
 function toggleMeterDoubling(abc, smallMeter, largeMeter) {
 	const currentMeter = getMeter(abc);
@@ -183,14 +158,8 @@ function toggleMeterDoubling(abc, smallMeter, largeMeter) {
 		);
 	}
 
-	if (isSmall) {
-		// We're going to remove some bars, so ensure every bar line (pipe / `|`) has a space preceding it
-		// Regex handles bars like :| and [|]
-		abc = abc.replaceAll(/([^\s])([[:]?\|)/g, "$1 $2");
-	}
-
 	const parsed = parseAbc(abc);
-	const { headerLines, barLines, musicText } = parsed;
+	const { headerLines, barLines, musicText, bars, meter } = parsed;
 
 	// Change meter in headers
 	const newHeaders = headerLines.map((line) => {
@@ -202,80 +171,174 @@ function toggleMeterDoubling(abc, smallMeter, largeMeter) {
 		return line;
 	});
 
-	const hasPickup = hasAnacrucisFromParsed(parsed);
-
 	if (isSmall) {
-		// Going from small to large: remove every other bar line (except final)
-		const barLinesToRemove = new Set();
-		const startIndex = hasPickup ? 1 : 0;
-
-		for (let i = startIndex; i < barLines.length - 1; i += 2) {
-			barLinesToRemove.add(barLines[i].sourceIndex);
+		// Going from small to large: remove every other bar line
+		// Get bar info with barNumbers to understand the musical structure
+		getBarInfo(bars, barLines, meter, {
+			barNumbers: true,
+			isPartial: true,
+		});
+
+		// Build a map of which bars start with variant endings
+		const barStartsWithVariant = new Map();
+		for (let i = 0; i < bars.length; i++) {
+			if (bars[i].length > 0 && bars[i][0].isVariantEnding) {
+				barStartsWithVariant.set(i, bars[i][0]);
+			}
 		}
 
-		// Reconstruct music by removing marked bar lines
-		let newMusic = "";
-		let lastPos = 0;
+		// Determine which bar lines to keep or remove
+		const barLineDecisions = new Map(); // barLineIndex -> {action, variantToken?}
+		let barPosition = 0; // Position within current pairing (0 or 1)
+		let barNumberOfStartOfSection = 0;
 
 		for (let i = 0; i < barLines.length; i++) {
 			const barLine = barLines[i];
-			newMusic += musicText.substring(lastPos, barLine.sourceIndex);
 
-			if (!barLinesToRemove.has(barLine.sourceIndex)) {
-				lastPos = barLine.sourceIndex;
+			// Initial bar line is always kept
+			if (barLine.barNumber === null) {
+				barLineDecisions.set(i, { action: "keep" });
+				continue;
+			}
+
+			// initial anacrucis bar line of section is always kept
+			if (
+				barLine.barNumber === barNumberOfStartOfSection &&
+				barLine.isPartial
+			) {
+				barLineDecisions.set(i, { action: "keep" });
+				continue;
+			}
+
+			// Final bar line is always kept
+			if (i === barLines.length - 1) {
+				barLineDecisions.set(i, { action: "keep" });
+				continue;
+			}
+
+			// Section breaks are always kept and reset pairing
+			if (barLine.isSectionBreak) {
+				barLineDecisions.set(i, { action: "keep" });
+				barPosition = 0;
+				barNumberOfStartOfSection = barLine.barNumber;
+				continue;
+			}
+
+			// barLines[i] comes after bars[i], so the NEXT bar is bars[i+1]
+			const nextBarIdx = i + 1;
+			const nextBarVariant =
+				nextBarIdx < bars.length ? barStartsWithVariant.get(nextBarIdx) : null;
+
+			// If the current bar (bars[i]) starts with a variant, keep its bar line and reset position
+			const currentBarVariant = barStartsWithVariant.get(i);
+			if (currentBarVariant) {
+				barLineDecisions.set(i, { action: "keep" });
+				barPosition = 0;
+				continue;
+			}
+
+			// Normal pairing logic
+			if (barPosition === 0) {
+				// First of pair - remove
+				if (nextBarVariant) {
+					barLineDecisions.set(i, {
+						action: "remove",
+						variantToken: nextBarVariant,
+					});
+				} else {
+					barLineDecisions.set(i, { action: "remove" });
+				}
+				barPosition = 1;
 			} else {
-				// Remove the bar line - skip over it
-				lastPos = barLine.sourceIndex + barLine.sourceLength;
+				// Second of pair - keep
+				barLineDecisions.set(i, { action: "keep" });
+				barPosition = 0;
 			}
 		}
-		newMusic += musicText.substring(lastPos);
 
-		return `${newHeaders.join("\n")}\n${newMusic}`;
-	} else {
-		// Going from large to small: add bar line in middle of each bar
-		const halfBarDuration = new Fraction(smallMeter[0], smallMeter[1]);
-		const insertionPoints = [];
-		const startBarIndex = hasPickup ? 1 : 0;
-
-		for (let barIdx = startBarIndex; barIdx < parsed.bars.length; barIdx++) {
-			const bar = parsed.bars[barIdx];
-			let barDuration = new Fraction(0, 1);
-			let insertPos = null;
-
-			// Find position where we've accumulated half a bar
-			for (let noteIdx = 0; noteIdx < bar.length; noteIdx++) {
-				const token = bar[noteIdx];
-
-				// Skip tokens with no duration
-				if (!token.duration) {
-					continue;
-				}
+		// Track variant replacements
+		const variantReplacements = new Map();
+		for (const [, decision] of barLineDecisions) {
+			if (decision.action === "remove" && decision.variantToken) {
+				const token = decision.variantToken;
+				const newToken = token.token.replace(/^\|/, "[");
+				variantReplacements.set(token.sourceIndex, {
+					oldLength: token.sourceLength,
+					newText: " " + newToken,
+				});
+			}
+		}
+
+		// Reconstruct music
+		let newMusic = "";
+		let pos = 0;
+
+		while (pos < musicText.length) {
+			// Check for variant replacement
+			if (variantReplacements.has(pos)) {
+				const replacement = variantReplacements.get(pos);
+				newMusic += replacement.newText;
+				pos += replacement.oldLength;
+				continue;
+			}
 
-				const prevDuration = barDuration.clone();
-				barDuration = barDuration.add(token.duration);
+			// Check for bar line
+			const barLineIdx = barLines.findIndex((bl) => bl.sourceIndex === pos);
+			if (barLineIdx >= 0) {
+				const decision = barLineDecisions.get(barLineIdx);
+				const barLine = barLines[barLineIdx];
 
-				// Check if we've just crossed the halfway point
 				if (
-					prevDuration.compare(halfBarDuration) < 0 &&
-					barDuration.compare(halfBarDuration) >= 0
+					decision &&
+					decision.action === "remove" &&
+					!decision.variantToken
 				) {
-					// Insert bar line after this note
-					insertPos = token.sourceIndex + token.sourceLength;
-					// Skip any trailing space that's part of this note
-					if (token.spacing && token.spacing.whitespace) {
-						insertPos += token.spacing.whitespace.length;
+					// 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] !== " ";
+					if (needsSpace) {
+						newMusic += " ";
 					}
-					break;
+					let skipLength = barLine.sourceLength;
+					// Skip any trailing space after the bar line to avoid double spaces
+					if (
+						pos + skipLength < musicText.length &&
+						musicText[pos + skipLength] === " "
+					) {
+						skipLength++;
+					}
+					pos += skipLength;
+					continue;
+				} else if (decision && decision.action === "keep") {
+					// Keep this bar line
+					newMusic += musicText.substring(pos, pos + barLine.sourceLength);
+					pos += barLine.sourceLength;
+					continue;
 				}
 			}
 
-			if (insertPos !== null) {
-				insertionPoints.push(insertPos);
-			}
+			// Regular character
+			newMusic += musicText[pos];
+			pos++;
 		}
 
+		return `${newHeaders.join("\n")}\n${newMusic}`;
+	} else {
+		// Going from large to small: add bar lines at midpoints
+		const barInfo = getBarInfo(bars, barLines, meter, {
+			divideBarsBy: 2,
+		});
+
+		const { midpoints } = barInfo;
+
 		// Insert bar lines at calculated positions
-		const newMusic = insertCharsAtIndexes(musicText, "| ", insertionPoints);
+		const insertionPoints = [...midpoints].sort((a, b) => b - a);
+		let newMusic = musicText;
+
+		for (const pos of insertionPoints) {
+			newMusic = newMusic.substring(0, pos) + "| " + newMusic.substring(pos);
+		}
 
 		return `${newHeaders.join("\n")}\n${newMusic}`;
 	}
@@ -318,9 +381,7 @@ function getFirstBars(
 ) {
 	// Convert numBars to Fraction if it's a number
 	const numBarsFraction =
-		typeof numBars === "number"
-			? new Fraction(Math.round(numBars * 1000), 1000)
-			: numBars;
+		typeof numBars === "number" ? new Fraction(numBars) : numBars;
 
 	// Estimate maxBars needed - simple ceiling with buffer
 	const estimatedMaxBars =
@@ -344,6 +405,7 @@ function getFirstBars(
 		}
 	}
 
+	//todo
 	if (firstCompleteBarIdx === -1) {
 		throw new Error("No complete bars found");
 	}
@@ -426,10 +488,14 @@ function getFirstBars(
 		accumulatedDuration = newAccumulated;
 	}
 
+	// if (endPos === startPos) {
+	// 	throw new Error(
+	// 		`Not enough bars to satisfy request. Requested ${numBars} bars.`
+	// 	);
+	// }
+
 	if (endPos === startPos) {
-		throw new Error(
-			`Not enough bars to satisfy request. Requested ${numBars} bars.`
-		);
+		endPos = musicText.length - 1;
 	}
 
 	// Reconstruct ABC

package/src/math.js

@@ -12,6 +12,10 @@ class Fraction {
 		) {
 			throw new Error("invalid argument");
 		}
+		// if (!Number.isInteger(numerator)) {
+		// 	numerator = Math.round(numerator * 1000);
+		// 	denominator = denominator * 1000;
+		// }
 
 		const g = gcd(Math.abs(numerator), Math.abs(denominator));
 		this.num = numerator / g;
@@ -23,11 +27,16 @@ class Fraction {
 			this.den = -this.den;
 		}
 	}
-
 	clone() {
 		return new Fraction(this.num, this.den);
 	}
 
+	static min(x, y) {
+		if (!x) return y;
+		if (!y) return x;
+		return x.compare(y) < 0 ? x : y;
+	}
+
 	multiply(n) {
 		if (typeof n === "number") {
 			return new Fraction(this.num * n, this.den);
@@ -59,7 +68,7 @@ class Fraction {
 	compare(other) {
 		// Returns -1 if this < other, 0 if equal, 1 if this > other
 		const diff =
-			typeof n === "number"
+			typeof other === "number"
 				? this.num - other * this.den
 				: this.num * other.den - other.num * this.den;
 		return diff < 0 ? -1 : diff > 0 ? 1 : 0;

package/src/parse/getBarInfo.js

@@ -0,0 +1,202 @@
+const { Fraction } = require("../math.js");
+
+/**
+ * Enriches parsed ABC bar data with musical bar information
+ *
+ * Analyzes bars and bar lines to add:
+ * - barNumber: Index of the musical bar (null for initial bar lines)
+ * - isPartial: Flag for bar lines that occur mid-musical-bar
+ * - cumulativeDuration: Duration tracking for bar segments
+ * - midpoints: Positions where bars should be split (when divideBarsBy specified)
+ *
+ * A "musical bar" is defined by the meter (e.g., 4/4 means 4 quarter notes).
+ * Bar lines can create "partial bars" when repeats or variant endings split a musical bar.
+ * Consecutive partial bars within the same musical bar will have the same barNumber.
+ * Variant endings create alternative paths, so duration tracking follows one path at a time.
+ *
+ * @param {Array<Array<Object>>} bars - Array of bar arrays from parseAbc
+ * @param {Array<Object>} barLines - Array of barLine objects from parseAbc
+ * @param {Array<number>} meter - [numerator, denominator] from parseAbc
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.barNumbers - Add barNumber to each barLine. Default value: true.
+ * @param {boolean} options.isPartial - Add isPartial flag to partial barLines. Default value: true.
+ * @param {boolean} options.cumulativeDuration - Add duration tracking to barLines. Default value: true.
+ * @param {number|null} options.divideBarsBy - Find midpoints for splitting (only 2 supported)
+ * @returns {Object} - { barLines: enriched array, midpoints: insertion positions }
+ */
+function getBarInfo(bars, barLines, meter, options = {}) {
+	const {
+		barNumbers = true,
+		isPartial = true,
+		cumulativeDuration = true,
+		divideBarsBy = null,
+	} = options;
+
+	if (divideBarsBy !== null && divideBarsBy !== 2) {
+		throw new Error("divideBarsBy currently only supports value 2");
+	}
+	if (!barLines || barLines.length < bars.length) {
+		throw new Error(
+			"currently not handling bars without a bar line at the end"
+		);
+	}
+
+	const fullBarDuration = new Fraction(meter[0], meter[1]);
+	const midpoints = [];
+
+	let currentBarNumber = 0;
+	let durationSinceLastComplete = new Fraction(0, 1);
+	let lastCompleteBarLineIdx = -1;
+	let barLineOffset = 0;
+
+	// Check for initial bar line (before any music)
+	if (
+		bars.length > 0 &&
+		bars[0].length > 0 &&
+		barLines.length > 0 &&
+		barLines[0].sourceIndex < bars[0][0].sourceIndex
+	) {
+		// Initial bar line exists
+		if (barNumbers) {
+			barLines[0].barNumber = null;
+		}
+		barLineOffset = 1;
+	}
+
+	// Process each bar and its following bar line
+	for (let barIdx = 0; barIdx < bars.length; barIdx++) {
+		const bar = bars[barIdx];
+		const barLineIdx = barIdx + barLineOffset;
+
+		// Check if this bar starts with a variant ending
+		const startsWithVariant = bar.length > 0 && bar[0].isVariantEnding;
+
+		// If this bar starts with a variant, reset duration tracking
+		// (variant endings create alternative paths)
+		if (startsWithVariant && lastCompleteBarLineIdx >= 0) {
+			durationSinceLastComplete = new Fraction(0, 1);
+		}
+
+		// Calculate duration of this bar segment
+		let barDuration = new Fraction(0, 1);
+		for (const token of bar) {
+			if (token.duration) {
+				barDuration = barDuration.add(token.duration);
+			}
+		}
+
+		durationSinceLastComplete = durationSinceLastComplete.add(barDuration);
+
+		// Get the bar line that follows this bar
+		if (barLineIdx < barLines.length) {
+			const barLine = barLines[barLineIdx];
+
+			// Determine if this bar line is partial
+			// A bar line is partial if THIS bar segment is less than full bar duration
+			const isPartialBar = barDuration.compare(fullBarDuration) < 0;
+
+			// Add barNumber
+			if (barNumbers) {
+				if (isPartialBar) {
+					// Partial bar line: barNumber is lastComplete + 1
+					barLine.barNumber =
+						lastCompleteBarLineIdx >= 0
+							? barLines[lastCompleteBarLineIdx].barNumber + 1
+							: 0;
+
+					// If this is the initial anacrusis (barNumber 0), mark it as complete for numbering purposes
+					if (barLine.barNumber === 0) {
+						lastCompleteBarLineIdx = barLineIdx;
+						currentBarNumber = 1; // Next complete bar will be bar 1
+					}
+
+					// If partial bars have accumulated to a full bar, increment currentBarNumber
+					if (durationSinceLastComplete.compare(fullBarDuration) >= 0) {
+						currentBarNumber = barLine.barNumber + 1;
+						lastCompleteBarLineIdx = barLineIdx;
+					}
+				} else {
+					// Complete bar line
+					barLine.barNumber = currentBarNumber;
+					currentBarNumber++;
+					lastCompleteBarLineIdx = barLineIdx;
+				}
+			}
+
+			// Add isPartial flag (only when true)
+			if (isPartial && isPartialBar) {
+				barLine.isPartial = true;
+			}
+
+			// Add cumulative duration
+			if (cumulativeDuration) {
+				barLine.cumulativeDuration = {
+					sinceLastBarLine: barDuration.clone(),
+					sinceLastComplete: durationSinceLastComplete.clone(),
+				};
+			}
+
+			// Reset duration tracking if this completes a musical bar
+			// Also reset after initial anacrusis (barNumber 0)
+			if (lastCompleteBarLineIdx === barLineIdx || barLine.barNumber === 0) {
+				durationSinceLastComplete = new Fraction(0, 1);
+			}
+		}
+	}
+
+	// Calculate midpoints if requested
+	if (divideBarsBy === 2) {
+		const halfBarDuration = fullBarDuration.divide(new Fraction(2, 1));
+
+		for (let barIdx = 0; barIdx < bars.length; barIdx++) {
+			const bar = bars[barIdx];
+			let accumulated = new Fraction(0, 1);
+
+			// Check if this bar starts with a variant - if so, skip it
+			// (variant endings already create splits)
+			if (bar.length > 0 && bar[0].isVariantEnding) {
+				continue;
+			}
+
+			// Find the halfway point in this bar
+			for (let tokenIdx = 0; tokenIdx < bar.length; tokenIdx++) {
+				const token = bar[tokenIdx];
+
+				// If we hit a variant ending before halfway, don't split
+				if (token.isVariantEnding) {
+					break;
+				}
+
+				if (!token.duration) {
+					continue;
+				}
+
+				const prevAccumulated = accumulated.clone();
+				accumulated = accumulated.add(token.duration);
+
+				// Check if we just crossed the halfway point
+				if (
+					prevAccumulated.compare(halfBarDuration) < 0 &&
+					accumulated.compare(halfBarDuration) >= 0
+				) {
+					// Insert after this token
+					let insertPos = token.sourceIndex + token.sourceLength;
+					if (token.spacing && token.spacing.whitespace) {
+						insertPos += token.spacing.whitespace.length;
+					}
+					midpoints.push(insertPos);
+					break;
+				}
+			}
+		}
+	}
+
+	return {
+		barLines,
+		midpoints,
+	};
+}
+
+module.exports = {
+	getBarInfo,
+};

package/src/parse/header-parser.js

@@ -13,7 +13,7 @@ const { Fraction } = require("../math.js");
 // ============================================================================
 
 /**
- * Extract key signature from ABC header
+ * Extract base note of key signature from ABC header
  *
  * @param {string} abc - ABC notation string
  * @returns {string} - Tonic note (e.g., 'C', 'D', 'G')
@@ -27,6 +27,20 @@ function getTonalBase(abc) {
 	return keyMatch[1].toUpperCase();
 }
 
+/**
+ * Extract key signature from ABC header
+ *
+ * @param {string} abc - ABC notation string
+ * @returns {string} - Tonic note (e.g., 'C', 'D', 'G')
+ * @throws {Error} - If no key signature found
+ */
+function getKey(abc) {
+	const keyMatch = abc.match(/^K:\s*([A-G].*)/m);
+	if (!keyMatch) {
+		throw new Error("No key signature found in ABC");
+	}
+	return keyMatch[1];
+}
 /**
  * Extract meter/time signature from ABC header
  *
@@ -151,4 +165,5 @@ module.exports = {
 	getUnitLength,
 	getMusicLines,
 	getTitles,
+	getKey,
 };

package/src/parse/parser.js

@@ -2,6 +2,7 @@ const { Fraction } = require("../math.js");
 const {
 	getTonalBase,
 	getMeter,
+	getKey,
 	getUnitLength,
 	getMusicLines,
 } = require("./header-parser.js");
@@ -70,7 +71,7 @@ const {
  * Returns object with:
  * {
  *   bars: Array<Array<ScoreObject>>,  // Array of bars, each bar is array of ScoreObjects
- * 		// A Score object is almost anything that isn’t a bar line: note/chord/field/broken rhythm/tuplet/1st or 2nd repeat or variant ending
+ * 		// A ScoreObject is almost anything that isn’t a bar line: note/chord/field/broken rhythm/tuplet/1st or 2nd repeat or variant ending
  *   barLines: Array<BarLineObject>,  // Array of bar line information
  *   unitLength: Fraction,             // The L: field value (default 1/8)
  *   meter: [number, number],          // The M: field value (default [4,4])
@@ -484,7 +485,7 @@ function parseAbc(abc, options = {}) {
 			...barLineInfo,
 			sourceIndex: barLinePos,
 			sourceLength: barLineText.length,
-			barNumber: barCount,
+			//barNumber: barCount,
 			hasLineBreak: hasLineBreakAfterBar,
 		});
 
@@ -602,6 +603,7 @@ function getTunes(text) {
 
 module.exports = {
 	getTunes,
+	getKey,
 	parseAbc,
 	calculateBarDurations,
 	// Re-export utilities for convenience

package/src/sort/contour-sort.js

@@ -1,173 +1,13 @@
 const { Fraction } = require("../math.js");
-const {
-	getTonalBase,
-	getUnitLength,
-	parseAbc,
-	getMeter,
-} = require("../parse/parser.js");
 
-const { contourToSvg } = require("./contour-svg.js");
-
-const {
-	calculateModalPosition,
-	decodeChar,
-	encodeToChar,
-	silenceChar,
-} = require("./encode.js");
+const { decodeChar, encodeToChar, silenceChar } = require("./encode.js");
+const { getContour } = require("./get-contour.js");
 
 /**
  * Tune Contour Sort - Modal melody sorting algorithm
  * Sorts tunes by their modal contour, independent of key and mode
  */
 
-// ============================================================================
-// Contour (compare object) generation
-// ============================================================================
-
-/**
- * Generate contour (compare object) from ABC notation
- * @returns { sortKey: string, durations: Array, version: string, part: string }
- *
- * todo: complete this header. options.withSvg; options.maxNbUnitLengths
- */
-function getContour(
-	abc,
-	{ withSvg = false, maxNbUnitLengths = 10, svgConfig = {} } = {}
-) {
-	const tonalBase = getTonalBase(abc);
-	const unitLength = getUnitLength(abc);
-	const maxDuration = unitLength.multiply(maxNbUnitLengths);
-	const meter = getMeter(abc);
-	const maxNbBars = meter
-		? maxDuration.divide(new Fraction(meter[0], meter[1]))
-		: new Fraction(2, 1); //default 2 bars when no meter (free meter)
-	const { bars } = parseAbc(abc, {
-		maxBars: Math.ceil(maxNbBars.toNumber()),
-	});
-	let cumulatedDuration = new Fraction(0, 1);
-	const sortKey = [];
-	const durations = [];
-	// const debugPositions = [];
-	let index = 0;
-	// get the parsed notes - notes are tokens with a duration
-	const notes = [];
-	let tied = false,
-		previousPosition = null;
-	for (let i = 0; i < bars.length; i++) {
-		const bar = bars[i];
-		for (let j = 0; j < bar.length; j++) {
-			const token = bar[j];
-			if (token.duration && token.duration.num > 0) {
-				cumulatedDuration = cumulatedDuration.add(token.duration);
-				if (cumulatedDuration.isGreaterThan(maxDuration)) break;
-				notes.push(token);
-			}
-		}
-	}
-
-	notes.forEach((note) => {
-		const { duration, isSilence } = note;
-		const comparison = duration.compare(unitLength);
-		const { encoded, encodedHeld, position } = isSilence
-			? { encoded: silenceChar, encodedHeld: silenceChar, position: 0 }
-			: getEncodedFromNote(note, tonalBase, tied, previousPosition);
-
-		if (note.tied) {
-			tied = true;
-			previousPosition = position;
-		} else {
-			tied = false;
-			previousPosition = null;
-		}
-
-		if (comparison > 0) {
-			// Held note: duration > unitLength
-			const ratio = duration.divide(unitLength);
-			const nbUnitLengths = Math.floor(ratio.num / ratio.den);
-			const remainingDuration = duration.subtract(
-				unitLength.multiply(nbUnitLengths)
-			);
-
-			// const durationRatio = Math.round(ratio.num / ratio.den);
-
-			// First note is played
-			sortKey.push(encoded);
-			//debugPositions.push(position);
-
-			// Subsequent notes are held
-			for (let i = 1; i < nbUnitLengths; i++) {
-				sortKey.push(encodedHeld);
-				//debugPositions.push(position);
-			}
-
-			index += nbUnitLengths;
-			if (remainingDuration.num !== 0) {
-				pushShortNote(
-					encodedHeld,
-					unitLength,
-					duration,
-					index,
-					durations,
-					sortKey
-				);
-				//debugPositions.push(position);
-				index++;
-			}
-		} else if (comparison < 0) {
-			pushShortNote(encoded, unitLength, duration, index, durations, sortKey);
-			//debugPositions.push(position);
-			index++;
-		} else {
-			// Normal note: duration === unitLength
-			sortKey.push(encoded);
-			//debugPositions.push(position);
-			index++;
-		}
-	});
-
-	const result = {
-		sortKey: sortKey.join(""),
-		//debugPositions: debugPositions.join(","),
-	};
-	if (durations.length > 0) {
-		result.durations = durations;
-	}
-	if (withSvg) {
-		result.svg = contourToSvg(result, svgConfig);
-	}
-	return result;
-}
-
-/**
- * Adds a short note (duration < unitLength) to the contour
- * @param {string} encoded - the encoded representation of the note’s modal degree information (MDI)
- * @param {Fraction} unitLength - the unit length
- * @param {Fraction} duration - the duration of the note
- * @param {number} index - the index of the note
- * @param {Array<object>} durations - the durations array
- * @param {Array<string>} sortKey - array of MDIs
- */
-function pushShortNote(
-	encoded,
-	unitLength,
-	duration,
-	index,
-	durations,
-	sortKey
-) {
-	const relativeDuration = duration.divide(unitLength),
-		d = {
-			i: index,
-			d: relativeDuration.den,
-		};
-	if (relativeDuration.num !== 1) {
-		d.n = relativeDuration.num;
-	}
-
-	durations.push(d);
-	sortKey.push(encoded);
-}
-
 // ============================================================================
 // COMPARISON FUNCTIONS
 // ============================================================================
@@ -352,26 +192,11 @@ function sortArray(arr) {
 	return arr;
 }
 
-function getEncodedFromNote(note, tonalBase, tied, previousPosition) {
-	// Handle pitched note
-	const { pitch, octave } = note;
-	const position = calculateModalPosition(tonalBase, pitch, octave);
-	const encodedHeld = encodeToChar(position, true);
-	const encoded = encodeToChar(position, false);
-
-	return {
-		encoded: tied && position === previousPosition ? encodedHeld : encoded,
-		encodedHeld,
-		position,
-	};
-}
-
 // ============================================================================
 // EXPORTS
 // ============================================================================
 
 module.exports = {
-	getContour,
 	compare,
 	sortArray,
 	decodeChar,

package/src/sort/get-contour.js

@@ -0,0 +1,333 @@
+const { Fraction } = require("../math.js");
+
+const {
+	calculateModalPosition,
+	encodeToChar,
+	silenceChar,
+} = require("./encode.js");
+
+const {
+	getTonalBase,
+	getUnitLength,
+	parseAbc,
+	getMeter,
+} = require("../parse/parser.js");
+
+const { contourToSvg } = require("./contour-svg.js");
+
+// ============================================================================
+// Contour (compare object) generation
+// ============================================================================
+
+/**
+ * Generate contour (compare object) from ABC notation
+ * @returns { sortKey: string, durations: Array, version: string, part: string }
+ *
+ * todo: complete this header. options.withSvg; options.maxNbUnitLengths
+ */
+function getContour(
+	abc,
+	{
+		withSvg = false,
+		withSwingTransform = false,
+		maxNbBars = new Fraction(3, 2),
+		maxNbUnitLengths = 12,
+		svgConfig = {},
+	} = {}
+) {
+	const tonalBase = getTonalBase(abc);
+
+	const unitLength = getUnitLength(abc); //todo: could add as an argument; default null
+	if (typeof maxNbBars === "number") maxNbBars = new Fraction(maxNbBars);
+	let meter = getMeter(abc); //todo: could add as an argument; default null
+	if (!meter) meter = [4, 4]; //temp
+	const meterFraction = new Fraction(meter[0], meter[1]);
+	if (maxNbUnitLengths) {
+		const maxNbBarsFromMaxUnitLength = unitLength
+			.multiply(maxNbUnitLengths)
+			.divide(meterFraction);
+
+		maxNbBars = Fraction.min(maxNbBarsFromMaxUnitLength, maxNbBars);
+	}
+	const maxDuration = maxNbBars * meterFraction;
+
+	const {
+		bars,
+	} = //todo: could add as an argument; default null
+		parseAbc(abc, {
+			maxBars: Math.ceil(maxNbBars.toNumber()),
+		});
+
+	let cumulatedDuration = new Fraction(0, 1);
+	const sortKey = [];
+	const durations = [];
+	// const debugPositions = [];
+	let index = 0;
+	// get the parsed notes - notes are tokens with a duration
+	const notes = [];
+	let tied = false,
+		previousPosition = null;
+	for (let i = 0; i < bars.length; i++) {
+		const bar = bars[i];
+		for (let j = 0; j < bar.length; j++) {
+			const token = bar[j];
+			if (token.duration && token.duration.num > 0) {
+				cumulatedDuration = cumulatedDuration.add(token.duration);
+				if (cumulatedDuration.isGreaterThan(maxDuration)) break;
+				notes.push(token);
+			}
+		}
+	}
+
+	if (withSwingTransform) {
+		swingTransform(notes, unitLength, meter);
+	}
+
+	notes.forEach((note) => {
+		const { duration, isSilence } = note;
+		const comparison = duration.compare(unitLength);
+		const { encoded, encodedHeld, position } = isSilence
+			? { encoded: silenceChar, encodedHeld: silenceChar, position: 0 }
+			: getEncodedFromNote(note, tonalBase, tied, previousPosition);
+
+		if (note.tied) {
+			tied = true;
+			previousPosition = position;
+		} else {
+			tied = false;
+			previousPosition = null;
+		}
+
+		if (comparison > 0) {
+			// Held note: duration > unitLength
+			const { nbUnitLengths, remainingDuration } = divideDuration(
+				duration,
+				unitLength
+			);
+
+			// First note is played
+			sortKey.push(encoded);
+			//debugPositions.push(position);
+
+			// Subsequent notes are held
+			for (let i = 1; i < nbUnitLengths; i++) {
+				sortKey.push(encodedHeld);
+				//debugPositions.push(position);
+			}
+
+			index += nbUnitLengths;
+			if (remainingDuration.num !== 0) {
+				pushShortNote(
+					encodedHeld,
+					unitLength,
+					duration,
+					index,
+					durations,
+					sortKey
+				);
+				//debugPositions.push(position);
+				index++;
+			}
+		} else if (comparison < 0) {
+			pushShortNote(encoded, unitLength, duration, index, durations, sortKey);
+			//debugPositions.push(position);
+			index++;
+		} else {
+			// Normal note: duration === unitLength
+			sortKey.push(encoded);
+			//debugPositions.push(position);
+			index++;
+		}
+	});
+
+	const result = {
+		sortKey: sortKey.join(""),
+		//debugPositions: debugPositions.join(","),
+	};
+	if (durations.length > 0) {
+		result.durations = durations;
+	}
+	if (withSvg) {
+		result.svg = contourToSvg(result, svgConfig);
+	}
+	return result;
+}
+
+function divideDuration(duration, unitLength) {
+	const ratio = duration.divide(unitLength);
+	const nbUnitLengths = Math.floor(ratio.num / ratio.den);
+	const remainingDuration = duration.subtract(
+		unitLength.multiply(nbUnitLengths)
+	);
+	return { nbUnitLengths, remainingDuration };
+}
+
+function swingTransform(notes, unitLength, meter) {
+	// if (meter[0] % 2 !== 0) {
+	//check meter is an even multiple of the unit length
+	{
+		const nbUnitLengths = new Fraction(meter[0], meter[1]).divide(unitLength);
+		if (nbUnitLengths.den !== 1 || nbUnitLengths.num % 2 !== 0)
+			throw new Error("invalid meter for swing transform");
+	}
+	// modify notes to ensure all are of duration <= 2*unitLength
+	{
+		const twoUnits = unitLength.multiply(2);
+		let tooLong = notes
+				.map((n, i) => {
+					return { n, i };
+				})
+				.filter((n) => n.n.duration.compare(twoUnits) > 0),
+			safety = 0;
+
+		while (tooLong.length > 0) {
+			if (safety > 1000) throw new Error("swingTransform safety check failed");
+
+			const noteToSplit = tooLong[0].n;
+			const { nbUnitLengths, remainingDuration } = divideDuration(
+				noteToSplit.duration,
+				twoUnits
+			);
+			noteToSplit.duration = twoUnits;
+			if (!tooLong.isSilence) noteToSplit.tied = true;
+			const toAdd = [];
+			for (let i = 1; i < nbUnitLengths; i++) {
+				toAdd.push({ ...noteToSplit });
+			}
+			const lastNote = { ...noteToSplit };
+			lastNote.duration = remainingDuration;
+			toAdd.push(lastNote);
+			notes.splice(tooLong[0].i + 1, 0, ...toAdd);
+			/*
+    myArray.splice(index, 0, ...itemsToInsert): The splice method takes three arguments:
+        The first argument (index) is the starting index at which to modify the array.
+        The second argument (0) indicates that no elements should be removed from the array.
+        The third argument uses the spread operator (...itemsToInsert) to insert the elements of itemsToInsert into myArray at the specified index.
+ */
+			safety++;
+			tooLong = notes
+				.map((n, i) => {
+					return { n, i };
+				})
+				.filter((n) => n.n.duration.compare(twoUnits) > 0);
+		}
+	}
+
+	const dotted = unitLength.multiply(3).divide(2), // dotted quaver, if L:1/8;  long part of broken rhythm
+		semi = unitLength.divide(2), // semiquaver, if L:1/8;  short part of broken rhythm
+		triplet = unitLength.multiply(2).divide(3),
+		multiplier = new Fraction(3, 2);
+
+	let i = 0;
+	while (true) {
+		if (i >= notes.length) break;
+		const n1 = notes[i],
+			n2 = i + 1 < notes.length ? notes[i + 1] : null,
+			n3 = i + 2 < notes.length ? notes[i + 2] : null;
+
+		//basic: change AB to A2B
+		if (
+			n2 &&
+			n1.duration.equals(unitLength) &&
+			n2.duration.equals(unitLength)
+		) {
+			n1.duration = unitLength.multiply(2);
+			i += 2;
+			continue;
+		}
+		//broken
+		if (n2 && n1.duration.equals(dotted) && n2.duration.equals(semi)) {
+			n1.duration = unitLength.multiply(2);
+			n2.duration = unitLength;
+			i += 2;
+			continue;
+		}
+		//reverse broken
+		if (n2 && n2.duration.equals(dotted) && n1.duration.equals(semi)) {
+			n2.duration = unitLength.multiply(2);
+			n1.duration = unitLength;
+			i += 2;
+			continue;
+		}
+
+		//triplets
+		if (
+			n2 &&
+			n3 &&
+			n1.duration.equals(triplet) &&
+			n2.duration.equals(triplet) &&
+			n3.duration.equals(triplet)
+		) {
+			n1.duration = unitLength;
+			n2.duration = unitLength;
+			n3.duration = unitLength;
+			i += 3;
+			continue;
+		}
+		//two short + long, eg d/c/B
+		if (
+			n2 &&
+			n3 &&
+			n1.duration.equals(semi) &&
+			n2.duration.equals(semi) &&
+			n3.duration.equals(unitLength)
+		) {
+			n1.duration = unitLength.divide(2);
+			n2.duration = unitLength.divide(2);
+			n3.duration = unitLength.multiply(2);
+			i += 3;
+			continue;
+		}
+		// other
+		n1.duration = n1.duration.multiply(multiplier);
+		i++;
+	}
+}
+
+/**
+ * Adds a short note (duration < unitLength) to the contour
+ * @param {string} encoded - the encoded representation of the note’s modal degree information (MDI)
+ * @param {Fraction} unitLength - the unit length
+ * @param {Fraction} duration - the duration of the note
+ * @param {number} index - the index of the note
+ * @param {Array<object>} durations - the durations array
+ * @param {Array<string>} sortKey - array of MDIs
+ */
+function pushShortNote(
+	encoded,
+	unitLength,
+	duration,
+	index,
+	durations,
+	sortKey
+) {
+	const relativeDuration = duration.divide(unitLength),
+		d = {
+			i: index,
+			d: relativeDuration.den,
+		};
+	if (relativeDuration.num !== 1) {
+		d.n = relativeDuration.num;
+	}
+
+	durations.push(d);
+	sortKey.push(encoded);
+}
+
+function getEncodedFromNote(note, tonalBase, tied, previousPosition) {
+	// Handle pitched note
+	const { pitch, octave } = note;
+	const position = calculateModalPosition(tonalBase, pitch, octave);
+	const encodedHeld = encodeToChar(position, true);
+	const encoded = encodeToChar(position, false);
+
+	return {
+		encoded: tied && position === previousPosition ? encodedHeld : encoded,
+		encodedHeld,
+		position,
+	};
+}
+
+module.exports = {
+	getContour,
+};