@types/vexflow
Version:
TypeScript definitions for vexflow
1,229 lines (1,153 loc) • 97.6 kB
TypeScript
// 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);
}
interface GroupAttributes {
pointerBBox: boolean;
}
/**
* 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;
bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): IRenderContext;
quadraticCurveTo(x1: number, y1: number, x2: number, y2: number): IRenderContext;
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;
openGroup(cls?: string, id?: string, attrs?: GroupAttributes): Node | undefined;
closeGroup(): void;
/**
* 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: Array<{ 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;
} | undefined;
}
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
const DEFAULT_NOTATION_FONT_SCALE: number;
function clefProperties(clef: string): { line_shift: number };
function keyProperties(
key: string,
clef: string,
params: { octave_shift?: number | undefined },
): {
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): Array<{ 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 | undefined;
rest?: boolean | undefined;
position?: string | undefined;
};
// 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: Array<{ 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 {
enum Justify {
LEFT = 1,
CENTER,
RIGHT,
CENTER_STEM,
}
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;
constructor();
getType(): Barline.type;
setType(type: Barline.type): BarNote;
getBoundingBox(): BoundingBox;
addToModifierContext(): BarNote;
preFormat(): BarNote;
draw(): void;
}
namespace Barline {
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);
setStyle(style: {
shadowColor?: string | undefined;
shadowBlur?: string | undefined;
fillStyle?: string | undefined;
strokeStyle?: string | undefined;
}): Beam;
setContext(context: IRenderContext): Beam;
getNotes(): StemmableNote[];
getBeamCount(): number;
breakSecondaryAt(indices: number[]): Beam;
getSlopeY(): number;
calculateSlope(): void;
applyStemExtensions(): void;
getBeamLines(duration: string): Array<{ 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[] | undefined;
stem_direction?: number | undefined;
beam_rests?: boolean | undefined;
beam_middle_only?: boolean | undefined;
show_stemlets?: boolean | undefined;
maintain_stem_directions?: boolean | undefined;
},
): Beam[];
}
class Bend extends Modifier {
constructor(text: string, release?: boolean, phrase?: Array<{ 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;
bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): CanvasContext;
quadraticCurveTo(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;
openGroup(cls?: string, id?: string, attrs?: GroupAttributes): undefined;
closeGroup(): 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 | undefined });
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 | undefined;
thickness?: number | undefined;
x_shift?: number | undefined;
y_shift: number;
position: Curve.Position;
invert: boolean;
cps?: Array<{ x: number; y: number }> | undefined;
},
);
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 {
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;
constructor(options?: {
softmaxFactor?: number | undefined;
maxIterations?: number | undefined;
});
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 | undefined; context: IRenderContext },
): Formatter;
formatToStave(
voices: Voice[],
stave: Stave,
options?: { align_rests?: boolean | undefined; 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;
denominator: number;
numerator: 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 | string);
static format(
nums: FretHandFinger[],
state: { left_shift: number; right_shift: number; text_line: number },
): void;
finger: number | string;
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 | undefined;
dots?: number | undefined;
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 | undefined; font?: IFont | undefined },
);
setOptions(options: { cache?: boolean | undefined; font?: IFont | undefined }): 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 | undefined;
type?: string | undefined;
dots?: number | undefined;
duration: string;
clef?: string | undefined;
keys: string[];
octave_shift?: number | undefined;
auto_stem?: boolean | undefined;
stem_direction?: number | undefined;
});
static LEDGER_LINE_OFFSET: number;
getStemExtension(): number;
getCategory(): string;
draw(): void;
}
namespace GraceNote {
const SCALE: number;
}
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;
alignSubNotesWithNote(subNotes: Note[], note: Note): void;
// (Modifier extends Element in vexflow, but not in these definitions, probably because of some typing problem)
getStyle(): {
shadowColor?: string | undefined;
shadowBlur?: string | undefined;
fillStyle?: string | undefined;
strokeStyle?: string | undefined;
};
setStyle(style: {
shadowColor?: string | undefined;
shadowBlur?: string | undefined;
fillStyle?: string | undefined;
strokeStyle?: string | undefined;
}): Modifier;
}
namespace Modifier {
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;
preFormatted: boolean;
constructor(note_struct: { type?: string | undefined; dots?: number | undefined; 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 | undefined;
y?: number | undefined;
note_type?: string | undefined;
duration: string;
displaced?: boolean | undefined;
stem_direction?: number | undefined;
line: number;
x_shift: number;
custom_glyph_code?: string | undefined;
style?: string | undefined;
slashed?: boolean | undefined;
glyph_font_scale?: number | undefined;
});
static DEBUG: boolean;
getCategory(): string;
setContext(context: IRenderContext): NoteHead;
getWidth(): number;
isDisplaced(): boolean;
getStyle(): {
shadowColor?: string | undefined;
shadowBlur?: string | undefined;
fillStyle?: string | undefined;
strokeStyle?: string | undefined;
};
setStyle(style: {
shadowColor?: string | undefined;
shadowBlur?: string | undefined;
fillStyle?: string | undefined;
strokeStyle?: string | undefined;
}): 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 NoteSubGroup extends Modifier {
constructor(subnotes: Note[]);
preFormat(): 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 {
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;
bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): RaphaelContext;
quadraticCurveTo(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;
openGroup(cls?: string, id?: string, attrs?: GroupAttributes): undefined;
closeGroup(): void;
}
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 {
enum Backends {
CANVAS = 1,
RAPHAEL,
SVG,
VML,
}
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 {
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 | undefined;
glyph_spacing_px?: number | undefined;
num_lines?: number | undefined;
fill_style?: string | undefined;
spacing_between_lines_px?: number | undefined;
space_above_staff_ln?: number | undefined;
space_below_staff_ln?: number | undefined;
top_text_position?: number | undefined;
},
);
options: {
vertical_bar_width?: number | undefined;
glyph_spacing_px?: number | undefined;
num_lines?: number | undefined;
fill_style?: string | undefined;
left_bar?: boolean | undefined;
line_config?: Array<{ visible: boolean }>;
right_bar?: boolean | undefined;
spacing_between_lines_px?: number | undefined;
space_above_staff_ln?: number | undefined;
space_below_staff_ln?: number | undefined;
top_text_position?: number | undefined;
};
endClef: Clef;
resetLines(): void;
setNoteStartX(x: number): Stave;
getNoteStartX(): number;
getNoteEndX(): number;
getTieStartX(): number;
getTieEndX(): number;
setContext(context: IRenderContext): Stave;
getContext(): IRenderContext;
getX(): number;
getNumLines(): number;
setNumLines(lines: number): void;
setX(x: number): Stave;
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: