@goplayerjuggler/abc-tools 1.0.4 → 1.0.6

package/.editorconfig

@@ -4,7 +4,7 @@ root = true
 
 # Unix-style newlines with a newline ending every file
 [*]
-end_of_line = lf
+end_of_line = crlf
 insert_final_newline = true
 
 # Matches multiple files with brace expansion notation
@@ -14,4 +14,13 @@ charset = utf-8
 
 # Indentation override for all JS
 [**.js]
-indent_style = tab
+indent_style = tab
+
+# Ignore paths
+[{tunes.json,**/*tunebook*}.js]
+charset = unset
+end_of_line = unset
+insert_final_newline = unset
+trim_trailing_whitespace = unset
+indent_style = unset
+indent_size = unset

package/eslint.config.js

@@ -1,44 +1,41 @@
-const js = require("@eslint/js");
-const globals = require("globals");
-const pluginJest = require('eslint-plugin-jest');
-
-module.exports = [
-  {
-    ...js.configs.recommended,
-    plugins: { jest: pluginJest },
-    languageOptions: {
-      ...js.configs.recommended.languageOptions,
-      globals: {
-        ...globals.node,...pluginJest.environments.globals.globals
-      },
-      ecmaVersion: 12,
-      sourceType: "module",
-    },
-    
-    ignores: [
-      "**/node_modules/",
-      "**/coverage/",
-      "**/dist/",
-    ],
-    rules: {
-      ...js.configs.recommended.rules,
-      // "arrow-spacing": "error"
-      "curly": ["error", "all"],
-      // "eol-last": ["error", "always"],
-      "eqeqeq": ["error", "always"],
-      "no-console": "off",
-      "no-eval": "error",
-      "no-implied-eval": "error",
-      // "no-trailing-spaces": "error",
-      "no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
-      "no-var": "error",
-      "no-with": "error",
-      "prefer-const": "error",
-      "prefer-template": "error",
-      // "comma-dangle": ["error", "never"],
-      // "indent": ["error", 2],
-      // "quotes": ["error", "single", { avoidEscape: true }],
-      // "semi": ["error", "always"],
-    }
-  }
-];
+const js = require("@eslint/js");
+const globals = require("globals");
+const pluginJest = require("eslint-plugin-jest");
+
+module.exports = [
+	{
+		...js.configs.recommended,
+		plugins: { jest: pluginJest },
+		languageOptions: {
+			...js.configs.recommended.languageOptions,
+			globals: {
+				...globals.node,
+				...pluginJest.environments.globals.globals,
+			},
+			ecmaVersion: 12,
+			sourceType: "module",
+		},
+
+		ignores: ["**/node_modules/", "**/coverage/", "**/dist/"],
+		rules: {
+			...js.configs.recommended.rules,
+			// "arrow-spacing": "error"
+			//curly: ["error", "all"],
+			// "eol-last": ["error", "always"],
+			eqeqeq: ["error", "always"],
+			"no-console": "off",
+			"no-eval": "error",
+			"no-implied-eval": "error",
+			// "no-trailing-spaces": "error",
+			"no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+			"no-var": "error",
+			"no-with": "error",
+			"prefer-const": "error",
+			// "prefer-template": "error",
+			// "comma-dangle": ["error", "never"],
+			// "indent": ["error", 2],
+			// "quotes": ["error", "single", { avoidEscape: true }],
+			// "semi": ["error", "always"],
+		},
+	},
+];

package/package.json

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

@@ -4,6 +4,72 @@ const { getFirstBars } = require("./manipulator.js");
 
 const { getUnitLength, getMeter } = require("./parse/parser.js");
 
