web-music-score 0.0.1 → 6.0.0-pre.1

package/dist/tempo-D-JF-8b_.d.ts

@@ -0,0 +1,409 @@
+import { N as Note, A as Accidental } from './note-RVXvpfyV.js';
+
+/** Mode enum. */
+declare enum Mode {
+    /** Mode 1: Ionian (Major). */
+    Ionian = 1,
+    /** Mode 2: Dorian. */
+    Dorian = 2,
+    /** Mode 3: Phrygian. */
+    Phrygian = 3,
+    /** Mode 4: Lydian. */
+    Lydian = 4,
+    /** Mode 5: Mixolydian. */
+    Mixolydian = 5,
+    /** Mode 6: Aeolian (minor). */
+    Aeolian = 6,
+    /** Mode 7: Locrian. */
+    Locrian = 7
+}
+/** Accidental type enum. */
+declare enum AccidentalType {
+    /** Natural type has no accidentals. */
+    Natural = 0,
+    /** Flats type has one or more flats. */
+    Flats = 1,
+    /** Sharps type has one or more sharps. */
+    Sharps = 2
+}
+/**
+ * Get default key signature (key signature of "C Major" scale).
+ * @returns - Default key signature.
+ */
+declare function getDefaultKeySignature(): KeySignature;
+declare class KeySignature {
+    readonly tonic: string;
+    readonly mode: Mode;
+    private static readonly OrderOfSharps;
+    private static readonly OrderOfFlats;
+    private readonly naturalScaleNotes;
+    private readonly accidentalByDiatonicClass;
+    private readonly orderedAccidentedNotes;
+    /**
+     * @param tonic - Tonic/root note.
+     * @param mode - Mode: Ionian/Major = 1, Dorian = 2, ..., Locrian = 7
+     */
+    protected constructor(tonic: string, mode: Mode);
+    /**
+     * Get accidental type sharps, flats, or natural (without accidentals).
+     * @returns - Accidental type.
+     */
+    getAccidentalType(): AccidentalType;
+    /**
+     * Get natural scale notes of this key signature, natural scale has 7 steps (e.g. Major scale: W, W, H, W, W, W, H).
+     * @returns - Array of notes.
+     */
+    getNaturalScaleNotes(): ReadonlyArray<Note>;
+    /**
+     * Get accidental for given diatonic id.
+     * @param diatonicId - Diatonic id.
+     * @returns - Accidental -2, -1, 0, 1 or 2.
+     */
+    getAccidental(diatonicId: number): Accidental;
+    /**
+     * Get number of accidentals this key signature has.
+     * @returns - Number of accidentals.
+     */
+    getNumAccidentals(): number;
+    /**
+     * Get accidental notes in correct order.
+     * @returns - Array of accidental notes.
+     */
+    getOrderedAccidentalNotes(): ReadonlyArray<Note>;
+    /**
+     * Get note of key signature by degree value.
+     * @param degree - Degree number in range [1, 7] or string e.g "b5" or "#4".
+     * @returns - Note.
+     */
+    getNoteByDegree(degree: number | string): Note;
+    /**
+     * Test equality of given key signatures.
+     * @param a - Key signature a.
+     * @param b - Key signature b.
+     * @returns - True/false.
+     */
+    static equals(a: KeySignature | null | undefined, b: KeySignature | null | undefined): boolean;
+}
+
+/** Note length enum. */
+declare enum NoteLength {
+    /** Whole note. */
+    Whole = "1n",
+    /** Whole note creating a triplet. */
+    WholeTriplet = "1t",
+    /** Dotted whole note. */
+    WholeDot = "1.",
+    /** Double dotted whole note. */
+    Whole2Dots = "1..",
+    /** Triple dotted whole note. */
+    Whole3Dots = "1...",
+    /** Quadruple-dotted whole note. */
+    Whole4Dots = "1....",
+    /** Quintuple-dotted whole note. */
+    Whole5Dots = "1.....",
+    /** Sextuple-dotted whole note. */
+    Whole6Dots = "1......",
+    /** Half note. */
+    Half = "2n",
+    /** Half note creating a triplet. */
+    HalfTriplet = "2t",
+    /** Dotted half note. */
+    HalfDot = "2.",
+    /** Double dotted half note. */
+    Half2Dots = "2..",
+    /** Triple dotted half note. */
+    Half3Dots = "2...",
+    /** Quadruple-dotted half note. */
+    Half4Dots = "2....",
+    /** Quintuple-dotted half notre. */
+    Half5Dots = "2.....",
+    /** Quarter note. */
+    Quarter = "4n",
+    /** Quarter note creating a triplet. */
+    QuarterTriplet = "4t",
+    /** Dotted quarter note. */
+    QuarterDot = "4.",
+    /** Double dotted quarter note. */
+    Quarter2Dots = "4..",
+    /** Triple dotted quarter note. */
+    Quarter3Dots = "4...",
+    /** Quadruple-dotted quarter note. */
+    Quarter4Dots = "4....",
+    /** Eighth note. */
+    Eighth = "8n",
+    /** Eighth note creating a triplet. */
+    EighthTriplet = "8t",
+    /** Dotted eighth note. */
+    EighthDot = "8.",
+    /** Double dotted eighth note. */
+    Eighth2Dots = "8..",
+    /** Triple dotted eighth note. */
+    Eighth3Dots = "8...",
+    /** Sixteenth note. */
+    Sixteenth = "16n",
+    /** Sixteenth note creating a triplet. */
+    SixteenthTriplet = "16t",
+    /** Dotted sixteenth note. */
+    SixteenthDot = "16.",
+    /** Double dotted sixteenth note. */
+    Sixteenth2Dots = "16..",
+    /** Thirtysecond note. */
+    ThirtySecond = "32n",
+    /** Thirtysecond note creating a triplet. */
+    ThirtySecondTriplet = "32t",
+    /** Dotted thritysecond note. */
+    ThirtySecondDot = "32.",
+    /** Sixtyfourth note. */
+    SixtyFourth = "64n",
+    /** Sixtyfourth note creating a triplet. */
+    SixtyFourthTriplet = "64t"
+}
+/** String values type of note length enum. */
+type NoteLengthStr = `${NoteLength}`;
+/**
+ * Test if given argument is note length.
+ * @param noteLength - Note length to validate.
+ * @returns - True/false.
+ */
+declare function isNoteLength(noteLength: unknown): noteLength is NoteLength;
+/**
+ * Validate if given argument is note length.
+ * @param noteLength - Note length to validate.
+ * @returns - Valid note length or throws.
+ */
+declare function validateNoteLength(noteLength: unknown): NoteLength;
+/** Note length props class. */
+declare class NoteLengthProps {
+    /** Longest note size (e.g. 1 = whole note). */
+    static LongestNoteSize: number;
+    /** Shortest note size (e.g. 64 = sixtyfourth note). */
+    static ShortestNoteSize: number;
+    /** Note length. */
+    readonly noteLength: NoteLength;
+    /** Note size (whole=1, half=2, quarter=4, ...). */
+    readonly noteSize: number;
+    /** Number of ticks (not altered by isTriplet). */
+    readonly ticks: number;
+    /** Flag count. */
+    readonly flagCount: number;
+    /** Dot count. */
+    readonly dotCount: number;
+    /** Max dot count. */
+    readonly maxDotCount: number;
+    /** Is triplet? */
+    readonly isTriplet: boolean;
+    /** Has note stem. */
+    readonly hasStem: boolean;
+    /** Is note head solid (black)? */
+    readonly isSolid: boolean;
+    private constructor();
+    private static cache;
+    /**
+     * Get note length props.
+     * @param noteLength - Note length.
+     * @returns - Note length props.
+     */
+    static get(noteLength: NoteLength | NoteLengthStr | string): NoteLengthProps;
+    /**
+     * Create note length props.
+     * @param noteLength - Note length or note size.
+     * @param dotCount - Dot count.
+     * @returns - Note length props.
+     */
+    static create(noteLength: NoteLength | NoteLengthStr | string | number, dotCount?: number): NoteLengthProps;
+    /**
+     * Compare note lengths/sizes. Whole (1) > half (2) > quarter (4), etc.
+     * Ignores possible triplet property of note length.
+     * @param a - NoteLengthProps, NoteLength/Str or noteSize
+     * @param b - NoteLengthProps, NoteLength/Str or noteSize
+     * @returns - -1: a < b, 0: a === b, +1: a > b (note length/size comparisons)
+     */
+    static cmp(a: NoteLengthProps | NoteLength | NoteLengthStr | number, b: NoteLengthProps | NoteLength | NoteLengthStr | number): -1 | 0 | 1;
+    /**
+     * Compare note lengths/sizes for equality.
+     * Ignores possible triplet property of note length.
+     * @param a - NoteLengthProps, NoteLength/Str or noteSize
+     * @param b - NoteLengthProps, NoteLength/Str or noteSize
+     * @returns - true: a === b, false: a !== b (note length/size comparisons)
+     */
+    static equals(a: NoteLengthProps | NoteLength | NoteLengthStr | number, b: NoteLengthProps | NoteLength | NoteLengthStr | number): boolean;
+}
+/** Tuplet ratio interface. */
+interface TupletRatio {
+    /** Number of parts (notes). */
+    parts: number;
+    /** Played int time of (notes). */
+    inTimeOf: number;
+}
+/**
+ * Test if given argument is tuplet ratio.
+ * @param tupletRatio - Tuplet ratio to validate.
+ * @returns - True/false.
+ */
+declare function isTupletRatio(tupletRatio: unknown): tupletRatio is TupletRatio;
+/**
+ * Validate if given argument is tuplet ratio.
+ * @param tupletRatio - Tuplet ratio to validate.
+ * @returns - Valid tuplet ratio or throws.
+ */
+declare function validateTupletRatio(tupletRatio: unknown): TupletRatio;
+/** Some preset tuplet ratio values. */
+declare const Tuplet: Record<"Duplet" | "Triplet" | "Quadruplet", TupletRatio>;
+/** Rhythm props class. */
+declare class RhythmProps {
+    /** Note length. */
+    readonly noteLength: NoteLength;
+    /** Note size (whole=1, half=2, quarter=4, ...). */
+    readonly noteSize: number;
+    /** Dot count. */
+    readonly dotCount: number;
+    /** Tuplet ratio. */
+    readonly tupletRatio?: TupletRatio;
+    /** Number of ticks. */
+    readonly ticks: number;
+    /** Flag count. */
+    readonly flagCount: number;
+    /** Has note stem. */
+    readonly hasStem: boolean;
+    /** Is note head solid (black)? */
+    readonly isSolidNoteHead: boolean;
+    private constructor();
+    private static NoteSymbolMap;
+    /**
+     * Get string presentation of rhythm props.
+     * @returns - String presentation.
+     */
+    toString(): string;
+    private static cache;
+    /**
+     * Get rhythm props with given arguments.
+     * @param noteLength - Note length.
+     * @param dotCount - Dot count.
+     * @param tupletRatio - Tuplet ratio.
+     * @returns - Rhythm props.
+     */
+    static get(noteLength: NoteLength | NoteLengthStr, dotCount?: number, tupletRatio?: TupletRatio): RhythmProps;
+    /**
+     * Compare duration of rhythm props.
+     * @param a - RhythmProps
+     * @param b - RhythmProps
+     * @returns - -1: a < b, 0: a === b, +1: a > b (duration comparisons)
+     */
+    static cmp(a: RhythmProps, b: RhythmProps): -1 | 0 | 1;
+    /**
+     * Compare duration equality of rhythm props.
+     * @param a - RhythmProps
+     * @param b - RhythmProps
+     * @returns - true: a === b, false: a !== b (duration comparisons)
+     */
+    static equals(a: RhythmProps, b: RhythmProps): boolean;
+}
+
+/** Time signature enum.  */
+declare enum TimeSignatures {
+    /** 2/4 time signature. */
+    _2_4 = "2/4",
+    /** 3/4 time signature. */
+    _3_4 = "3/4",
+    /** 4/4 time signature. */
+    _4_4 = "4/4",
+    /** 3/8 time signature. */
+    _3_8 = "3/8",
+    /** 5/8 time signature. */
+    _5_8 = "5/8",
+    /** 6/8 time signature. */
+    _6_8 = "6/8",
+    /** 7/8 time signature. */
+    _7_8 = "7/8",
+    /** 9/8 time signature. */
+    _9_8 = "9/8",
+    /** 12/8 time signature. */
+    _12_8 = "12/8"
+}
+/** Beam grouping enum. */
+declare enum BeamGrouping {
+    /** 2-3 beam grouping for 5/8 time signature. */
+    _2_3 = "2-3",
+    /** 3-2 beam grouping for 5/8 time signature. */
+    _3_2 = "3-2",
+    /** 2-2-3 beam grouping for 7/8 time signature. */
+    _2_2_3 = "2-2-3",
+    /** 3-2-2 beam grouping for 7/8 time signature. */
+    _3_2_2 = "3-2-2"
+}
+/** Time signature class. */
+declare class TimeSignature {
+    /** Number of beats in measure, upper value (e.g. "3" in "3/4"). */
+    readonly beatCount: number;
+    /** Beat size of time signature, lower value (e.g. "4" in "3/4"). */
+    readonly beatSize: number;
+    /** Beat length. */
+    readonly beatLength: NoteLength;
+    /** Number of ticks in measure. */
+    readonly measureTicks: number;
+    /** Beam groups (e.g. [[2], [2]] or [[2, 2], [2, 2]] (first try as [[4], [4]])). */
+    readonly beamGroupSizes: number[][];
+    /**
+     * Create new time signature instance.
+     * @param timeSignature - For example "4/4".
+     * @param beamGrouping - Beam grouping (e.g. "3-2" for time signature "5/8").
+     */
+    constructor(timeSignature: TimeSignatures | `${TimeSignatures}`, beamGrouping?: BeamGrouping | `${BeamGrouping}`);
+    /**
+     * Create new time signature instance.
+     * @param beatCount - Measure beat count.
+     * @param beatSize - Size value: whole-note=1, half-note=2, quarter-note=4, etc.
+     * @param beamGrouping - Beam grouping (e.g. "3-2" for time signature "5/8").
+     */
+    constructor(beatCount: number, beatSize: number, beamGrouping?: BeamGrouping | `${BeamGrouping}`);
+    /**
+     * Test whether this time signature has given beat count and size.
+     * @param beatCount - Beat count.
+     * @param beatSize - Beat size.
+     * @returns - Boolean whether this time signature match given beat count and size.
+     */
+    is(beatCount: number, beatSize: number): boolean;
+    /**
+     * Get string representation of this time signature (e.g. "3/4").
+     * @returns - String representation.
+     */
+    toString(): string;
+}
+/**
+ * Get default time signature ("4/4").
+ * @returns - Default time signature.
+ */
+declare function getDefaultTimeSignature(): TimeSignature;
+
+/** Tempo type. */
+type Tempo = {
+    /** Beats per minute value. */
+    beatsPerMinute: number;
+    /** Optional tempo props. */
+    options: {
+        /** Length of ane beat. */
+        beatLength: NoteLength;
+        /** Dot count for length of one beat. */
+        dotCount: number;
+    };
+};
+/**
+ * Get default tempo, which is 120 bpm with quarter note  beat length.
+ * @returns - Default tempo.
+ */
+declare function getDefaultTempo(): Readonly<Tempo>;
+/**
+ * Get formatted tempo string (e.g. "♩=120").
+ * @param tempo - Tempo.
+ * @returns - Formatted tempo string.
+ */
+declare function getTempoString(tempo: Tempo): string;
+/**
+ * Get copy of tempo with altered speed.
+ * @param tempo - Tempo.
+ * @param speed - Speed factor, used to multiply beats per minute to.
+ * @returns - Altered tempo.
+ */
+declare function alterTempoSpeed(tempo: Tempo, speed: number): Tempo;
+
+export { AccidentalType as A, BeamGrouping as B, KeySignature as K, Mode as M, NoteLength as N, RhythmProps as R, TimeSignatures as T, TimeSignature as a, getDefaultTimeSignature as b, type Tempo as c, getDefaultTempo as d, getTempoString as e, alterTempoSpeed as f, getDefaultKeySignature as g, type NoteLengthStr as h, isNoteLength as i, NoteLengthProps as j, type TupletRatio as k, isTupletRatio as l, validateTupletRatio as m, Tuplet as n, validateNoteLength as v };

