@huffduff/midi-writer-ts 3.2.0 → 3.2.2

package/src/constants.ts

@@ -0,0 +1,18 @@
+/**
+ * MIDI file format constants.
+ * @return {Constants}
+ */
+
+const Constants = {
+	VERSION					: '3.1.1',
+	HEADER_CHUNK_TYPE  		: [0x4d, 0x54, 0x68, 0x64], // Mthd
+	HEADER_CHUNK_LENGTH  	: [0x00, 0x00, 0x00, 0x06], // Header size for SMF
+	HEADER_CHUNK_FORMAT0    : [0x00, 0x00], // Midi Type 0 id
+	HEADER_CHUNK_FORMAT1    : [0x00, 0x01], // Midi Type 1 id
+	HEADER_CHUNK_DIVISION   : [0x00, 0x80], // Defaults to 128 ticks per beat
+	TRACK_CHUNK_TYPE		: [0x4d, 0x54, 0x72, 0x6b], // MTrk,
+	META_EVENT_ID			: 0xFF,
+	META_SMTPE_OFFSET		: 0x54
+};
+
+export {Constants};

package/src/main.ts

@@ -0,0 +1,48 @@
+
+import { Constants } from './constants';
+import { ControllerChangeEvent } from './midi-events/controller-change-event';
+import { CopyrightEvent } from './meta-events/copyright-event';
+import { CuePointEvent } from './meta-events/cue-point-event';
+import { EndTrackEvent } from './meta-events/end-track-event';
+import { InstrumentNameEvent } from './meta-events/instrument-name-event';
+import { KeySignatureEvent } from './meta-events/key-signature-event';
+import { LyricEvent } from './meta-events/lyric-event';
+import { MarkerEvent } from './meta-events/marker-event';
+import { NoteOnEvent } from './midi-events/note-on-event';
+import { NoteOffEvent } from './midi-events/note-off-event';
+import { NoteEvent } from './midi-events/note-event';
+import { PitchBendEvent } from './midi-events/pitch-bend-event';
+import { ProgramChangeEvent } from './midi-events/program-change-event';
+import { TempoEvent } from './meta-events/tempo-event';
+import { TextEvent } from './meta-events/text-event';
+import { TimeSignatureEvent } from './meta-events/time-signature-event';
+import { Track } from './chunks/track';
+import { TrackNameEvent } from './meta-events/track-name-event';
+import { Utils } from './utils';
+import { VexFlow } from './vexflow';
+import { Writer } from './writer';
+
+export {
+	Constants,
+	ControllerChangeEvent,
+	CopyrightEvent,
+	CuePointEvent,
+	EndTrackEvent,
+	InstrumentNameEvent,
+	KeySignatureEvent,
+	LyricEvent,
+	MarkerEvent,
+	NoteOnEvent,
+	NoteOffEvent,
+	NoteEvent,
+	PitchBendEvent,
+	ProgramChangeEvent,
+	TempoEvent,
+	TextEvent,
+	TimeSignatureEvent,
+	Track,
+	TrackNameEvent,
+	Utils,
+	VexFlow,
+	Writer
+};

package/src/meta-events/copyright-event.ts

@@ -0,0 +1,35 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {CopyrightEvent}
+ */
+class CopyrightEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	text: string;
+	type: 0x02;
+
+	constructor(fields: { text: string; delta?: number; }) {
+		this.delta = fields.delta || 0x00;
+		this.name = 'CopyrightEvent';
+		this.text = fields.text;
+		this.type = 0x02;
+
+		const textBytes = Utils.stringToBytes(this.text);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			Utils.numberToVariableLength(textBytes.length), // Size
+			textBytes, // Text
+		);
+	}
+}
+
+export {CopyrightEvent};

package/src/meta-events/cue-point-event.ts

@@ -0,0 +1,35 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a cue point meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {CuePointEvent}
+ */
+class CuePointEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	text: string;
+	type: 0x07;
+
+	constructor(fields: { text: string; delta?: number; }) {
+		this.delta = fields.delta || 0x00;
+		this.name = 'CuePointEvent';
+		this.text = fields.text;
+		this.type = 0x07;
+
+		const textBytes = Utils.stringToBytes(this.text);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			Utils.numberToVariableLength(textBytes.length), // Size
+			textBytes, // Text
+		);
+	}
+}
+
+export {CuePointEvent};

package/src/meta-events/end-track-event.ts

@@ -0,0 +1,29 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a end track meta event.
+ * @param {object} fields {delta: integer}
+ * @return {EndTrackEvent}
+ */
+class EndTrackEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	type: [0x2F, 0x00];
+
+	constructor(fields?: { delta: number; }) {
+		this.delta = fields?.delta || 0x00;
+		this.name = 'EndTrackEvent';
+		this.type = [0x2F, 0x00];
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type
+		);
+	}
+}
+
+export {EndTrackEvent};

