@huffduff/midi-writer-ts 3.2.0

package/build/types/abstract-event.d.ts

@@ -0,0 +1,7 @@
+interface AbstractEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    tick?: number;
+}
+export { AbstractEvent };

package/build/types/chunks/chunk.d.ts

@@ -0,0 +1,5 @@
+interface Chunk {
+    type: number[];
+    size: number[];
+}
+export { Chunk };

package/build/types/chunks/header.d.ts

@@ -0,0 +1,13 @@
+import { Chunk } from './chunk';
+/**
+ * Object representation of a header chunk section of a MIDI file.
+ * @param {number} numberOfTracks - Number of tracks
+ * @return {Header}
+ */
+declare class Header implements Chunk {
+    data: number[];
+    type: number[];
+    size: number[];
+    constructor(numberOfTracks: any);
+}
+export { Header };

package/build/types/chunks/track.d.ts

@@ -0,0 +1,139 @@
+import { AbstractEvent } from '../abstract-event';
+import { Chunk } from './chunk';
+import { NoteEvent } from '../midi-events/note-event';
+/**
+ * Holds all data for a track.
+ * @param {object} fields {type: number, data: array, size: array, events: array}
+ * @return {Track}
+ */
+declare class Track implements Chunk {
+    data: number[];
+    events: AbstractEvent[];
+    explicitTickEvents: NoteEvent[];
+    size: number[];
+    type: number[];
+    tickPointer: number;
+    constructor();
+    /**
+     * Adds any event type to the track.
+     * Events without a specific startTick property are assumed to be added in order of how they should output.
+     * Events with a specific startTick property are set aside for now will be merged in during build process.
+     *
+     * TODO: Don't put startTick events in their own array.  Just lump everything together and sort it out during buildData();
+     * @param {(NoteEvent|ProgramChangeEvent)} events - Event object or array of Event objects.
+     * @param {Function} mapFunction - Callback which can be used to apply specific properties to all events.
+     * @return {Track}
+     */
+    addEvent(events: (AbstractEvent | AbstractEvent[]), mapFunction?: (i: number, event: AbstractEvent) => object): Track;
+    /**
+     * Builds int array of all events.
+     * @param {object} options
+     * @return {Track}
+     */
+    buildData(options?: {}): this;
+    mergeExplicitTickEvents(): void;
+    /**
+     * Merges another track's events with this track.
+     * @param {Track} track
+     * @return {Track}
+     */
+    mergeTrack(track: Track): Track;
+    /**
+     * Merges a single event into this track's list of events based on event.tick property.
+     * @param {AbstractEvent} - event
+     * @return {Track}
+     */
+    mergeSingleEvent(event: AbstractEvent): Track;
+    /**
+     * Removes all events matching specified type.
+     * @param {string} eventName - Event type
+     * @return {Track}
+     */
+    removeEventsByName(eventName: string): Track;
+    /**
+     * Sets tempo of the MIDI file.
+     * @param {number} bpm - Tempo in beats per minute.
+     * @param {number} tick - Start tick.
+     * @return {Track}
+     */
+    setTempo(bpm: number, tick?: number): Track;
+    /**
+     * Sets time signature.
+     * @param {number} numerator - Top number of the time signature.
+     * @param {number} denominator - Bottom number of the time signature.
+     * @param {number} midiclockspertick - Defaults to 24.
+     * @param {number} notespermidiclock - Defaults to 8.
+     * @return {Track}
+     */
+    setTimeSignature(numerator: number, denominator: number, midiclockspertick: number, notespermidiclock: number): Track;
+    /**
+     * Sets key signature.
+     * @param {*} sf -
+     * @param {*} mi -
+     * @return {Track}
+     */
+    setKeySignature(sf: any, mi: any): Track;
+    /**
+     * Adds text to MIDI file.
+     * @param {string} text - Text to add.
+     * @return {Track}
+     */
+    addText(text: string): Track;
+    /**
+     * Adds copyright to MIDI file.
+     * @param {string} text - Text of copyright line.
+     * @return {Track}
+     */
+    addCopyright(text: string): Track;
+    /**
+     * Adds Sequence/Track Name.
+     * @param {string} text - Text of track name.
+     * @return {Track}
+     */
+    addTrackName(text: string): Track;
+    /**
+     * Sets instrument name of track.
+     * @param {string} text - Name of instrument.
+     * @return {Track}
+     */
+    addInstrumentName(text: string): Track;
+    /**
+     * Adds marker to MIDI file.
+     * @param {string} text - Marker text.
+     * @return {Track}
+     */
+    addMarker(text: string): Track;
+    /**
+     * Adds cue point to MIDI file.
+     * @param {string} text - Text of cue point.
+     * @return {Track}
+     */
+    addCuePoint(text: string): Track;
+    /**
+     * Adds lyric to MIDI file.
+     * @param {string} text - Lyric text to add.
+     * @return {Track}
+     */
+    addLyric(text: string): Track;
+    /**
+     * Channel mode messages
+     * @return {Track}
+     */
+    polyModeOn(): Track;
+    /**
+     * Sets a pitch bend.
+     * @param {float} bend - Bend value ranging [-1,1], zero meaning no bend.
+     * @return {Track}
+     */
+    setPitchBend(bend: number): Track;
+    /**
+     * Adds a controller change event
+     * @param {number} number - Control number.
+     * @param {number} value - Control value.
+     * @param {number} channel - Channel to send controller change event on (1-based).
+     * @param {number} delta - Track tick offset for cc event.
+     * @return {Track}
+     */
+    controllerChange(number: number, value: number, channel?: number, delta?: number): Track;
+}
+export { Track };

package/build/types/constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MIDI file format constants.
+ * @return {Constants}
+ */
+declare const Constants: {
+    VERSION: string;
+    HEADER_CHUNK_TYPE: number[];
+    HEADER_CHUNK_LENGTH: number[];
+    HEADER_CHUNK_FORMAT0: number[];
+    HEADER_CHUNK_FORMAT1: number[];
+    HEADER_CHUNK_DIVISION: number[];
+    TRACK_CHUNK_TYPE: number[];
+    META_EVENT_ID: number;
+    META_SMTPE_OFFSET: number;
+};
+export { Constants };

package/build/types/main.d.ts

@@ -0,0 +1,56 @@
+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';
+declare const _default: {
+    Constants: {
+        VERSION: string;
+        HEADER_CHUNK_TYPE: number[];
+        HEADER_CHUNK_LENGTH: number[];
+        HEADER_CHUNK_FORMAT0: number[];
+        HEADER_CHUNK_FORMAT1: number[];
+        HEADER_CHUNK_DIVISION: number[];
+        TRACK_CHUNK_TYPE: number[];
+        META_EVENT_ID: number;
+        META_SMTPE_OFFSET: number;
+    };
+    ControllerChangeEvent: typeof ControllerChangeEvent;
+    CopyrightEvent: typeof CopyrightEvent;
+    CuePointEvent: typeof CuePointEvent;
+    EndTrackEvent: typeof EndTrackEvent;
+    InstrumentNameEvent: typeof InstrumentNameEvent;
+    KeySignatureEvent: typeof KeySignatureEvent;
+    LyricEvent: typeof LyricEvent;
+    MarkerEvent: typeof MarkerEvent;
+    NoteOnEvent: typeof NoteOnEvent;
+    NoteOffEvent: typeof NoteOffEvent;
+    NoteEvent: typeof NoteEvent;
+    PitchBendEvent: typeof PitchBendEvent;
+    ProgramChangeEvent: typeof ProgramChangeEvent;
+    TempoEvent: typeof TempoEvent;
+    TextEvent: typeof TextEvent;
+    TimeSignatureEvent: typeof TimeSignatureEvent;
+    Track: typeof Track;
+    TrackNameEvent: typeof TrackNameEvent;
+    Utils: typeof Utils;
+    VexFlow: typeof VexFlow;
+    Writer: typeof Writer;
+};
+export default _default;

package/build/types/meta-events/copyright-event.d.ts

@@ -0,0 +1,18 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {CopyrightEvent}
+ */
+declare class CopyrightEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    text: string;
+    type: 0x02;
+    constructor(fields: {
+        text: string;
+        delta?: number;
+    });
+}
+export { CopyrightEvent };

package/build/types/meta-events/cue-point-event.d.ts

@@ -0,0 +1,18 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a cue point meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {CuePointEvent}
+ */
+declare class CuePointEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    text: string;
+    type: 0x07;
+    constructor(fields: {
+        text: string;
+        delta?: number;
+    });
+}
+export { CuePointEvent };

package/build/types/meta-events/end-track-event.d.ts