package/dist/theory/index.d.ts

@@ -0,0 +1,78 @@
+import { N as Note } from '../note-RVXvpfyV.js';
+export { A as Accidental, d as DefaultGuitarNoteLabel, D as DefaultPitchNotation, G as GuitarNoteLabel, e as GuitarNoteLabelList, a as NoteLetter, P as ParsedNote, b as PitchNotation, c as PitchNotationList, S as SymbolSet, g as getPitchNotationName, f as validateGuitarNoteLabel, v as validatePitchNotation } from '../note-RVXvpfyV.js';
+import { D as Degree } from '../scale-B1M10_fu.js';
+export { b as Interval, I as IntervalDirection, a as IntervalQuality, c as Scale, d as ScaleFactory, S as ScaleType, i as getDefaultScale, h as getScale, e as getScaleFactory, g as getScaleFactoryList, v as validateIntervalQuality, f as validateScaleType } from '../scale-B1M10_fu.js';
+export { A as AccidentalType, B as BeamGrouping, K as KeySignature, M as Mode, N as NoteLength, j as NoteLengthProps, h as NoteLengthStr, R as RhythmProps, c as Tempo, a as TimeSignature, T as TimeSignatures, n as Tuplet, k as TupletRatio, f as alterTempoSpeed, g as getDefaultKeySignature, d as getDefaultTempo, b as getDefaultTimeSignature, e as getTempoString, i as isNoteLength, l as isTupletRatio, v as validateNoteLength, m as validateTupletRatio } from '../tempo-D-JF-8b_.js';
+
+/** Chord info type. */
+type ChordInfo = {
+    name: string;
+    degrees: Degree[];
+};
+/** Chord class. */
+declare class Chord {
+    readonly chordInfo: ChordInfo;
+    readonly rootNote: Note;
+    /** Chord name. */
+    readonly name: string;
+    /** Notes of this chord. */
+    readonly notes: Note[];
+    /** Notes that are omitted in this chord (partial chord). */
+    readonly omitNotes: boolean[];
+    /** Bass note if not chord root note (e.g. "B" in "C/B"). */
+    readonly slashBassNote?: Note;
+    private constructor();
+    /**
+     * Get all chords that can be made up with given notes.
+     * @param notes - Array of notes.
+     * @returns - Array of chords.
+     */
+    static getChords(notes: ReadonlyArray<Note>): ReadonlyArray<Chord>;
+    private replaceWith;
+    /**
+     * Get chord string presentation.
+     * @returns Chord string presentation (e.g. "C/B").
+     */
+    toString(): string;
+    /**
+     * Get degree notation string (e.g. "E - 1(C) - 3(E) - 5(G)").
+     * @returns Degree notation string.
+     */
+    getDegreeNotationString(): string;
+    /**
+     * Get string presentation of omitted degrees (e.g. "Omits 5(G), 9(D)").
+     * @returns - String presentation of omitted degrees.
+     */
+    getOmittedDegreesString(): string;
+    /**
+     * Degree index for given degree index (e.g. "3").
+     * @param i - Chord degree index (e.g. 0 is first note degree of chord).
+     * @returns Degree string.
+     */
+    private getDegreeStr;
+    /**
+     * Get note name for given degree index (e.g. "E").
+     * @param i - Chord degree index (e.g. 0 is first note degree of chord).
+     * @returns - Note name string.
+     */
+    private getNoteStr;
+}
+
+/** Guitar tuning name list. */
+declare const TuningNameList: ReadonlyArray<string>;
+/** DEfault tuning name (Standard). */
+declare const DefaultTuningName: string;
+/**
+ * Validate if given argument is available tuning name.
+ * @param tuningName - Tuning name to validate.
+ * @returns - Tuning name if valid, or throws.
+ */
+declare function validateTuningName(tuningName: string): string;
+/**
+ * Get guitar tuning, note for each open string.
+ * @param tuningName - Tuning name.
+ * @returns Array of open string notes.
+ */
+declare function getTuningStrings(tuningName: string): ReadonlyArray<Note>;
+
+export { Chord, type ChordInfo, DefaultTuningName, Degree, Note, TuningNameList, getTuningStrings, validateTuningName };