package/src/meta-events/instrument-name-event.ts

@@ -0,0 +1,35 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of an instrument name meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {InstrumentNameEvent}
+ */
+class InstrumentNameEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	text: string;
+	type: 0x04;
+
+	constructor(fields: { text: string; delta?: number; }) {
+		this.delta = fields.delta || 0x00;
+		this.name = 'InstrumentNameEvent';
+		this.text = fields.text;
+		this.type = 0x04;
+
+		const textBytes = Utils.stringToBytes(this.text);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			Utils.numberToVariableLength(textBytes.length), // Size
+			textBytes, // Instrument name
+		);
+	}
+}
+
+export {InstrumentNameEvent};

package/src/meta-events/key-signature-event.ts

@@ -0,0 +1,73 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a key signature meta event.
+ * @return {KeySignatureEvent}
+ */
+class KeySignatureEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	type: 0x59;
+
+	constructor(sf, mi) {
+		this.name = 'KeySignatureEvent';
+		this.type = 0x59;
+
+		let mode = mi || 0;
+		sf = sf || 0;
+
+		//	Function called with string notation
+		if (typeof mi === 'undefined') {
+			const fifths = [
+				['Cb', 'Gb', 'Db', 'Ab', 'Eb', 'Bb', 'F', 'C', 'G', 'D', 'A', 'E', 'B', 'F#', 'C#'],
+				['ab', 'eb', 'bb', 'f', 'c', 'g', 'd', 'a', 'e', 'b', 'f#', 'c#', 'g#', 'd#', 'a#']
+			];
+			const _sflen = sf.length;
+			let note = sf || 'C';
+
+			if (sf[0] === sf[0].toLowerCase()) mode = 1
+
+			if (_sflen > 1) {
+				switch (sf.charAt(_sflen - 1)) {
+					case 'm':
+						mode = 1;
+						note = sf.charAt(0).toLowerCase();
+						note = note.concat(sf.substring(1, _sflen - 1));
+						break;
+					case '-':
+						mode = 1;
+						note = sf.charAt(0).toLowerCase();
+						note = note.concat(sf.substring(1, _sflen - 1));
+						break;
+					case 'M':
+						mode = 0;
+						note = sf.charAt(0).toUpperCase();
+						note = note.concat(sf.substring(1, _sflen - 1));
+						break;
+					case '+':
+						mode = 0;
+						note = sf.charAt(0).toUpperCase();
+						note = note.concat(sf.substring(1, _sflen - 1));
+						break;
+				}
+			}
+
+			const fifthindex = fifths[mode].indexOf(note);
+			sf = fifthindex === -1 ? 0 : fifthindex - 7;
+		}
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(0x00).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			[0x02], // Size
+			Utils.numberToBytes(sf, 1), // Number of sharp or flats ( < 0 flat; > 0 sharp)
+			Utils.numberToBytes(mode, 1), // Mode: 0 major, 1 minor
+		);
+	}
+}
+
+export {KeySignatureEvent};

package/src/meta-events/lyric-event.ts

@@ -0,0 +1,35 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a lyric meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {LyricEvent}
+ */
+class LyricEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	text: string;
+	type: 0x05;
+
+	constructor(fields: { text: string; delta?: number; }) {
+		this.delta = fields.delta || 0x00;
+		this.name = 'LyricEvent';
+		this.text = fields.text;
+		this.type = 0x05;
+
+		const textBytes = Utils.stringToBytes(this.text);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			Utils.numberToVariableLength(textBytes.length), // Size
+			textBytes, // Text
+		);
+	}
+}
+
+export {LyricEvent};

package/src/meta-events/marker-event.ts

@@ -0,0 +1,35 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a marker meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {MarkerEvent}
+ */
+class MarkerEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	text: string;
+	type: 0x06;
+
+	constructor(fields: { text: string; delta?: number; }) {
+		this.delta = fields.delta || 0x00;
+		this.name = 'MarkerEvent';
+		this.text = fields.text;
+		this.type = 0x06;
+
+		const textBytes = Utils.stringToBytes(this.text);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			Utils.numberToVariableLength(textBytes.length), // Size
+			textBytes, // Text
+		);
+	}
+}
+
+export {MarkerEvent};

package/src/meta-events/meta-event.ts

@@ -0,0 +1,7 @@
+import { AbstractEvent } from "../abstract-event";
+
+interface MetaEvent extends AbstractEvent {
+    type: number|number[];
+}
+
+export {MetaEvent};

package/src/meta-events/tempo-event.ts