@@ -0,0 +1,16 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a end track meta event.
+ * @param {object} fields {delta: integer}
+ * @return {EndTrackEvent}
+ */
+declare class EndTrackEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    type: [0x2F, 0x00];
+    constructor(fields?: {
+        delta: number;
+    });
+}
+export { EndTrackEvent };

package/build/types/meta-events/instrument-name-event.d.ts

@@ -0,0 +1,18 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of an instrument name meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {InstrumentNameEvent}
+ */
+declare class InstrumentNameEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    text: string;
+    type: 0x04;
+    constructor(fields: {
+        text: string;
+        delta?: number;
+    });
+}
+export { InstrumentNameEvent };

package/build/types/meta-events/key-signature-event.d.ts

@@ -0,0 +1,13 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a key signature meta event.
+ * @return {KeySignatureEvent}
+ */
+declare class KeySignatureEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    type: 0x59;
+    constructor(sf: any, mi: any);
+}
+export { KeySignatureEvent };

package/build/types/meta-events/lyric-event.d.ts

@@ -0,0 +1,18 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a lyric meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {LyricEvent}
+ */
+declare class LyricEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    text: string;
+    type: 0x05;
+    constructor(fields: {
+        text: string;
+        delta?: number;
+    });
+}
+export { LyricEvent };

package/build/types/meta-events/marker-event.d.ts

@@ -0,0 +1,18 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a marker meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {MarkerEvent}
+ */
+declare class MarkerEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    text: string;
+    type: 0x06;
+    constructor(fields: {
+        text: string;
+        delta?: number;
+    });
+}
+export { MarkerEvent };

package/build/types/meta-events/meta-event.d.ts

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

package/build/types/meta-events/tempo-event.d.ts

@@ -0,0 +1,20 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {bpm: integer, delta: integer}
+ * @return {TempoEvent}
+ */
+declare class TempoEvent implements MetaEvent {
+    bpm: number;
+    data: number[];
+    delta: number;
+    name: string;
+    tick: number;
+    type: 0x51;
+    constructor(fields: {
+        bpm: number;
+        tick?: number;
+        delta?: number;
+    });
+}
+export { TempoEvent };

package/build/types/meta-events/text-event.d.ts

@@ -0,0 +1,18 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {TextEvent}
+ */
+declare class TextEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    text: string;
+    type: 0x01;
+    constructor(fields: {
+        text: string;
+        delta?: number;
+    });
+}
+export { TextEvent };

package/build/types/meta-events/time-signature-event.d.ts

@@ -0,0 +1,13 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a time signature meta event.
+ * @return {TimeSignatureEvent}
+ */
+declare class TimeSignatureEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    type: 0x58;
+    constructor(numerator: any, denominator: any, midiclockspertick: any, notespermidiclock: any);
+}
+export { TimeSignatureEvent };

package/build/types/meta-events/track-name-event.d.ts

@@ -0,0 +1,18 @@
+import { MetaEvent } from './meta-event';
+/**
+ * Object representation of a tempo meta event.
+ * @param {object} fields {text: string, delta: integer}
+ * @return {TrackNameEvent}
+ */
+declare class TrackNameEvent implements MetaEvent {
+    data: number[];
+    delta: number;
+    name: string;
+    text: string;
+    type: 0x03;
+    constructor(fields: {
+        text: string;
+        delta?: number;
+    });
+}
+export { TrackNameEvent };

package/build/types/midi-events/controller-change-event.d.ts

@@ -0,0 +1,22 @@
+import { MidiEvent } from './midi-event';
+/**
+ * Holds all data for a "controller change" MIDI event
+ * @param {object} fields {controllerNumber: integer, controllerValue: integer, delta: integer}
+ * @return {ControllerChangeEvent}
+ */
+declare 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;
+    });
+}
+export { ControllerChangeEvent };

package/build/types/midi-events/midi-event.d.ts

@@ -0,0 +1,7 @@
+import { AbstractEvent } from '../abstract-event';
+interface MidiEvent extends AbstractEvent {
+    channel: number;
+    status: number;
+    buildData?: Function;
+}
+export { MidiEvent };

package/build/types/midi-events/note-event.d.ts