+const { getContour } = require("./sort/contour-sort.js");
+
+//this file has code that's a fork of some code in  Michael Eskin's abctools
+
+//
+// Clean an incipit line
+//
+function cleanIncipitLine(theTextIncipit) {
+	//console.log("Starting incipit:");
+	//console.log(theTextIncipit);
+
+	// Strip any embedded voice [V:*]
+	let searchRegExp = /\[V:\s*\d+\]/gm;
+	theTextIncipit = theTextIncipit.replace(searchRegExp, "");
+	//console.log(theTextIncipit);
+
+	// Strip any embedded voice V: *
+	//searchRegExp = /V: [^ ]+ /gm
+	searchRegExp = /V:\s+\S+\s/gm;
+	theTextIncipit = theTextIncipit.replace(searchRegExp, "");
+	//console.log(theTextIncipit);
+
+	// Strip any embedded voice V:*
+	searchRegExp = /V:[^ ]+ /gm;
+	theTextIncipit = theTextIncipit.replace(searchRegExp, "");
+	//console.log(theTextIncipit);
+
+	// Sanitize !*! style annotations, but keep !fermata!
+	searchRegExp = /!(?!fermata!)[^!\n]*!/gm;
+	theTextIncipit = theTextIncipit.replace(searchRegExp, "");
+	//console.log(theTextIncipit);
+
+	// Strip out repeat marks
+	theTextIncipit = theTextIncipit.replaceAll("|:", "|");
+	theTextIncipit = theTextIncipit.replaceAll(":|", "|");
+
+	// strip out 1st 2nd etc time repeats
+	searchRegExp = /\[\d(,\d)*/gm;
+	theTextIncipit = theTextIncipit.replace(searchRegExp, "");
+
+	//console.log(theTextIncipit);
+
+	// Strip out brackets
+	//   theTextIncipit = theTextIncipit.replaceAll("[", "");
+	//console.log(theTextIncipit);
+
+	// Strip out brackets
+	//   theTextIncipit = theTextIncipit.replaceAll("]", "");
+	//console.log(theTextIncipit);
+
+	// Strip out continuations
+	theTextIncipit = theTextIncipit.replaceAll("\\", "");
+
+	// Segno
+	theTextIncipit = theTextIncipit.replaceAll("S", "");
+
+	// Strip out comments
+	theTextIncipit = theTextIncipit.replace(/"[^"]+"/gm, "");
+	// Strip out inline parts
+	theTextIncipit = theTextIncipit.replace(/\[P:[Ⅰ\w]\]/gm, "");
+
+	//
+	theTextIncipit = theTextIncipit.replace(/^\|[:|]?/, "");
+	return theTextIncipit;
+}
+
 function StripAnnotationsOneForIncipits(theNotes) {
 	// Strip out tempo markings
 	let searchRegExp = /^Q:.*[\r\n]*/gm;
@@ -153,29 +219,85 @@ function StripChordsOne(theNotes) {
 }
 
 function sanitise(theTune) {
+	let j,
+		k,
+		theTextIncipits = [];
 	// Strip out annotations
 	theTune = StripAnnotationsOneForIncipits(theTune);
 
-	// Strip out textnnotations
+	// Strip out atextnnotations
 	theTune = StripTextAnnotationsOne(theTune);
 
 	// Strip out chord markings
 	theTune = StripChordsOne(theTune);
 
-	return theTune;
+	// Parse out the first few measures
+	const theLines = theTune.split("\n"),
+		nLines = theLines.length;
+
+	// Find the key
+	let theKey = "";
+	let indexOfTheKey;
+
+	for (j = 0; j < nLines; ++j) {
+		theKey = theLines[j];
+
+		if (theKey.indexOf("K:") !== -1) {
+			indexOfTheKey = j;
+			break;
+		}
+	}
+	// Find the L: parameter
+	let theL = "";
+
+	for (j = 0; j < nLines; ++j) {
+		theL = theLines[j];
+
+		if (theL.indexOf("L:") !== -1) {
+			break;
+		}
+	}
+	// Find the M: parameter
+	let theM = "";
+
+	for (j = 0; j < nLines; ++j) {
+		theM = theLines[j];
+
+		if (theM.indexOf("M:") !== -1) {
+			break;
+		}
+	}
+	// Use at most the first three lines following the header K:
+	let added = 0;
+	for (k = indexOfTheKey + 1; k < nLines; ++k) {
+		const theTextIncipit = theLines[k];
+
+		// Clean out the incipit line of any annotations besides notes and bar lines
+		theTextIncipits.push(cleanIncipitLine(theTextIncipit));
+		added++;
+		if (added === 3) break;
+	}
+
+	return `X:1\n${theM}\n${theL}\n${theKey}\n${theTextIncipits.join("\n")}`;
 }
 
 /**
  * Get incipit (opening bars) of a tune for display/search purposes
- * @param {object} Object of the form {abc} with optional property: numBars
+ * @param {object|string} Object of the form {abc} with optional property: numBars, or a string in ABC format
  * @param {string} params.abc - ABC notation
- * @param {number|Fraction} params.numBars - Number of bars to return, counting the anacrucis if there is one. (default:2)
+ * @param {number|Fraction} params.numBars - Number of bars to return, counting the anacrucis if there is one.
+ * (default: 1.5 for some cases like M:4/4 L:1/16; 3 for M:3/4; otherwise 2)
  * @returns {string} - ABC incipit
  */
-function getIncipit({
-	abc,
-	numBars, //, part=null
-} = {}) {
+function getIncipit(data) {
+	let {
+		abc,
+		numBars, //, part=null
+	} = typeof data === "string" ? { abc: data } : data;
+
+	const { withAnacrucis = true } =
+		typeof data === "string" ? { abc: data } : data;
+
 	if (!numBars) {
 		numBars = 2;
 		const currentMeter = getMeter(abc);
@@ -195,7 +317,27 @@ function getIncipit({
 		}
 	}
 	abc = sanitise(abc);
-	return getFirstBars(abc, numBars, true, true, { all: true });
+	return getFirstBars(abc, numBars, withAnacrucis, false, { all: true });
+}
+
+function getIncipitForContourGeneration(abc) {
+	return getIncipit({
+		abc,
+		withAnacrucis: false,
+		numBars: 1,
+	});
+}
+
+function getContourFromFullAbc(abc) {
+	if (Array.isArray(abc)) {
+		if (abc.length === 0) return null;
+		abc = abc[0];
+	}
+	return getContour(getIncipitForContourGeneration(abc));
 }
 
-module.exports = { getIncipit };
+module.exports = {
+	getIncipit,
+	getIncipitForContourGeneration,
+	getContourFromFullAbc,
+};

package/src/index.js

@@ -5,8 +5,12 @@
 
 const parser = require("./parse/parser.js");
 const manipulator = require("./manipulator.js");
-const sort = require("./contour-sort.js");
+const sort = require("./sort/contour-sort.js");
+const contourToSvg = require("./sort/contour-svg.js");
+const displayContour = require("./sort/display-contour.js");
+
 const incipit = require("./incipit.js");
+const javascriptify = require("./javascriptify.js");
 
 module.exports = {
 	// Parser functions
@@ -17,7 +21,12 @@ module.exports = {
 
 	// Sort functions
 	...sort,
+	...displayContour,
+	...contourToSvg,
 
 	// Incipit functions
 	...incipit,
+
+	//
+	javascriptify,
 };

package/src/javascriptify.js

@@ -0,0 +1,84 @@
+/**
+ * Converts a JavaScript value to a string representation using JavaScript syntax.
+ * Uses template literals for multiline strings and avoids quotes on property names where possible.
+ * Object properties with values that are falsey or empty arrays are omitted.
+ *
+ * @param {*} value - The value to convert to JavaScript syntax
+ * @param {number} indent - Current indentation level (for internal use)
+ * @returns {string} JavaScript code representation of the value
+ */
+function javascriptify(value, indent = 0) {
+	const indentStr = "  ".repeat(indent);
+	const nextIndentStr = "  ".repeat(indent + 1);
+
+	// Handle null and undefined
+	if (value === null) {return "null";}
+	if (value === undefined) {return "undefined";}
+
+	// Handle primitives
+	if (typeof value === "number") {
+		return String(value);
+	}
+	if (typeof value === "boolean") {
+		return String(value);
+	}
+
+	// Handle strings
+	if (typeof value === "string") {
+		// Check if string contains newlines
+		if (value.includes("\n")) {
+			// Escape backslashes, backticks, and template literal interpolations
+			const escaped = value
+				.replace(/\\/g, "\\\\")
+				.replace(/`/g, "\\`")
+				.replace(/\$/g, "\\$");
+			return `\`${escaped}\``;
+		}
+		return JSON.stringify(value);
+	}
+
+	// Handle arrays
+	if (Array.isArray(value)) {
+		if (value.length === 0) {return "[]";}
+
+		const items = value
+			.map((item) => nextIndentStr + javascriptify(item, indent + 1))
+			.join(",\n");
+
+		return `[\n${items}\n${indentStr}]`;
+	}
+
+	// Handle objects
+	if (typeof value === "object") {
+		// Filter out falsey values and empty arrays
+		const keys = Object.keys(value).filter((k) => {
+			const val = value[k];
+			// Omit all falsey values (including false, but keep 0)
+			if (val === 0) {return true;}
+			//if (val === null || val === undefined || val === "") return false;
+			if (!val) {return false;}
+			// Omit empty arrays
+			if (Array.isArray(val) && val.length === 0) {return false;}
+			return true;
+		});
+
+		if (keys.length === 0) {return "{}";}
+
+		const properties = keys
+			.map((key) => {
+				const propValue = javascriptify(value[key], indent + 1);
+				// Check if key is a valid identifier (can be unquoted)
+				const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+				const keyStr = validIdentifier ? key : JSON.stringify(key);
+				return `${nextIndentStr}${keyStr}: ${propValue}`;
+			})
+			.join(",\n");
+
+		return `{\n${properties}\n${indentStr}}`;
+	}
+
+	// Fallback for functions and other types
+	return String(value);
+}
+
+module.exports = javascriptify;

package/src/manipulator.js

@@ -159,7 +159,7 @@ function insertCharsAtIndexes(originalString, charToInsert, indexes) {
 /**
  * Toggle meter by doubling or halving bar length
  * Supports 4/4↔4/2 and 6/8↔12/8 transformations
- * This is neary a true inverse operation - going there and back preserves the ABC except for some
+ * 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
  *

package/src/math.js

@@ -1,13 +1,18 @@
-// ============================================================================
-// FRACTION CLASS (to avoid floating point errors)
-// ============================================================================
-
 class Fraction {
 	constructor(numerator, denominator = 1) {
 		if (denominator === 0) {
 			throw new Error("Denominator cannot be zero");
 		}
 
+		if (
+			isNaN(numerator) ||
+			isNaN(denominator) ||
+			numerator === null ||
+			denominator === null
+		) {
+			throw new Error("invalid argument");
+		}
+
 		const g = gcd(Math.abs(numerator), Math.abs(denominator));
 		this.num = numerator / g;
 		this.den = denominator / g;
@@ -53,7 +58,10 @@ class Fraction {
 
 	compare(other) {
 		// Returns -1 if this < other, 0 if equal, 1 if this > other
-		const diff = this.num * other.den - other.num * this.den;
+		const diff =
+			typeof n === "number"
+				? this.num - other * this.den
+				: this.num * other.den - other.num * this.den;
 		return diff < 0 ? -1 : diff > 0 ? 1 : 0;
 	}
 
@@ -72,6 +80,9 @@ class Fraction {
 	toString() {
 		return this.den === 1 ? `${this.num}` : `${this.num}/${this.den}`;
 	}
+	toNumber() {
+		return this.num / this.den;
+	}
 }
 
 function gcd(a, b) {

package/src/parse/note-parser.js

@@ -459,5 +459,4 @@ module.exports = {
 	parseTuplet,
 	parseBrokenRhythm,
 	applyBrokenRhythm,
-	NOTE_TO_DEGREE,
 };

package/src/parse/parser.js

@@ -10,7 +10,6 @@ const {
 	parseTuplet,
 	parseBrokenRhythm,
 	applyBrokenRhythm,
-	NOTE_TO_DEGREE,
 } = require("./note-parser.js");
 const { classifyBarLine } = require("./barline-parser.js");
 const {
@@ -233,7 +232,7 @@ function parseABCWithBars(abc, options = {}) {
 	const newlineSet = new Set(newlinePositions);
 
 	// Comprehensive bar line regex - includes trailing spaces
-	const barLineRegex = /(\|\]|\[\||(\|:?)|(:?\|)|::|(\|[1-6])) */g;
+	const barLineRegex = /(\|\||\|\]|\[\|\]|(\|:?)|(:?\|)|:\|\|:) */g;
 
 	const bars = [];
 	const barLines = [];
@@ -516,7 +515,49 @@ function calculateBarDurations(parsedData) {
 	return result;
 }
 
+/**
+ * Extracts all ABC music notation tunes from a string.
+ *
+ * @param {string} text - The input string containing one or more ABC tunes
+ * @returns {string[]} An array of ABC tune strings, each containing a complete tune
+ * @throws {TypeError} If the input is not a string
+ *
+ * @example
+ * const abcText = `X: 1
+ * T: Example Tune
+ * M: 4/4
+ * K: C
+ * CDEF|
+ *
+ * X: 2
+ * T: Another Tune
+ * K: G
+ * GABc|`;
+ *
+ * const tunes = getTunes(abcText);
+ * // Returns: ['X: 1\nT: Example Tune\nM: 4/4\nK: C\nCDEF|', 'X: 2\nT: Another Tune\nK: G\nGABc|']
+ */
+function getTunes(text) {
+	if (typeof text !== "string") {
+		throw new TypeError("Input must be a string");
+	}
+	// Regex pattern to match ABC tunes:
+	// ^X:\s*\d+   - Matches lines starting with "X:" followed by optional whitespace and digits
+	// .*$         - Matches the rest of that line
+	// (?:\n(?!\n).*)* - Matches subsequent lines that are NOT empty lines (non-capturing group)
+	//                   \n(?!\n) ensures we have a newline NOT followed by another newline
+	//                   .* matches the content of that non-empty line
+	//                   * repeats for all consecutive non-empty lines
+	// Flags: g (global), m (multiline)
+	const getAbc = /^X:\s*\d+.*$(?:\n(?!\n).*)*$/gm;
+	// Extract all matches and return as an array of strings
+	const matches = [...text.matchAll(getAbc)];
+
+	return matches.map((match) => match[0]);
+}
+
 module.exports = {
+	getTunes,
 	parseABCWithBars,
 	calculateBarDurations,
 	// Re-export utilities for convenience
@@ -526,5 +567,4 @@ module.exports = {
 	getMusicLines,
 	analyzeSpacing,
 	classifyBarLine,
-	NOTE_TO_DEGREE,
 };

package/src/parse/token-utils.js

@@ -9,14 +9,83 @@
 //
 // ============================================================================
 
+const TokenRegexComponents = {
+	// Tuplet notation: (3, (3:2, (3:2:4
+	tuplet: String.raw`\(\d(?::\d?){0,2}`,
+
+	// Inline field changes: [K:D], [L:1/4], [M:3/4], [P:A]
+	inlineField: String.raw`\[(?:[KLMP]):[^\]]+\]`,
+
+	// Text in quotes: chord symbols "Dm7" or annotations "^text"
+	quotedText: String.raw`"[^"]+"`,
+
+	// Bang decoration: !trill!, !fermata!, etc.
+	bangDecoration: String.raw`![^!]+!`,
+
+	// Symbol decorations before note: ~, ., M, P, S, T, H, U, V
+	// 0..N of them, with optional following white space
+	symbolDecoration: String.raw`[~.MPSTHUV]`,
+
+	symbolDecorations() {
+		return String.raw`(?:${this.symbolDecoration}\s*)*`;
+	},
+	bangDecorations() {
+		return String.raw`(?:${this.bangDecoration}\s*)*`;
+	},
+
+	// Accidental: :, ^, _ (natural, sharp, flat)
+	accidental: String.raw`[:^_]?`,
+
+	// Note pitch: A-G (lower octave), a-g (middle octave), z/x (rest), y (dummy)
+	// Or chord in brackets: [CEG], [DF#A]
+	pitch: String.raw`(?:[A-Ga-gzxy]|\[[A-Ga-g]+\])`,
+
+	// Octave modifiers: ' (up), , (down)
+	octave: String.raw`[',]*`,
+
+	// Duration: 2, /2, 3/4, /, //, etc.
+	// include all digits, even though things like A0, A5,... are not allowed
+	// but we could have A16, or z10 (full bar rest for M:5/4; L:1/8)
+	duration: String.raw`[0-9]*\/?[0-9]*`,
+
+	// Tie (-) or broken rhythm (>, >>, >>>, <, <<, <<<)
+	// Optional: may have neither, or may have whitespace before broken rhythm
+	tieOrBroken: String.raw`(?:-|\s*(?:<{1,3}|>{1,3}))?`,
+};
+
 /**
  * Get regex for matching ABC music tokens
- * Matches: tuplets, inline fields, chord symbols, notes, rests, chords in brackets, decorations, broken rhythms
+ * Built from documented components for maintainability
+ *
+ * Matches: tuplets, inline fields, chord symbols, notes, rests, chords in brackets,
+ * decorations, ties, and broken rhythms
  *
  * @returns {RegExp} - Regular expression for tokenising ABC music
  */
-const getTokenRegex = () =>
-	/\(\d(?::\d?){0,2}|\[([KLMP]):[^\]]+\]|"[^"]+"|(?:!([^!]+)!\s*)?[~.MPSTHUV]*[=^_]?(?:[A-Ga-gzxy]|\[[A-Ga-gzxy]+\])[',]*[0-9]*\/?[0-9]*(?:-|\s*(?:<{1,3}|>{1,3}))?|!([^!]+)!/g;
+const getTokenRegex = () => {
+	const s = TokenRegexComponents;
+	// Complete note/rest/chord pattern with optional leading decoration
+	const notePattern =
+		s.bangDecorations() +
+		s.symbolDecorations() +
+		s.accidental +
+		s.pitch +
+		s.octave +
+		s.duration +
+		s.tieOrBroken;
+
+	// Combine all patterns with alternation
+	const fullPattern = [
+		s.tuplet,
+		s.inlineField,
+		s.quotedText,
+		//allow standalone bang and symbol decorations (?)
+		notePattern,
+		s.bangDecoration,
+	].join("|");
+
+	return new RegExp(fullPattern, "g");
+};
 
 /**
  * Parse inline field from music section