@@ -0,0 +1,37 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {bpm: integer, delta: integer}
+ * @return {TempoEvent}
+ */
+class TempoEvent implements MetaEvent {
+	bpm: number;
+	data: number[];
+	delta: number;
+	name: string;
+	tick: number;
+	type: 0x51;
+	
+	constructor(fields: { bpm: number; tick?: number; delta?: number; }) {
+		this.bpm = fields.bpm;
+		this.delta = fields.delta || 0x00;
+		this.tick = fields.tick;
+		this.name = 'TempoEvent';
+		this.type = 0x51;
+
+		const tempo = Math.round(60000000 / this.bpm);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			[0x03], // Size
+			Utils.numberToBytes(tempo, 3), // Tempo, 3 bytes
+		);
+	}
+}
+
+export {TempoEvent};

package/src/meta-events/text-event.ts

@@ -0,0 +1,35 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {TextEvent}
+ */
+class TextEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	text: string;
+	type: 0x01;
+
+	constructor(fields: { text: string; delta?: number; }) {
+		this.delta = fields.delta || 0x00;
+		this.text = fields.text;
+		this.name = 'TextEvent';
+		this.type = 0x01;
+
+		const textBytes = Utils.stringToBytes(this.text);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(fields.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			Utils.numberToVariableLength(textBytes.length), // Size
+			textBytes, // Text
+		);
+	}
+}
+
+export {TextEvent};

package/src/meta-events/time-signature-event.ts

@@ -0,0 +1,32 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a time signature meta event.
+ * @return {TimeSignatureEvent}
+ */
+class TimeSignatureEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	type: 0x58;
+
+	constructor(numerator, denominator, midiclockspertick, notespermidiclock) {
+		this.name = 'TimeSignatureEvent';
+		this.type = 0x58;
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(0x00).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			[0x04], // Size
+			Utils.numberToBytes(numerator, 1), // Numerator, 1 bytes
+			Utils.numberToBytes(Math.log2(denominator), 1), // Denominator is expressed as pow of 2, 1 bytes
+			Utils.numberToBytes(midiclockspertick || 24, 1), // MIDI Clocks per tick, 1 bytes
+			Utils.numberToBytes(notespermidiclock || 8, 1), // Number of 1/32 notes per MIDI clocks, 1 bytes
+		);
+	}
+}
+
+export {TimeSignatureEvent};

package/src/meta-events/track-name-event.ts

@@ -0,0 +1,35 @@
+import {Constants} from '../constants';
+import {MetaEvent} from './meta-event';
+import {Utils} from '../utils';
+
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {TrackNameEvent}
+ */
+class TrackNameEvent implements MetaEvent {
+	data: number[];
+	delta: number;
+	name: string;
+	text: string;
+	type: 0x03;
+
+	constructor(fields: { text: string; delta?: number; }) {
+		this.delta = fields.delta || 0x00;
+		this.name = 'TrackNameEvent';
+		this.text = fields.text;
+		this.type = 0x03;
+
+		const textBytes = Utils.stringToBytes(this.text);
+
+		// Start with zero time delta
+		this.data = Utils.numberToVariableLength(this.delta).concat(
+			Constants.META_EVENT_ID,
+			this.type,
+			Utils.numberToVariableLength(textBytes.length), // Size
+			textBytes, // Text
+		);
+	}
+}
+
+export {TrackNameEvent};

package/src/midi-events/controller-change-event.ts

@@ -0,0 +1,30 @@
+import {MidiEvent} from './midi-event';
+import {Utils} from '../utils';
+
+/**
+ * Holds all data for a "controller change" MIDI event
+ * @param {object} fields {controllerNumber: integer, controllerValue: integer, delta: integer}
+ * @return {ControllerChangeEvent}
+ */
+class ControllerChangeEvent implements MidiEvent {
+	channel: number;
+	controllerNumber: number;
+	controllerValue: number;
+	data: number[];
+	delta: number;
+	name: string;
+	status: 0xB0;
+
+	constructor(fields: { controllerNumber: number; controllerValue: number; channel?: number; delta?: number; }) {
+		this.channel = fields.channel - 1 || 0;
+		this.controllerValue = fields.controllerValue;
+		this.controllerNumber = fields.controllerNumber;
+		this.delta = fields.delta || 0x00;
+		this.name = 'ControllerChangeEvent';
+		this.status = 0xB0;
+
+		this.data = Utils.numberToVariableLength(fields.delta).concat(this.status | this.channel, this.controllerNumber, this.controllerValue);
+	}
+}
+
+export {ControllerChangeEvent};

package/src/midi-events/midi-event.ts

@@ -0,0 +1,11 @@
+import {AbstractEvent} from '../abstract-event';
+
+
+interface MidiEvent extends AbstractEvent {
+    channel: number;
+    status: number;
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    buildData?: Function;
+}
+
+export {MidiEvent};