@@ -0,0 +1,31 @@
+import { AbstractEvent } from '../abstract-event';
+import { MidiEvent } from './midi-event';
+/**
+ * Wrapper for noteOnEvent/noteOffEvent objects that builds both events.
+ * @param {object} fields - {pitch: '[C4]', duration: '4', wait: '4', velocity: 1-100}
+ * @return {NoteEvent}
+ */
+declare class NoteEvent implements AbstractEvent {
+    data: number[];
+    delta: number;
+    events: MidiEvent[];
+    name: string;
+    pitch: string[];
+    grace: string | string[];
+    channel: number;
+    repeat: number;
+    tick: number;
+    duration: string;
+    sequential: boolean;
+    wait: string;
+    velocity: number;
+    tickDuration: number;
+    restDuration: number;
+    constructor(fields: any);
+    /**
+     * Builds int array for this event.
+     * @return {NoteEvent}
+     */
+    buildData(): NoteEvent;
+}
+export { NoteEvent };

package/build/types/midi-events/note-off-event.d.ts

@@ -0,0 +1,36 @@
+import { MidiEvent } from './midi-event';
+/**
+ * Holds all data for a "note off" MIDI event
+ * @param {object} fields {data: []}
+ * @return {NoteOffEvent}
+ */
+declare class NoteOffEvent implements MidiEvent {
+    channel: number;
+    data: number[];
+    delta: number;
+    deltaWithPrecisionCorrection: number;
+    status: 0x80;
+    name: string;
+    velocity: number;
+    pitch: string | number;
+    duration: string | number;
+    tick: number;
+    constructor(fields: {
+        channel: number;
+        duration: string | number;
+        velocity: number;
+        pitch: string | number;
+        tick?: number;
+        data?: number[];
+        delta?: number;
+    });
+    /**
+     * Builds int array for this event.
+     * @param {Track} track - parent track
+     * @return {NoteOffEvent}
+     */
+    buildData(track: any, precisionDelta: number, options?: {
+        middleC?: string;
+    }): this;
+}
+export { NoteOffEvent };

package/build/types/midi-events/note-on-event.d.ts

@@ -0,0 +1,36 @@
+import { MidiEvent } from './midi-event';
+/**
+ * Holds all data for a "note on" MIDI event
+ * @param {object} fields {data: []}
+ * @return {NoteOnEvent}
+ */
+declare class NoteOnEvent implements MidiEvent {
+    channel: number;
+    data: number[];
+    delta: number;
+    status: 0x90;
+    name: string;
+    pitch: string | number;
+    velocity: number;
+    wait: string | number;
+    tick: number;
+    deltaWithPrecisionCorrection: number;
+    constructor(fields: {
+        channel?: number;
+        wait?: string | number;
+        velocity?: number;
+        pitch?: string | number;
+        tick?: number;
+        data?: number[];
+        delta?: number;
+    });
+    /**
+     * Builds int array for this event.
+     * @param {Track} track - parent track
+     * @return {NoteOnEvent}
+     */
+    buildData(track: any, precisionDelta: any, options?: {
+        middleC?: string;
+    }): this;
+}
+export { NoteOnEvent };

package/build/types/midi-events/pitch-bend-event.d.ts

@@ -0,0 +1,17 @@
+import { MidiEvent } from './midi-event';
+/**
+ * Holds all data for a "Pitch Bend" MIDI event
+ * [ -1.0, 0, 1.0 ] ->  [ 0, 8192, 16383]
+ * @param {object} fields { bend : float, channel : int, delta: int }
+ * @return {PitchBendEvent}
+ */
+declare class PitchBendEvent implements MidiEvent {
+    channel: number;
+    data: number[];
+    delta: number;
+    name: string;
+    status: 0xE0;
+    constructor(fields: any);
+    scale14bits(zeroOne: any): number;
+}
+export { PitchBendEvent };

package/build/types/midi-events/program-change-event.d.ts

@@ -0,0 +1,20 @@
+import { MidiEvent } from './midi-event';
+/**
+ * Holds all data for a "program change" MIDI event
+ * @param {object} fields {instrument: integer, delta: integer}
+ * @return {ProgramChangeEvent}
+ */
+declare class ProgramChangeEvent implements MidiEvent {
+    channel: number;
+    data: number[];
+    delta: number;
+    status: 0xC0;
+    name: string;
+    instrument: number;
+    constructor(fields: {
+        channel?: number;
+        delta?: number;
+        instrument: number;
+    });
+}
+export { ProgramChangeEvent };