declarations
Version:
[](https://www.npmjs.com/package/declarations)
932 lines (846 loc) • 73.4 kB
TypeScript
// Type definitions for VexFlow v1.2.27
// Project: http://vexflow.com
// Definitions by: Roman Quiring <https://github.com/rquiring>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
//inconsistent namespace: this is a helper funtion from tables.js and should not pollute the global namespace!
declare function sanitizeDuration(duration : string) : string;
declare namespace Vex {
function L(block : string, args : any[]) : void;
function Merge<T extends Object>(destination : T, source : Object) : T;
function Min(a : number, b : number) : number;
function Max(a : number, b : number) : number;
function RoundN(x : number, n : number) : number;
function MidLine(a : number, b : number) : number;
function SortAndUnique<T extends any[]>(arr : T, cmp : Function, eq : Function) : T;
function Contains(a : any[], obj : any) : boolean;
function getCanvasContext(canvas_sel : string) : CanvasRenderingContext2D;
function drawDot(ctx : IRenderContext, x : number, y : number, color? : string) : void;
function BM(s : number, f : Function) : void;
function Inherit<T extends Object>(child : T, parent : Object, object : Object) : T;
class RuntimeError {
constructor(code : string, message : string);
}
class RERR {
constructor(code : string, message : string);
}
/**
* Helper interface for handling the different rendering contexts (i.e. CanvasContext, RaphaelContext, SVGContext). Not part of VexFlow!
*/
interface IRenderContext {
clear() : void;
setFont(family : string, size : number, weight? : number) : IRenderContext;
setRawFont(font : string) : IRenderContext;
setFillStyle(style : string) : IRenderContext;
setBackgroundFillStyle(style : string) : IRenderContext;
setStrokeStyle(style : string) : IRenderContext;
setShadowColor(color : string) : IRenderContext;
setShadowBlur(blur : string) : IRenderContext;
setLineWidth(width : number) : IRenderContext;
setLineCap(cap_type : string) : IRenderContext;
setLineDash(dash : string) : IRenderContext;
scale(x : number, y : number) : IRenderContext;
resize(width : number, height : number) : IRenderContext;
fillRect(x : number, y : number, width : number, height : number) : IRenderContext;
clearRect(x : number, y : number, width : number, height : number) : IRenderContext;
beginPath() : IRenderContext;
moveTo(x : number, y : number) : IRenderContext;
lineTo(x : number, y : number) : IRenderContext;
bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : IRenderContext;
quadraticCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number) : void;
arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : IRenderContext;
glow() : IRenderContext;
fill() : IRenderContext;
stroke() : IRenderContext;
closePath() : IRenderContext;
fillText(text : string, x : number, y : number) : IRenderContext;
save() : IRenderContext;
restore() : IRenderContext;
/**
* canvas returns TextMetrics, SVG returns SVGRect, Raphael returns {width : number, height : number}. Only width is used throughout VexFlow.
*/
measureText(text : string) : {width : number};
}
/**
* Helper interface for handling the Vex.Flow.Font object in Vex.Flow.Glyph. Not part of VexFlow!
*/
interface IFont {
glyphs : {x_min : number, x_max : number, ha : number, o : string[]}[];
cssFontWeight : string;
ascender : number;
underlinePosition : number;
cssFontStyle : string;
boundingBox : {yMin : number, xMin : number, yMax : number, xMax : number};
resolution : number;
descender : number;
familyName : string;
lineHeight : number;
underlineThickness : number;
/**
* This property is missing in vexflow_font.js, but present in gonville_original.js and gonville_all.js.
*/
original_font_information? : {postscript_name : string, version_string : string, vendor_url : string, full_font_name : string, font_family_name : string, copyright : string, description : string, trademark : string, designer : string, designer_url : string, unique_font_identifier : string, license_url : string, license_description : string, manufacturer_name : string, font_sub_family_name : string};
}
namespace Flow {
const RESOLUTION : number;
// from tables.js:
const STEM_WIDTH : number;
const STEM_HEIGHT : number;
const STAVE_LINE_THICKNESS : number;
const TIME4_4 : {num_beats : number, beat_value : number, resolution : number};
const unicode : {[name : string] : string}; //inconsistent API: this should be private and have a wrapper function like the other tables
function clefProperties(clef : string) : {line_shift : number};
function keyProperties(key : string, clef : string, params : {octave_shift? : number}) : {key : string, octave : number, line : number, int_value : number, accidental : string, code : number, stroke : number, shift_right : number, displaced : boolean};
function integerToNote(integer : number) : string;
function tabToGlyph(fret : string) : {text : string, code : number, width : number, shift_y : number};
function textWidth(text : string) : number;
function articulationCodes(artic : string) : {code : string, width : number, shift_right : number, shift_up : number, shift_down : number, between_lines : boolean};
function accidentalCodes(acc : string) : {code : string, width : number, gracenote_width : number, shift_right : number, shift_down : number};
function ornamentCodes(acc : string) : {code : string, shift_right : number, shift_up : number, shift_down : number, width : number};
function keySignature(spec : string) : {type: string, line: number}[];
function parseNoteDurationString(durationString : string) : {duration : string, dots : number, type : string};
function parseNoteData(noteData : {duration : string, dots : number, type : string}) : {duration : string, type : string, dots : number, ticks : number};
function durationToFraction(duration : string) : Fraction;
function durationToNumber(duration : string) : number;
function durationToTicks(duration : string) : number;
function durationToGlyph(duration : string, type : string) : {head_width : number, stem : boolean, stem_offset : number, flag : boolean, stem_up_extension : number, stem_down_extension : number, gracenote_stem_up_extension : number, gracenote_stem_down_extension : number, tabnote_stem_up_extension : number, tabnote_stem_down_extension : number, dot_shiftY : number, line_above : number, line_below : number, code_head? : string, rest? : boolean, position? : string};
// from glyph.js:
function renderGlyph(ctx : IRenderContext, x_pos : number, y_pos : number, point : number, val : string, nocache : boolean) : void;
// from vexflow_font.js / gonville_original.js / gonville_all.js
var Font : {
glyphs : {x_min : number, x_max : number, ha : number, o : string[]}[];
cssFontWeight : string;
ascender : number;
underlinePosition : number;
cssFontStyle : string;
boundingBox : {yMin : number, xMin : number, yMax : number, xMax : number};
resolution : number;
descender : number;
familyName : string;
lineHeight : number;
underlineThickness : number;
//inconsistent member : this is missing in vexflow_font.js, but present in gonville_original.js and gonville_all.js
original_font_information : {postscript_name : string, version_string : string, vendor_url : string, full_font_name : string, font_family_name : string, copyright : string, description : string, trademark : string, designer : string, designer_url : string, unique_font_identifier : string, license_url : string, license_description : string, manufacturer_name : string, font_sub_family_name : string};
}
class Accidental extends Modifier {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes
setNote(note : Note) : Modifier;
constructor(type : string);
static DEBUG : boolean;
static format(accidentals : Accidental[], state : {left_shift : number, right_shift : number, text_line : number}) : void;
setNote(note : StaveNote) : void;
setAsCautionary() : Accidental;
draw() : void;
static applyAccidentals(voices : Voice[], keySignature? : string) : void;
}
namespace Accidental {
const CATEGORY : string;
}
class Annotation extends Modifier {
constructor(text : string);
static DEBUG : boolean;
static format(annotations : Annotation[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
setTextLine(line : number) : Annotation;
setFont(family : string, size : number, weight : string) : Annotation;
setVerticalJustification(just : Annotation.VerticalJustify) : Annotation;
getJustification() : Annotation.Justify;
setJustification(justification : Annotation.Justify) : Annotation;
draw() : void;
}
namespace Annotation {
const enum Justify {LEFT = 1, CENTER, RIGHT, CENTER_STEM}
const enum VerticalJustify {TOP = 1, CENTER, BOTTOM, CENTER_STEM}
const CATEGORY : string;
}
class Articulation extends Modifier {
constructor(type : string);
static DEBUG : boolean;
static format(articulations : Articulation[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
draw() : void;
}
namespace Articulation {
const CATEGORY : string;
}
class BarNote extends Note {
static DEBUG : boolean;
getType() : Barline.type;
setType(type : Barline.type) : BarNote;
getBoundingBox() : BoundingBox;
addToModifierContext() : BarNote;
preFormat() : BarNote;
draw() : void;
}
namespace Barline {
const enum type {SINGLE = 1, DOUBLE, END, REPEAT_BEGIN, REPEAT_END, REPEAT_BOTH, NONE}
}
class Barline extends StaveModifier {
constructor(type : Barline.type, x : number);
getCategory() : string;
setX(x : number) : Barline;
draw(stave : Stave, x_shift? : number) : void;
drawVerticalBar(stave : Stave, x : number, double_bar? : boolean) : void;
drawVerticalEndBar(stave : Stave, x : number) : void;
drawRepeatBar(stave : Stave, x : number, begin : boolean) : void;
}
class Beam {
constructor(notes : StemmableNote[], auto_stem? : boolean);
setContext(context : IRenderContext) : Beam;
getNotes() : StemmableNote[];
getBeamCount() : number;
breakSecondaryAt(indices : number[]) : Beam;
getSlopeY() : number;
calculateSlope() : void;
applyStemExtensions() : void;
getBeamLines(duration : string) : {start : number, end : number}[];
drawStems() : void;
drawBeamLines() : void;
preFormat() : Beam;
postFormat() : Beam;
draw() : boolean;
calculateStemDirection(notes : Note) : number;
static getDefaultBeamGroups(time_sig : string) : Fraction[];
static applyAndGetBeams(voice : Voice, stem_direction : number, groups : Fraction[]) : Beam[];
static generateBeams(notes : StemmableNote[], config? : {groups? : Fraction[], stem_direction? : number, beam_rests? : boolean, beam_middle_only? : boolean, show_stemlets? : boolean, maintain_stem_directions? : boolean}) : Beam[];
}
class Bend extends Modifier {
constructor(text : string, release? : boolean, phrase? : {type : number, text : string, width : number}[]);
static UP : number;
static DOWN : number;
static format(bends : Bend[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
setXShift(value : number) : void;
setFont(font : string) : Bend;
getText() : string;
updateWidth() : Bend;
draw() : void;
}
namespace Bend {
const CATEGORY : string;
}
class BoundingBox {
constructor(x : number, y : number, w : number, h : number);
static copy(that : BoundingBox) : BoundingBox;
getX() : number;
getY() : number;
getW() : number;
getH() : number;
setX(x : number) : BoundingBox;
setY(y : number) : BoundingBox;
setW(w : number) : BoundingBox;
setH(h : number) : BoundingBox;
move(x : number, y : number) : void;
clone() : BoundingBox;
mergeWith(boundingBox : BoundingBox, ctx? : IRenderContext) : BoundingBox;
draw(ctx : IRenderContext, x : number, y : number) : void;
}
class CanvasContext implements IRenderContext {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
setLineDash(dash : string) : CanvasContext;
scale(x : number, y : number) : CanvasContext;
resize(width : number, height : number) : CanvasContext;
fillRect(x : number, y : number, width : number, height : number) : CanvasContext;
clearRect(x : number, y : number, width : number, height : number) : CanvasContext;
beginPath() : CanvasContext;
moveTo(x : number, y : number) : CanvasContext;
lineTo(x : number, y : number) : CanvasContext;
bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : CanvasContext;
quadraticCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number) : CanvasContext;
arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : CanvasContext;
glow() : CanvasContext;
fill() : CanvasContext;
stroke() : CanvasContext;
closePath() : CanvasContext;
fillText(text : string, x : number, y : number) : CanvasContext;
save() : CanvasContext;
restore() : CanvasContext;
constructor(context : CanvasRenderingContext2D);
static WIDTH : number;
static HEIGHT : number;
clear() : void;
setFont(family : string, size : number, weight? : number) : CanvasContext;
setRawFont(font : string) : CanvasContext;
setFillStyle(style : string) : CanvasContext;
setBackgroundFillStyle(style : string) : CanvasContext;
setStrokeStyle(style : string) : CanvasContext;
setShadowColor(style : string) : CanvasContext; //inconsistent name: style -> color
setShadowBlur(blur : string) : CanvasContext;
setLineWidth(width : number) : CanvasContext;
setLineCap(cap_type : string) : CanvasContext;
//inconsistent type: void -> CanvasContext
setLineDash(dash : string) : void;
scale(x : number, y : number) : void;
resize(width : number, height : number) : void;
fillRect(x : number, y : number, width : number, height : number) : void;
clearRect(x : number, y : number, width : number, height : number) : void;
beginPath() : void;
moveTo(x : number, y : number) : void;
lineTo(x : number, y : number) : void;
bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : void;
quadraticCurveToTo(x1 : number, y1 : number, x : number, y : number) : void; //inconsistent name: x -> x2, y -> y2
arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : void;
glow() : void;
fill() : void;
stroke() : void;
closePath() : void;
measureText(text : string) : TextMetrics;
fillText(text : string, x : number, y : number) : void;
save() : void;
restore() : void;
}
class Clef extends StaveModifier {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes
addModifier() : void;
addEndModifier() : void;
constructor(clef : string, size? : string, annotation? : string);
static DEBUG : boolean;
addModifier(stave : Stave) : void;
addEndModifier(stave : Stave) : void;
}
class ClefNote extends Note {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes
setStave(stave : Stave) : Note;
constructor(clef : string, size? : string, annotation? : string);
setClef(clef : string, size? : string, annotation? : string) : ClefNote;
getClef() : string;
setStave(stave : Stave) : void;
getBoundingBox() : BoundingBox;
addToModifierContext() : ClefNote;
getCategory() : string;
preFormat() : ClefNote;
draw() : void;
}
class Crescendo extends Note {
constructor(note_struct : {duration : number, line? : number});
static DEBUG : boolean;
setLine(line : number) : Crescendo;
setHeight(height : number) : Crescendo;
setDecrescendo(decresc : boolean) : Crescendo;
preFormat() : Crescendo;
draw() : void;
}
class Curve {
constructor(from : Note, to : Note, options? : {spacing? : number, thickness? : number, x_shift? : number, y_shift : number, position : Curve.Position, invert : boolean, cps? : {x : number, y : number}[]});
static DEBUG : boolean;
setContext(context : IRenderContext) : Curve;
setNotes(from : Note, to : Note) : Curve;
isPartial() : boolean;
renderCurve(params : {first_x : number, first_y : number, last_x : number, last_y : number, direction : number}) : void;
draw() : boolean;
}
namespace Curve {
const enum Position {NEAR_HEAD = 1, NEAR_TOP}
}
class Dot extends Modifier {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
setNote(note : Note) : Dot;
static format(dots : number, state : {left_shift : number, right_shift : number, text_line : number}) : void;
setNote(note : Note) : void; //inconsistent type: void -> Dot
setDotShiftY(y : number) : Dot;
draw() : void;
}
namespace Dot {
const CATEGORY : string;
}
class Formatter {
static DEBUG : boolean;
static FormatAndDraw(ctx : IRenderContext, stave : Stave, notes : Note[], params? : {auto_beam : boolean, align_rests : boolean}) : BoundingBox;
static FormatAndDraw(ctx : IRenderContext, stave : Stave, notes : Note[], params? : boolean) : BoundingBox;
static FormatAndDrawTab(ctx : IRenderContext, tabstave : TabStave, stave : Stave, tabnotes : TabNote[], notes : Note[], autobeam? : boolean, params? : {auto_beam : boolean, align_rests : boolean}) : void;
static FormatAndDrawTab(ctx : IRenderContext, tabstave : TabStave, stave : Stave, tabnotes : TabNote[], notes : Note[], autobeam? : boolean, params? : boolean) : void;
static AlignRestsToNotes(notes : Note[], align_all_notes? : boolean, align_tuplets? : boolean) : Formatter;
alignRests(voices : Voice[], align_all_notes : boolean) : void;
preCalculateMinTotalWidth(voices : Voice[]) : number;
getMinTotalWidth() : number;
createModifierContexts(voices : Voice[]) : ModifierContext[];
createTickContexts(voices : Voice[]) : TickContext[];
preFormat(justifyWidth? : number, rendering_context? : IRenderContext, voices? : Voice[], stave? : Stave) : void;
postFormat() : Formatter;
joinVoices(voices : Voice[]) : Formatter;
format(voices : Voice[], justifyWidth : number, options? : {align_rests? : boolean, context : IRenderContext}) : Formatter;
formatToStave(voices : Voice[], stave : Stave, options? : {align_rests? : boolean, context : IRenderContext}) : Formatter;
}
class Fraction {
constructor(numerator : number, denominator : number);
static GCD(a : number, b : number) : number;
static LCM(a : number, b : number) : number;
static LCMM(a : number, b : number) : number;
set(numerator : number, denominator : number) : Fraction;
value() : number;
simplify() : Fraction;
add(param1 : Fraction, param2 : Fraction) : Fraction;
add(param1 : number, param2 : number) : Fraction;
subtract(param1 : Fraction, param2 : Fraction) : Fraction;
subtract(param1 : number, param2 : number) : Fraction;
multiply(param1 : Fraction, param2 : Fraction) : Fraction;
multiply(param1 : number, param2 : number) : Fraction;
divide(param1 : Fraction, param2 : Fraction) : Fraction;
divide(param1 : number, param2 : number) : Fraction;
equals(compare : Fraction) : boolean;
greaterThan(compare : Fraction) : boolean;
greaterThanEquals(compare : Fraction) : boolean;
lessThan(compare : Fraction) : boolean;
lessThanEquals(compare : Fraction) : boolean;
clone() : Fraction;
copy(copy : Fraction) : Fraction;
quotient() : number;
fraction() : number;
abs() : Fraction;
toString() : string;
toSimplifiedString() : string;
toMixedString() : string;
parse(str : string) : Fraction;
}
class FretHandFinger extends Modifier {
constructor(number : number);
static format(nums : FretHandFinger[], state : {left_shift : number, right_shift : number, text_line : number}) : void;
getNote() : Note;
setNote(note : Note) : FretHandFinger;
getIndex() : number;
setIndex(index : number) : FretHandFinger;
getPosition() : Modifier.Position;
setPosition(position : Modifier.Position) : FretHandFinger;
setFretHandFinger(number : number) : FretHandFinger;
setOffsetX(x : number) : FretHandFinger;
setOffsetY(y : number) : FretHandFinger;
draw() : void;
}
namespace FretHandFinger {
const CATEGORY : string;
}
class GhostNote extends StemmableNote {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
setStave(stave : Stave) : Note;
constructor(duration : string);
constructor(note_struct : {type? : string, dots? : number, duration : string}); //inconsistent name : init struct is called 'duration', should be 'params'/'options' (may be string or Object)
isRest() : boolean;
setStave(stave : Stave) : void; //inconsistent type: void -> GhostNote
addToModifierContext() : GhostNote;
preFormat() : GhostNote;
draw() : void;
}
class Glyph {
constructor(code : string, point : number, options? : {cache? : boolean, font? : IFont});
setOptions(options : {cache? : boolean, font? : IFont}) : void;
setStave(stave : Stave) : Glyph;
setXShift(x_shift : number) : Glyph;
setYShift(y_shift : number) : Glyph;
setContext(context : IRenderContext) : Glyph;
getContext() : IRenderContext;
reset() : void;
setWidth(width : number) : Glyph;
getMetrics() : {x_min : number, x_max : number, width : number, height : number};
render(ctx : IRenderContext, x_pos : number, y_pos : number) : void;
renderToStave(x : number) : void;
static loadMetrics(font : IFont, code : string, cache : boolean) : {x_min : number, x_max : number, ha : number, outline : number[]};
static renderOutline(ctx : IRenderContext, outline : number[], scale : number, x_pos : number, y_pos : number) : void;
}
class GraceNote extends StaveNote {
constructor(note_struct : {slash? : boolean, type? : string, dots? : number, duration : string, clef? : string, keys : string[], octave_shift? : number, auto_stem? : boolean, stem_direction? : number});
getStemExtension() : number;
getCategory() : string;
draw() : void;
}
class GraceNoteGroup extends Modifier {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
setWidth(width : number) : Modifier;
setNote(note : StaveNote) : Modifier;
constructor(grace_notes : GraceNote[], show_slur? : boolean); //inconsistent name: 'show_slur' is called 'config', suggesting object (is boolean)
static DEBUG : boolean;
static format(gracenote_groups : GraceNoteGroup[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
preFormat() : void;
beamNotes() : GraceNoteGroup;
setNote(note : Note) : void; //inconsistent type: void -> GraceNoteGroup
setWidth(width : number) : void; //inconsistent type: void -> GraceNoteGroup
getWidth() : number;
setXShift(x_shift : number) : void;
draw() : void;
}
namespace GraceNoteGroup {
const CATEGORY : string;
}
class KeyManager {
constructor(key : string);
setKey(key : string) : KeyManager;
getKey() : string;
reset() : KeyManager;
getAccidental(key : string) : {note : string, accidental : string};
selectNote(note : string) : {note : string, accidental : string, change : boolean};
}
class KeySignature extends StaveModifier {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes
addModifier() : void;
constructor(key_spec : string);
addAccToStave(stave : Stave, acc : {type : string, line : number}, next? : {type : string, line : number}) : void;
cancelKey(spec : string) : KeySignature;
addModifier(stave : Stave) : KeySignature;
addToStave(stave : Stave, firstGlyph? : boolean) : KeySignature;
convertAccLines(clef : string, type : string) : void;
}
class Modifier {
static DEBUG : boolean;
getCategory() : string;
getWidth() : number;
setWidth(width : number) : Modifier;
getNote() : Note;
setNote(note : Note) : Modifier;
getIndex() : number;
setIndex(index : number) : Modifier;
getContext() : IRenderContext;
setContext(context : IRenderContext) : Modifier;
getModifierContext() : ModifierContext;
setModifierContext(c : ModifierContext) : Modifier;
getPosition() : Modifier.Position;
setPosition(position : Modifier.Position) : Modifier;
setTextLine(line : number) : Modifier;
setYShift(y : number) : Modifier;
setXShift(x : number) : void; //inconsistent type: void -> Modifier
draw() : void;
}
namespace Modifier {
const enum Position {LEFT = 1, RIGHT, ABOVE, BELOW}
const CATEGORY : string
}
class ModifierContext {
static DEBUG : boolean;
addModifier(modifier : Modifier) : ModifierContext;
getModifiers(type : string) : Modifier[];
getWidth() : number;
getExtraLeftPx() : number;
getExtraRightPx() : number;
getState() : {left_shift : number, right_shift : number, text_line : number};
getMetrics() : {width : number, spacing : number, extra_left_px : number, extra_right_px : number};
preFormat() : void;
postFormat() : void;
}
class Music {
isValidNoteValue(note : number) : boolean;
isValidIntervalValue(interval : number) : boolean;
getNoteParts(noteString : string) : {root : string, accidental : string};
getKeyParts(noteString : string) : {root : string, accidental : string, type : string};
getNoteValue(noteString : string) : number;
getIntervalValue(intervalString : string) : number;
getCanonicalNoteName(noteValue : number) : string;
getCanonicalIntervalName(intervalValue : number) : string;
getRelativeNoteValue(noteValue : number, intervalValue : number, direction? : number) : number;
getRelativeNoteName(root : string, noteValue : number) : string;
getScaleTones(key : string, intervals : number[]) : number;
getIntervalBetween(note1 : number, note2 : number, direction? : number) : number;
createScaleMap(keySignature : string) : {[rootName : string] : string};
}
namespace Music {
const NUM_TONES : number;
const roots : string[];
const root_values : number[];
const root_indices : {[root : string] : number};
const canonical_notes : string[];
const diatonic_intervals : string[];
const diatonic_accidentals : {[diatonic_interval : string] : {note : number, accidental : number}};
const intervals : {[interval : string] : number};
const scales : {[scale : string] : number[]};
const accidentals : string[];
const noteValues : {[value : string] : {root_index : number, int_val : number}};
}
class Note implements Tickable {
//from tickable interface:
getTicks() : Fraction;
getCenterXShift() : number;
isCenterAligned() : boolean;
setCenterAlignment(align_center : boolean) : Note;
getTuplet() : Tuplet;
setTuplet(tuplet : Tuplet) : Note;
addToModifierContext(mc : ModifierContext) : void;
preFormat() : void;
postFormat() : Note;
getIntrinsicTicks() : Fraction;
setIntrinsicTicks(intrinsicTicks : Fraction) : void;
getTickMultiplier() : Fraction;
applyTickMultiplier(numerator : number, denominator : number) : void;
setDuration(duration : Fraction) : void;
constructor(note_struct : {type? : string, dots? : number, duration : string});
getPlayNote() : any;
setPlayNote(note : any) : Note;
isRest() : boolean;
addStroke(index : number, stroke : Stroke) : Note;
getStave() : Stave;
setStave(stave : Stave) : Note;
getCategory() : string;
setContext(context : IRenderContext) : Note;
getExtraLeftPx() : number;
getExtraRightPx() : number;
setExtraLeftPx(x : number) : Note;
setExtraRightPx(x : number) : Note;
shouldIgnoreTicks() : boolean;
getLineNumber() : number;
getLineForRest() : number;
getGlyph() : Glyph;
setYs(ys : number[]) : Note;
getYs() : number[];
getYForTopText(text_line : number) : number;
getBoundingBox() : BoundingBox;
getVoice() : Voice;
setVoice(voice : Voice) : Note;
getTickContext() : TickContext;
setTickContext(tc : TickContext) : Note;
getDuration() : string;
isDotted() : boolean;
hasStem() : boolean;
getDots() : number;
getNoteType() : string;
setBeam() : Note;
setModifierContext(mc : ModifierContext) : Note;
addModifier(modifier : Modifier, index? : number) : Note;
getModifierStartXY() : {x : number, y : number};
getMetrics() : {width : number, noteWidth : number, left_shift : number, modLeftPx : number, modRightPx : number, extraLeftPx : number, extraRightPx : number};
setWidth(width : number) : void;
getWidth() : number;
setXShift(x : number) : Note;
getX() : number;
getAbsoluteX() : number;
setPreFormatted(value : boolean) : void;
}
namespace Note {
const CATEGORY : string;
}
class NoteHead extends Note {
constructor(head_options : {x? : number, y? : number, note_type? : string, duration : string, displaced? : boolean, stem_direction? : number, line : number, x_shift : number, custom_glyph_code? : string, style? : string, slashed? : boolean, glyph_font_scale? : number});
static DEBUG : boolean;
getCategory() : string;
setContext(context : IRenderContext) : NoteHead;
getWidth() : number;
isDisplaced() : boolean;
getStyle() : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string};
setStyle(style : {shadowColor? : string, shadowBlur? : string, fillStyle? : string, strokeStyle? : string}) : NoteHead;
getGlyph() : Glyph;
setX(x : number) : NoteHead;
getY() : number;
setY(y : number) : NoteHead;
getLine() : number;
setLine(line : number) : NoteHead;
getAbsoluteX() : number;
getBoundingBox() : BoundingBox;
applyStyle(context : IRenderContext) : NoteHead;
setStave(stave : Stave) : NoteHead;
preFormat() : NoteHead;
draw() : void;
}
class Ornament extends Modifier {
constructor(type : string);
static DEBUG : boolean;
static format(ornaments : Ornament[], state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
setDelayed(delayed : boolean) : Ornament;
setUpperAccidental(acc : string) : Ornament;
setLowerAccidental(acc : string) : Ornament;
draw() : void;
}
namespace Ornament {
const CATEGORY : string;
}
class PedalMarking {
constructor(notes : Note[]); //inconsistent name: 'notes' is called 'type', suggesting string (is Note[])
static DEBUG : boolean;
static createSustain(notes : Note[]) : PedalMarking;
static createSostenuto(notes : Note[]) : PedalMarking;
static createUnaCorda(notes : Note[]) : PedalMarking;
setCustomText(depress? : string, release? : string) : PedalMarking;
setStyle(style : PedalMarking.Styles) : PedalMarking;
setLine(line : number) : PedalMarking;
setContext(context : IRenderContext) : PedalMarking;
drawBracketed() : void;
drawText() : void;
draw() : void;
}
namespace PedalMarking {
const enum Styles {TEXT = 1, BRACKET, MIXED}
const GLYPHS : {[name : string] : {code : string, x_shift : number, y_shift : number}};
}
class RaphaelContext implements IRenderContext {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes or type inconsistencies mentioned below are fixed
setLineWidth(width : number) : RaphaelContext;
glow() : RaphaelContext;
constructor(element : HTMLElement);
setFont(family : string, size : number, weight? : number) : RaphaelContext;
setRawFont(font : string) : RaphaelContext;
setFillStyle(style : string) : RaphaelContext;
setBackgroundFillStyle(style : string) : RaphaelContext;
setStrokeStyle(style : string) : RaphaelContext;
setShadowColor(style : string) : RaphaelContext; //inconsistent name: style -> color
setShadowBlur(blur : string) : RaphaelContext;
setLineWidth(width : number) : void; //inconsistent type: void -> RaphaelContext
setLineDash(dash : string) : RaphaelContext;
setLineCap(cap_type : string) : RaphaelContext;
scale(x : number, y : number) : RaphaelContext;
clear() : void;
resize(width : number, height : number) : RaphaelContext;
setViewBox(viewBox : string) : void;
rect(x : number, y : number, width : number, height : number) : void;
fillRect(x : number, y : number, width : number, height : number) : RaphaelContext;
clearRect(x : number, y : number, width : number, height : number) : RaphaelContext;
beginPath() : RaphaelContext;
moveTo(x : number, y : number) : RaphaelContext;
lineTo(x : number, y : number) : RaphaelContext;
bezierCurveToTo(x1 : number, y1 : number, x2 : number, y2 : number, x : number, y : number) : RaphaelContext;
quadraticCurveToTo(x1 : number, y1 : number, x : number, y : number) : RaphaelContext; //inconsistent name: x, y -> x2, y2
arc(x : number, y : number, radius : number, startAngle : number, endAngle : number, antiClockwise : boolean) : RaphaelContext;
glow() : {width : number, fill : boolean, opacity : number, offsetx : number, offsety : number, color : string}; //inconsistent type : Object -> RaphaelContext
fill() : RaphaelContext;
stroke() : RaphaelContext;
closePath() : RaphaelContext;
measureText(text : string) : {width : number, height : number};
fillText(text : string, x : number, y : number) : RaphaelContext;
save() : RaphaelContext;
restore() : RaphaelContext;
}
class Renderer {
constructor(sel : HTMLElement, backend : Renderer.Backends)
static USE_CANVAS_PROXY : boolean;
static buildContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : IRenderContext;
static getCanvasContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : CanvasContext;
static getRaphaelContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : RaphaelContext;
static getSVGContext(sel : HTMLElement, backend : Renderer.Backends, width? : number, height? : number, background? : string) : SVGContext;
static bolsterCanvasContext(ctx : CanvasRenderingContext2D) : CanvasContext;
static drawDashedLine(context : IRenderContext, fromX : number, fromY : number, toX : number, toY : number, dashPattern : number[]) : void;
resize(width : number, height : number) : Renderer;
getContext() : IRenderContext;
}
namespace Renderer {
const enum Backends {CANVAS = 1, RAPHAEL, SVG, VML}
const enum LineEndType {NONE = 1, UP, DOWN}
}
class Repetition extends StaveModifier {
constructor(type : Repetition.type, x : number, y_shift : number);
getCategory() : string;
setShiftX(x : number) : Repetition;
setShiftY(y : number) : Repetition;
draw(stave : Stave, x : number) : Repetition;
drawCodaFixed(stave : Stave, x : number) : Repetition;
drawSignoFixed(stave : Stave, x : number) : Repetition; //inconsistent name: drawSignoFixed -> drawSegnoFixed
drawSymbolText(stave : Stave, x : number, text : string, draw_coda : boolean) : Repetition;
}
namespace Repetition {
const enum type { NONE = 1, CODA_LEFT, CODA_RIGHT, SEGNO_LEFT, SEGNO_RIGHT, DC, DC_AL_CODA, DC_AL_FINE, DS, DS_AL_CODA, DS_AL_FINE, FINE }
}
class Stave {
constructor(x : number, y : number, width : number, options? : {vertical_bar_width? : number, glyph_spacing_px? : number, num_lines? : number, fill_style? : string, spacing_between_lines_px? : number, space_above_staff_ln? : number, space_below_staff_ln? : number, top_text_position? : number});
resetLines() : void;
setNoteStartX(x : number) : Stave;
getNoteStartX() : number;
getNoteEndX() : number;
getTieStartX() : number;
getTieEndX() : number;
setContext(context : IRenderContext) : Stave;
getContext() : IRenderContext;
getX() : number;
getNumLines() : number;
setY(y : number) : Stave;
setWidth(width : number) : Stave;
getWidth() : number;
setMeasure(measure : number) : Stave;
setBegBarType(type : Barline.type) : Stave;
setEndBarType(type : Barline.type) : Stave;
getModifierXShift(index : number) : number;
setRepetitionTypeLeft(type : Repetition.type, y : number) : Stave;
setRepetitionTypeRight(type : Repetition.type, y : number) : Stave;
setVoltaType(type : Volta.type, number_t : number, y : number) : Stave;
setSection(section : string, y : number) : Stave;
setTempo(tempo : {name? : string, duration : string, dots : number, bpm : number}, y : number) : Stave;
setText(text : string, position : Modifier.Position, options? : {shift_x? : number, shift_y? : number, justification? : TextNote.Justification}) : Stave;
getHeight() : number;
getSpacingBetweenLines() : number;
getBoundingBix() : BoundingBox;
getBottomY() : number;
getBottomLineY() : number;
getYForLine(line : number) : number;
getYForTopText(line? : number) : number;
getYForBottomText(line? : number) : number;
getYForNote(line? : number) : number;
getYForGlyphs() : number;
addGlyph(glypg : Glyph) : Stave;
addEndGlyph(glypg : Glyph) : Stave;
addModifier(modifier : StaveModifier) : Stave;
addEndModifier(modifier : StaveModifier) : Stave;
addKeySignature(keySpec : string) : Stave;
addClef(clef : string, size? : string, annotation? : string) : Stave;
addEndClef(clef : string, size? : string, annotation? : string) : Stave;
addTimeSignature(timeSpec : string, customPadding? : number) : void; //inconsistent type: void -> Stave
addTrebleGlyph() : Stave;
draw() : void;
drawVertical(x : number, isDouble : boolean) : void;
drawVerticalFixed(x : number, isDouble : boolean) : void;
drawVerticalBar(x : number) : void;
drawVerticalBarFixed(x : number) : void;
getConfigForLines() : {visible : boolean}[];
setConfigForLine(line_number : number, line_config : {visible : boolean}) : Stave;
setConfigForLines(lines_configuration : {visible : boolean}[]) : Stave;
}
class StaveConnector {
constructor(top_stave : Stave, bottom_stave : Stave);
setContext(ctx : IRenderContext) : StaveConnector;
setType(type : StaveConnector.type) : StaveConnector;
setText(text : string, text_options? : {shift_x? : number, shift_y? : number}) : StaveConnector;
setFont(font : {family? : string, size? : number, weight? : string}) : void; //inconsistent type: void -> StaveConnector
setXShift(x_shift : number) : StaveConnector;
draw() : void;
drawBoldDoubleLine(ctx : Object, type : StaveConnector.type, topX : number, topY : number, botY : number) : void;
}
namespace StaveConnector {
const enum type { SINGLE_RIGHT = 0, SINGLE_LEFT = 1, SINGLE = 1, DOUBLE = 2, BRACE = 3, BRACKET = 4, BOLD_DOUBLE_LEFT = 5, BOLD_DOUBLE_RIGHT = 6, THIN_DOUBLE = 7 }
}
class StaveHairpin {
constructor(notes : {first_note : Note, last_note : Note}, type : StaveHairpin.type);
static FormatByTicksAndDraw(ctx : IRenderContext, formatter : Formatter, notes : {first_note : Note, last_note : Note}, type : StaveHairpin.type, position : Modifier.Position, options? : {height : number, y_shift : number, left_shift_ticks : number, right_shift_ticks : number}) : void;
setContext(context : IRenderContext) : StaveHairpin;
setPosition(position : Modifier.Position) : StaveHairpin;
setRenderOptions(options : {height? : number, y_shift : number, left_shift_px : number, right_shift_px : number}) : StaveHairpin;
setNotes(notes : {first_note : Note, last_note : Note}) : StaveHairpin;
renderHairpin(params : {first_x : number, last_x : number, first_y : number, last_y : number, staff_height : number}) : void;
draw() : boolean;
}
namespace StaveHairpin {
const enum type { CRESC = 1, DECRESC }
}
class StaveLine {
constructor(notes : {first_note: Note, last_note: Note, first_indices : number[], last_indices : number[]});
setContext(context : Object) : StaveLine;
setFont(font : {family : string, size : number, weight : string}) : StaveLine;
setText(text : string) : StaveLine;
setNotes(notes : {first_note: Note, last_note: Note, first_indices? : number[], last_indices? : number[]}) : StaveLine;
applyLineStyle() : void;
applyFontStyle() : void;
draw() : StaveLine;
//inconsistent API: this should be set via an options object in the constructor
render_options : {padding_left : number, padding_right : number, line_width : number, line_dash : number[], rounded_end : boolean, color : string, draw_start_arrow : boolean, draw_end_arrow : boolean, arrowhead_length : number, arrowhead_angle : number, text_position_vertical : StaveLine.TextVerticalPosition, text_justification : StaveLine.TextJustification};
}
namespace StaveLine {
const enum TextVerticalPosition { TOP = 1, BOTTOM }
const enum TextJustification { LEFT = 1, CENTER, RIGHT }
}
class StaveModifier {
getCategory() : string;
makeSpacer(padding : number) : {getContext: Function, setStave: Function, renderToStave: Function, getMetrics: Function};
placeGlyphOnLine(glyph : Glyph, stave : Stave, line : number) : void;
setPadding(padding : number) : void;
addToStave(stave : Stave, firstGlyph : boolean) : StaveModifier;
addToStaveEnd(stave : Stave, firstGlyph : boolean) : StaveModifier;
addModifier() : void;
addEndModifier() : void;
}
class StaveNote extends StemmableNote {
//TODO remove the following lines once TypeScript allows subclass overrides with type changes and/or inconsistencies mentioned below are fixed
buildStem() : StemmableNote;
setStave(stave : Stave) : Note;
addModifier(modifier : Modifier, index? : number) : Note;
getModifierStartXY() : {x : number, y : number};
getDots() : number;
constructor(note_struct : {type? : string, dots? : number, duration : string, clef? : string, keys : string[], octave_shift? : number, auto_stem? : boolean, stem_direction? : number});
static DEBUG : boolean;
static format(notes : StaveNote[] , state : {left_shift : number, right_shift : number, text_line : number}) : boolean;
static formatByY(notes : StaveNote[] , state : {left_shift : number, right_shift : number, text_line : number}) : void;
static postFormat(notes : StaveNote[]) : boolean;
buildStem() : void; //inconsistent type: void -> StaveNote
buildNoteHeads() : void;
autoStem() : void;
calculateKeyProps() : void;
getBoundingBox() : BoundingBox;
getLineNumber() : number;
isRest() : boolean;
isChord() : boolean;
hasStem() : boolean;
getY