abcjs 6.5.2 → 6.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abcjs",
-  "version": "6.5.2",
+  "version": "6.6.0",
   "description": "Renderer for abc music notation",
   "main": "index.js",
   "types": "types/index.d.ts",

package/src/api/abc_timing_callbacks.js

@@ -12,6 +12,7 @@ var TimingCallbacks = function(target, params) {
 	self.lineEndCallback = params.lineEndCallback;   // This is called when the end of a line is approaching.
 	self.lineEndAnticipation = params.lineEndAnticipation ? parseInt(params.lineEndAnticipation, 10) : 0;   // How many milliseconds before the end should the call happen.
 	self.beatSubdivisions = params.beatSubdivisions ? parseInt(params.beatSubdivisions, 10) : 1; // how many callbacks per beat is desired.
+	if (!self.beatSubdivisions) self.beatSubdivisions = 1
 	self.joggerTimer = null;
 
 	self.replaceTarget = function(newTarget) {
@@ -38,7 +39,73 @@ var TimingCallbacks = function(target, params) {
 		// noteTimings contains an array of events sorted by time. Events that happen at the same time are in the same element of the array.
 		self.millisecondsPerBeat = 1000 / (self.qpm / 60) / self.beatSubdivisions;
 		self.lastMoment = self.noteTimings[self.noteTimings.length-1].milliseconds;
-		self.totalBeats = Math.round(self.lastMoment / self.millisecondsPerBeat);
+
+		// For irregular time sigs that specify the beat divisions (that is, something like `M: 2+3/8`)
+		// Then the beat is not a regular pulse. To keep most of this logic easy, the beat will be specified
+		// as half as long, but the callback will happen according to the pattern. That is,
+		// for bpm=60 at the above time signature, internally the beat callback will happen at 120 bpm, but
+		// the callback function will be called at 2 sub beats, then 3 sub beats, etc.
+		// The beat number will be an integer for all of them and count up by one each time.
+		var meter = newTarget.getMeter()
+		var irregularMeter = ''
+		if (meter && meter.type === "specified" && meter.value && meter.value.length > 0 && meter.value[0].num.indexOf('+') > 0)
+			irregularMeter = meter.value[0].num
+		// for subdivisions = 1, then this should contain only whole numbers and the callbacks are irregular
+		// for subdivisions = 2, then this should be 1/8 notes. The beats should be something like: 0, 0.5, 1, 1.33, 1.66 2 (For M:2+3/8)
+		// etc for more subdivisions - they are just multiplied
+		self.beatStarts = []
+		if (irregularMeter) {
+			var measureLength = self.noteTimings[self.noteTimings.length-1].millisecondsPerMeasure
+			var numMeasures = self.lastMoment / measureLength
+			var parts = irregularMeter.split("+")
+			for (var i = 0; i < parts.length; i++)
+				parts[i] = parseInt(parts[i],10) / 2 // since we count a beat as a quarter note, but these numbers refer to 1/8 notes, we convert the beat length
+			var currentTs = 0
+			var beatNumber = 0
+			// For the input: parts = [ 1, 1.5 ] and beatSubdivisions = 2
+			// beatNumbers = 0 0.5 1 1.33 1.67 2 2.5 3 3.33 3.67 ...
+			// when part=1 then there is 1 extra sub beat and it is 0.5
+			// when part=1.5 then there are 2 extra sub beats at 0.33 and 0.67
+			//
+			// beatSubdivision | numFor1 | numFor1.5
+			//        2        |    2    |     3
+			//        3        |    3    |     4.5
+			//        4        |    4    |     6
+			for (var measureNumber = 0; measureNumber < numMeasures; measureNumber++) {
+				var measureStartTs = measureNumber * measureLength
+				var subBeatCounter = 0
+				for (var kk = 0; kk < parts.length; kk++) {
+					var beatLength = parts[kk] // This is either 1 or 1.5 (how many quarter notes in this beat)
+					if (self.beatSubdivisions === 1) {
+						if (self.beatSubdivisions === 1)
+							if (currentTs < self.lastMoment) {
+								self.beatStarts.push({b: beatNumber, ts: currentTs})
+							}
+							currentTs += beatLength * self.millisecondsPerBeat
+					} else {
+						var numDivisions = beatLength * self.beatSubdivisions
+						for (var k = 0; k < Math.floor(numDivisions); k++) {
+							var subBeat = k / numDivisions
+							var ts = Math.round(measureStartTs + subBeatCounter * self.millisecondsPerBeat)
+							if (ts < self.lastMoment) {
+								self.beatStarts.push({b: beatNumber + subBeat, ts: ts})
+							}
+							subBeatCounter++
+						}
+					}
+					beatNumber++
+				}
+			}
+			self.beatStarts.push({b: numMeasures * parts.length, ts: self.lastMoment})
+			self.totalBeats = self.beatStarts.length
+		} else {
+			self.totalBeats = Math.round(self.lastMoment / self.millisecondsPerBeat);
+			// Add one so the last beat is the last moment
+			for (var j = 0; j < self.totalBeats+1; j++) {
+				self.beatStarts.push({b: j/self.beatSubdivisions, ts: Math.round(j * self.millisecondsPerBeat)})
+			}
+		}
+		//console.log({lastMoment: self.lastMoment, beatStarts: self.beatStarts})
 	};
 
 	self.replaceTarget(target);
@@ -49,11 +116,11 @@ var TimingCallbacks = function(target, params) {
 		if (self.lastTimestamp === timestamp)
 			return; // If there are multiple seeks or other calls, then we can easily get multiple callbacks for the same instant.
 		self.lastTimestamp = timestamp;
-		if (!self.startTime) {
-			self.startTime = timestamp;
-		}
 
 		if (!self.isPaused && self.isRunning) {
+			if (!self.startTime) {
+				self.startTime = timestamp;
+			}
 			self.currentTime = timestamp - self.startTime;
 			self.currentTime += 16; // Add a little slop because this function isn't called exactly.
 			while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < self.currentTime) {
@@ -73,8 +140,9 @@ var TimingCallbacks = function(target, params) {
 			}
 			if (self.currentTime < self.lastMoment) {
 				requestAnimationFrame(self.doTiming);
-				if (self.currentBeat * self.millisecondsPerBeat < self.currentTime) {
+				if (self.currentBeat < self.beatStarts.length && self.beatStarts[self.currentBeat].ts <= self.currentTime) {
 					var ret = self.doBeatCallback(timestamp);
+					self.currentBeat++
 					if (ret !== null)
 						self.currentTime = ret;
 				}
@@ -82,6 +150,7 @@ var TimingCallbacks = function(target, params) {
 				// Because of timing issues (for instance, if the browser tab isn't active), the beat callbacks might not have happened when they are supposed to. To keep the client programs from having to deal with that, this will keep calling the loop until all of them have been sent.
 				if (self.beatCallback) {
 					var ret2 = self.doBeatCallback(timestamp);
+					self.currentBeat++
 					if (ret2 !== null)
 						self.currentTime = ret2;
 					requestAnimationFrame(self.doTiming);
@@ -178,15 +247,15 @@ var TimingCallbacks = function(target, params) {
 
 			var thisStartTime = self.startTime; // the beat callback can call seek and change the position from beneath us.
 			self.beatCallback(
-				self.currentBeat / self.beatSubdivisions,
+				self.beatStarts[self.currentBeat].b,
 				self.totalBeats / self.beatSubdivisions,
 				self.lastMoment,
 				position,
 				debugInfo);
 			if (thisStartTime !== self.startTime) {
 				return timestamp - self.startTime;
-			} else
-				self.currentBeat++;
+			} // else
+			// 	self.currentBeat++;
 		}
 		return null;
 	};
@@ -285,7 +354,6 @@ var TimingCallbacks = function(target, params) {
 		var now = performance.now();
 		self.startTime = now - self.currentTime;
 
-		var oldEvent = self.currentEvent;
 		self.currentEvent = 0;
 		while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < self.currentTime) {
 			self.currentEvent++;
@@ -298,10 +366,18 @@ var TimingCallbacks = function(target, params) {
 			}
 		}
 
+		//console.log({jump:self.currentTime})
 		var oldBeat = self.currentBeat;
-		self.currentBeat = Math.floor(self.currentTime / self.millisecondsPerBeat);
-		if (self.beatCallback && oldBeat !== self.currentBeat) // If the movement caused the beat to change, then immediately report it to the client.
-			self.doBeatCallback(self.startTime+self.currentTime);
+		for (self.currentBeat = 0; self.currentBeat < self.beatStarts.length; self.currentBeat++) {
+			if (self.beatStarts[self.currentBeat].ts > self.currentTime)
+				break
+		}
+		self.currentBeat--
+		if (self.beatCallback && oldBeat !== self.currentBeat) {
+			// If the movement caused the beat to change, then immediately report it to the client.
+			self.doBeatCallback(self.startTime + self.currentTime);
+			self.currentBeat++
+		}
 
 		if (self.eventCallback && self.currentEvent >= 0 && self.noteTimings[self.currentEvent].type === 'event')
 			self.eventCallback(self.noteTimings[self.currentEvent]);
@@ -328,4 +404,3 @@ function getLineEndTimings(timings, anticipation) {
 }
 
 module.exports = TimingCallbacks;
-

package/src/const/relative-major.js

@@ -1,21 +1,26 @@
 // All these keys have the same number of accidentals
 var keys = {
-	'C': { modes: ['CMaj', 'Amin', 'Am', 'GMix', 'DDor', 'EPhr', 'FLyd', 'BLoc'], stepsFromC: 0 },
-	'Db': { modes: ['DbMaj', 'Bbmin', 'Bbm', 'AbMix', 'EbDor', 'FPhr', 'GbLyd', 'CLoc'], stepsFromC: 1 },
-	'D': { modes: ['DMaj', 'Bmin', 'Bm', 'AMix', 'EDor', 'F#Phr', 'GLyd', 'C#Loc'], stepsFromC: 2 },
-	'Eb': { modes: ['EbMaj', 'Cmin', 'Cm', 'BbMix', 'FDor', 'GPhr', 'AbLyd', 'DLoc'], stepsFromC: 3 },
-	'E': { modes: ['EMaj', 'C#min', 'C#m', 'BMix', 'F#Dor', 'G#Phr', 'ALyd', 'D#Loc'], stepsFromC: 4 },
-	'F': { modes: ['FMaj', 'Dmin', 'Dm', 'CMix', 'GDor', 'APhr', 'BbLyd', 'ELoc'], stepsFromC: 5 },
-	'Gb': { modes: ['GbMaj', 'Ebmin', 'Ebm', 'DbMix', 'AbDor', 'BbPhr', 'CbLyd', 'FLoc'], stepsFromC: 6 },
-	'G': { modes: ['GMaj', 'Emin', 'Em', 'DMix', 'ADor', 'BPhr', 'CLyd', 'F#Loc'], stepsFromC: 7 },
-	'Ab': { modes: ['AbMaj', 'Fmin', 'Fm', 'EbMix', 'BbDor', 'CPhr', 'DbLyd', 'GLoc'], stepsFromC: 8 },
-	'A': { modes: ['AMaj', 'F#min', 'F#m', 'EMix', 'BDor', 'C#Phr', 'DLyd', 'G#Loc'], stepsFromC: 9 },
-	'Bb': { modes: ['BbMaj', 'Gmin', 'Gm', 'FMix', 'CDor', 'DPhr', 'EbLyd', 'ALoc'], stepsFromC: 10 },
-	'B': { modes: ['BMaj', 'G#min', 'G#m', 'F#Mix', 'C#Dor', 'D#Phr', 'ELyd', 'A#Loc'], stepsFromC: 11 },
+	'C': { modes: ['CMaj', 'CIon', 'Amin', 'AAeo', 'Am', 'GMix', 'DDor', 'EPhr', 'FLyd', 'BLoc'], stepsFromC: 0 },
+	'Db': { modes: ['DbMaj', 'DbIon', 'Bbmin', 'BbAeo', 'Bbm', 'AbMix', 'EbDor', 'FPhr', 'GbLyd', 'CLoc'], stepsFromC: 1 },
+	'D': { modes: ['DMaj', 'DIon', 'Bmin', 'BAeo', 'Bm', 'AMix', 'EDor', 'F#Phr', 'GLyd', 'C#Loc'], stepsFromC: 2 },
+	'Eb': { modes: ['EbMaj', 'EbIon', 'Cmin', 'CAeo', 'Cm', 'BbMix', 'FDor', 'GPhr', 'AbLyd', 'DLoc'], stepsFromC: 3 },
+	'E': { modes: ['EMaj', 'EIon', 'C#min', 'C#Aeo', 'C#m', 'BMix', 'F#Dor', 'G#Phr', 'ALyd', 'D#Loc'], stepsFromC: 4 },
+	'F': { modes: ['FMaj', 'FIon', 'Dmin', 'DAeo', 'Dm', 'CMix', 'GDor', 'APhr', 'BbLyd', 'ELoc'], stepsFromC: 5 },
+	'Gb': { modes: ['GbMaj', 'GbIon', 'Ebmin', 'EbAeo', 'Ebm', 'DbMix', 'AbDor', 'BbPhr', 'CbLyd', 'FLoc'], stepsFromC: 6 },
+	'G': { modes: ['GMaj', 'GIon', 'Emin', 'EAeo', 'Em', 'DMix', 'ADor', 'BPhr', 'CLyd', 'F#Loc'], stepsFromC: 7 },
+	'Ab': { modes: ['AbMaj', 'AbIon', 'Fmin', 'FAeo', 'Fm', 'EbMix', 'BbDor', 'CPhr', 'DbLyd', 'GLoc'], stepsFromC: 8 },
+	'A': { modes: ['AMaj', 'AIon', 'F#min', 'F#Aeo', 'F#m', 'EMix', 'BDor', 'C#Phr', 'DLyd', 'G#Loc'], stepsFromC: 9 },
+	'Bb': { modes: ['BbMaj', 'BbIon', 'Gmin', 'GAeo', 'Gm', 'FMix', 'CDor', 'DPhr', 'EbLyd', 'ALoc'], stepsFromC: 10 },
+	'B': { modes: ['BMaj', 'BIon', 'G#min', 'G#Aeo', 'G#m', 'F#Mix', 'C#Dor', 'D#Phr', 'ELyd', 'A#Loc'], stepsFromC: 11 },
 	// Enharmonic keys
-	'C#': { modes: ['C#Maj', 'A#min', 'A#m', 'G#Mix', 'D#Dor', 'E#Phr', 'F#Lyd', 'B#Loc'], stepsFromC: 1 },
-	'F#': { modes: ['F#Maj', 'D#min', 'D#m', 'C#Mix', 'G#Dor', 'A#Phr', 'BLyd', 'E#Loc'], stepsFromC: 6 },
-	'Cb': { modes: ['CbMaj', 'Abmin', 'Abm', 'GbMix', 'DbDor', 'EbPhr', 'FbLyd', 'BbLoc'], stepsFromC: 11 },
+	'C#': { modes: ['C#Maj', 'C#Ion', 'A#min', 'A#Aeo', 'A#m', 'G#Mix', 'D#Dor', 'E#Phr', 'F#Lyd', 'B#Loc'], stepsFromC: 1 },
+	'F#': { modes: ['F#Maj', 'F#Ion', 'D#min', 'D#Aeo', 'D#m', 'C#Mix', 'G#Dor', 'A#Phr', 'BLyd', 'E#Loc'], stepsFromC: 6 },
+	'Cb': { modes: ['CbMaj', 'CbIon', 'Abmin', 'AbAeo', 'Abm', 'GbMix', 'DbDor', 'EbPhr', 'FbLyd', 'BbLoc'], stepsFromC: 11 },
+}
+
+var modeNames = ['maj', 'ion', 'min', 'aeo', 'm', 'mix', 'dor', 'phr', 'lyd', 'loc']
+function isLegalMode(mode) {
+	return modeNames.indexOf(mode.toLowerCase()) >= 0
 }
 
 var keyReverse = null
@@ -42,7 +47,7 @@ function relativeMajor(key) {
 		createKeyReverse()
 	}
 	// get the key portion itself - there might be other stuff, like extra sharps and flats, or the mode written out.
-	var mode = key.toLowerCase().match(/([a-g][b#]?)(maj|min|mix|dor|phr|lyd|loc|m)?/)
+	var mode = key.toLowerCase().match(/([a-g][b#]?)(maj|ion|min|aeo|mix|dor|phr|lyd|loc|m)?/);
 	if (!mode || !mode[2])
 		return key;
 	mode = mode[1] + mode[2]
@@ -60,10 +65,10 @@ function relativeMode(majorKey, mode) {
 		return majorKey;
 	if (mode === '')
 		return majorKey;
-	var match = mode.toLowerCase().match(/^(maj|min|mix|dor|phr|lyd|loc|m)/)	
+	var match = mode.toLowerCase().match(/^(maj|ion|min|aeo|mix|dor|phr|lyd|loc|m)/);
 	if (!match)
 		return majorKey
-	var regMode = match[1]	
+	var regMode = match[1]
 	for (var i = 0; i < group.modes.length; i++) {
 		var thisMode = group.modes[i]
 		var ind = thisMode.toLowerCase().indexOf(regMode)
@@ -89,4 +94,4 @@ function transposeKey(key, steps) {
 	return key;
 }
 
-module.exports = {relativeMajor: relativeMajor, relativeMode: relativeMode, transposeKey: transposeKey};
+module.exports = {relativeMajor: relativeMajor, relativeMode: relativeMode, transposeKey: transposeKey, isLegalMode:isLegalMode};

package/src/data/abc_tune.js

@@ -90,12 +90,17 @@ var Tune = function() {
 	this.getBeatLength = function() {
 		// This returns a fraction: for instance 1/4 for a quarter
 		// There are two types of meters: compound and regular. Compound meter has 3 beats counted as one.
+
+		// Irregular meters have the beat as an 1/8 note but the tempo as a 1/4.
+		// That keeps it a similar tempo to 4/4 but that may or may not be generally intuitive, so that might need to change.
 		var meter = this.getMeterFraction();
 		var multiplier = 1;
 		if (meter.num === 6 || meter.num === 9 || meter.num === 12)
 			multiplier = 3;
 		else if (meter.num === 3 && meter.den === 8)
 			multiplier = 3;
+		else if (meter.den === 8 && (meter.num === 5 || meter.num === 7))
+			multiplier = 2
 
 		return multiplier / meter.den;
 	};
@@ -194,7 +199,13 @@ var Tune = function() {
 		var den = 4;
 		if (meter) {
 			if (meter.type === 'specified') {
-				num = parseInt(meter.value[0].num, 10);
+				if (meter.value && meter.value.length > 0 && meter.value[0].num.indexOf('+') > 0) {
+					var parts = meter.value[0].num.split('+')
+					num = 0;
+					for (var i = 0; i < parts.length; i++)
+						num += parseInt(parts[i],10)
+				} else
+					num = parseInt(meter.value[0].num, 10);
 				den = parseInt(meter.value[0].den,10);
 			} else if (meter.type === 'cut_time') {
 				num = 2;

package/src/data/deline-tune.js

@@ -11,7 +11,7 @@ function delineTune(inputLines, options) {
 	var currentTripletFont = [];
 	var currentAnnotationFont = [];
 	for (var i = 0; i < inputLines.length; i++) {
-		var inputLine = inputLines[i];
+		var inputLine = cloneLine(inputLines[i]);
 		if (inputLine.staff) {
 			if (inMusicLine && !inputLine.vskip) {
 				var outputLine = outputLines[outputLines.length-1];

package/src/midi/abc_midi_create.js

@@ -23,8 +23,8 @@ var create;
 
 		var beatsPerSecond = tempo / 60;
 
-		// Fix tempo for */8 meters
-		if (time.den == 8){
+		// Fix tempo for compound meters
+		if (time.den === 8 && time.num !== 5 && time.num !== 7){
 
 			// Compute the tempo based on the actual milliseconds per measure, scaled by the number of eight notes and halved to get tempo in bpm.
 			var msPerMeasure = abcTune.millisecondsPerMeasure();

package/src/parse/abc_parse.js

@@ -6,6 +6,7 @@ var ParseHeader = require('./abc_parse_header');
 var ParseMusic = require('./abc_parse_music');
 var Tokenizer = require('./abc_tokenizer');
 var wrap = require('./wrap_lines');
+var chordGrid = require('./chord-grid');
 
 var Tune = require('../data/abc_tune');
 var TuneBuilder = require('../parse/tune-builder');
@@ -53,6 +54,8 @@ var Parse = function() {
 			t.lineBreaks = tune.lineBreaks;
 		if (tune.visualTranspose)
 			t.visualTranspose = tune.visualTranspose;
+		if (tune.chordGrid)
+			t.chordGrid = tune.chordGrid
 		return t;
 	};
 
@@ -593,6 +596,23 @@ var Parse = function() {
 		}
 
 		wrap.wrapLines(tune, multilineVars.lineBreaks, multilineVars.barNumbers);
+		if (switches.chordGrid) {
+			try {
+				tune.chordGrid = chordGrid(tune)
+			} catch(err) {
+				switch (err.message) {
+					case "notCommonTime":
+						warn("Chord grid only works for 2/2 and 4/4 time.", 0,0)
+						break;
+					case "noChords":
+						warn("No chords are found in the tune.", 0,0)
+						break;
+					default:
+						warn(err.message, 0,0)
+				}
+
+			}
+		}
 	};
 };