@coderline/alphatab-monaco 1.7.0-alpha.1626 → 1.7.0-alpha.1628

package/dist/types/alphatab/src/importer/ScoreImporter.d.ts

@@ -1,22 +0,0 @@
-import type { IReadable } from "./../io/IReadable";
-import { Score } from "./../model/Score";
-import type { Settings } from "./../Settings";
-/**
- * This is the base public class for creating new song importers which
- * enable reading scores from any binary datasource
- * @public
- */
-export declare abstract class ScoreImporter {
-    protected data: IReadable;
-    protected settings: Settings;
-    /**
-     * Initializes the importer with the given data and settings.
-     */
-    init(data: IReadable, settings: Settings): void;
-    abstract get name(): string;
-    /**
-     * Reads the {@link Score} contained in the data.
-     * @returns The score that was contained in the data.
-     */
-    abstract readScore(): Score;
-}

package/dist/types/alphatab/src/importer/ScoreLoader.d.ts

@@ -1,32 +0,0 @@
-import type { Score } from "./../model/Score";
-import { Settings } from "./../Settings";
-/**
- * The ScoreLoader enables you easy loading of Scores using all
- * available importers
- * @public
- */
-export declare class ScoreLoader {
-    /**
-     * Loads the given alphaTex string.
-     * @param tex The alphaTex string.
-     * @param settings The settings to use for parsing.
-     * @returns The parsed {@see Score}.
-     */
-    static loadAlphaTex(tex: string, settings?: Settings): Score;
-    /**
-     * Loads a score asynchronously from the given datasource
-     * @param path the source path to load the binary file from
-     * @param success this function is called if the Score was successfully loaded from the datasource
-     * @param error this function is called if any error during the loading occured.
-     * @param settings settings for the score import
-     * @target web
-     */
-    static loadScoreAsync(path: string, success: (score: Score) => void, error: (error: any) => void, settings?: Settings): void;
-    /**
-     * Loads the score from the given binary data.
-     * @param data The binary data containing a score in any known file format.
-     * @param settings The settings to use during importing.
-     * @returns The loaded score.
-     */
-    static loadScoreFromBytes(data: Uint8Array, settings?: Settings): Score;
-}

package/dist/types/alphatab/src/importer/UnsupportedFormatError.d.ts

@@ -1,9 +0,0 @@
-import { AlphaTabError } from "./../AlphaTabError";
-/**
- * The exception thrown by a {@link ScoreImporter} in case the
- * binary data does not contain a reader compatible structure.
- * @public
- */
-export declare class UnsupportedFormatError extends AlphaTabError {
-    constructor(message?: string | null, inner?: Error);
-}

package/dist/types/alphatab/src/importer/_barrel.d.ts

@@ -1,5 +0,0 @@
-export { AlphaTexErrorWithDiagnostics, AlphaTexImporter } from "./AlphaTexImporter";
-export * as alphaTex from "./alphaTex/_barrel";
-export { ScoreImporter } from "./ScoreImporter";
-export { ScoreLoader } from "./ScoreLoader";
-export { UnsupportedFormatError } from "./UnsupportedFormatError";

package/dist/types/alphatab/src/importer/alphaTex/ATNF.d.ts

@@ -1,19 +0,0 @@
-import { type AlphaTexIdentifier, type AlphaTexMetaDataNode, type AlphaTexNumberLiteral, type AlphaTexPropertiesNode, type AlphaTexPropertyNode, type AlphaTexStringLiteral, type AlphaTexArgumentList, type IAlphaTexArgumentValue } from "./AlphaTexAst";
-/**
- * AlphaTexNodeFactory (short name for less code)
- * @internal
- */
-export declare class Atnf {
-    static ident(text: string): AlphaTexIdentifier;
-    static string(text: string): AlphaTexStringLiteral;
-    static number(value: number): AlphaTexNumberLiteral;
-    static meta(tag: string, args?: AlphaTexArgumentList, properties?: AlphaTexPropertiesNode): AlphaTexMetaDataNode;
-    static identMeta(tag: string, value: string): AlphaTexMetaDataNode;
-    static numberMeta(tag: string, value: number): AlphaTexMetaDataNode;
-    static args(args: (IAlphaTexArgumentValue | undefined)[], parentheses?: boolean | undefined): AlphaTexArgumentList | undefined;
-    static stringValue(text: string): AlphaTexArgumentList;
-    static identValue(text: string): AlphaTexArgumentList;
-    static numberValue(value: number): AlphaTexArgumentList;
-    static props(properties: ([string, AlphaTexArgumentList | undefined] | undefined)[]): AlphaTexPropertiesNode;
-    static prop(properties: AlphaTexPropertyNode[], identifier: string, args?: AlphaTexArgumentList): void;
-}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1EnumMappings.d.ts

@@ -1,75 +0,0 @@
-import type { AlphaTexAccidentalMode } from "./AlphaTexShared";
-import type { BarLineStyle } from "./../../model/Bar";
-import type { BarreShape } from "./../../model/BarreShape";
-import type { BendStyle } from "./../../model/BendStyle";
-import type { BendType } from "./../../model/BendType";
-import type { Clef } from "./../../model/Clef";
-import type { Direction } from "./../../model/Direction";
-import type { DynamicValue } from "./../../model/DynamicValue";
-import type { FermataType } from "./../../model/Fermata";
-import type { GraceType } from "./../../model/GraceType";
-import type { KeySignature } from "./../../model/KeySignature";
-import type { KeySignatureType } from "./../../model/KeySignatureType";
-import type { NoteAccidentalMode } from "./../../model/NoteAccidentalMode";
-import type { Ottavia } from "./../../model/Ottavia";
-import type { Rasgueado } from "./../../model/Rasgueado";
-import type { BracketExtendMode, TrackNameMode, TrackNameOrientation, TrackNamePolicy } from "./../../model/RenderStylesheet";
-import type { SimileMark } from "./../../model/SimileMark";
-import type { TripletFeel } from "./../../model/TripletFeel";
-import type { WhammyType } from "./../../model/WhammyType";
-import type { TextAlign } from "./../../platform/ICanvas";
-/**
- * @internal
- * @partial
- */
-export declare class AlphaTex1EnumMappings {
-    private static _reverse;
-    static readonly whammyType: Map<string, WhammyType>;
-    static readonly whammyTypeReversed: Map<WhammyType, string>;
-    static readonly bendStyle: Map<string, BendStyle>;
-    static readonly bendStyleReversed: Map<BendStyle, string>;
-    static readonly graceType: Map<string, GraceType>;
-    static readonly graceTypeReversed: Map<GraceType, string>;
-    static readonly fermataType: Map<string, FermataType>;
-    static readonly fermataTypeReversed: Map<FermataType, string>;
-    static readonly alphaTexAccidentalMode: Map<string, AlphaTexAccidentalMode>;
-    static readonly alphaTexAccidentalModeReversed: Map<AlphaTexAccidentalMode, string>;
-    static readonly noteAccidentalMode: Map<string, NoteAccidentalMode>;
-    static readonly noteAccidentalModeReversed: Map<NoteAccidentalMode, string>;
-    static readonly barreShape: Map<string, BarreShape>;
-    static readonly barreShapeReversed: Map<BarreShape, string>;
-    static readonly ottavia: Map<string, Ottavia>;
-    static readonly ottaviaReversed: Map<Ottavia, string>;
-    static readonly rasgueado: Map<string, Rasgueado>;
-    static readonly rasgueadoReversed: Map<Rasgueado, string>;
-    static readonly dynamicValue: Map<string, DynamicValue>;
-    static readonly dynamicValueReversed: Map<DynamicValue, string>;
-    static readonly bracketExtendMode: Map<string, BracketExtendMode>;
-    static readonly bracketExtendModeReversed: Map<BracketExtendMode, string>;
-    static readonly trackNamePolicy: Map<string, TrackNamePolicy>;
-    static readonly trackNamePolicyReversed: Map<TrackNamePolicy, string>;
-    static readonly trackNameOrientation: Map<string, TrackNameOrientation>;
-    static readonly trackNameOrientationReversed: Map<TrackNameOrientation, string>;
-    static readonly trackNameMode: Map<string, TrackNameMode>;
-    static readonly trackNameModeReversed: Map<TrackNameMode, string>;
-    static readonly textAlign: Map<string, TextAlign>;
-    static readonly textAlignReversed: Map<TextAlign, string>;
-    static readonly bendType: Map<string, BendType>;
-    static readonly bendTypeReversed: Map<BendType, string>;
-    static readonly keySignature: Map<string, KeySignature>;
-    static readonly keySignatureReversed: Map<KeySignature, string>;
-    static readonly keySignatureType: Map<string, KeySignatureType>;
-    static readonly keySignatureTypeReversed: Map<KeySignatureType, string>;
-    static readonly clef: Map<string, Clef>;
-    static readonly clefReversed: Map<Clef, string>;
-    static readonly tripletFeel: Map<string, TripletFeel>;
-    static readonly tripletFeelReversed: Map<TripletFeel, string>;
-    static readonly barLineStyle: Map<string, BarLineStyle>;
-    static readonly barLineStyleReversed: Map<BarLineStyle, string>;
-    static readonly simileMark: Map<string, SimileMark>;
-    static readonly simileMarkReversed: Map<SimileMark, string>;
-    static readonly direction: Map<string, Direction>;
-    static readonly directionReversed: Map<Direction, string>;
-    static readonly keySignaturesMinorReversed: Map<KeySignature, string>;
-    static readonly keySignaturesMajorReversed: Map<KeySignature, string>;
-}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1LanguageDefinitions.d.ts

@@ -1,39 +0,0 @@
-import type { AlphaTexNodeType } from "./AlphaTexAst";
-import type { ArgumentListParseTypesMode } from "./AlphaTexShared";
-/**
- * @record
- * @internal
- */
-export interface AlphaTexParameterDefinition {
-    expectedTypes: Set<AlphaTexNodeType>;
-    parseMode: ArgumentListParseTypesMode;
-    allowedValues?: Set<string>;
-    reservedIdentifiers?: Set<string>;
-}
-/**
- * @record
- * @internal
- */
-export interface AlphaTexSignatureDefinition {
-    isStrict: boolean;
-    parameters: AlphaTexParameterDefinition[];
-}
-/**
- * @internal
- */
-export declare class AlphaTex1LanguageDefinitions {
-    private static _param;
-    private static _simple;
-    private static _metaProps;
-    private static _props;
-    private static _signatures;
-    static readonly scoreMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
-    static readonly staffMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
-    static readonly structuralMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
-    static readonly barMetaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>;
-    static readonly metaDataProperties: Map<string, Map<string, AlphaTexSignatureDefinition[] | null> | null>;
-    static readonly metaDataSignatures: Map<string, AlphaTexSignatureDefinition[] | null>[];
-    static readonly durationChangeProperties: Map<string, AlphaTexSignatureDefinition[] | null>;
-    static readonly beatProperties: Map<string, AlphaTexSignatureDefinition[] | null>;
-    static readonly noteProperties: Map<string, AlphaTexSignatureDefinition[] | null>;
-}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1LanguageHandler.d.ts

@@ -1,72 +0,0 @@
-import { type AlphaTexMetaDataNode, type AlphaTexPropertyNode } from "./AlphaTexAst";
-import { type IAlphaTexImporter } from "./AlphaTexShared";
-import { ApplyNodeResult, ApplyStructuralMetaDataResult, type IAlphaTexLanguageImportHandler } from "./IAlphaTexLanguageImportHandler";
-import { type Bar } from "./../../model/Bar";
-import { type Beat } from "./../../model/Beat";
-import type { Note } from "./../../model/Note";
-import { Score } from "./../../model/Score";
-import { Staff } from "./../../model/Staff";
-/**
- * @internal
- */
-export declare class AlphaTex1LanguageHandler implements IAlphaTexLanguageImportHandler {
-    static readonly instance: AlphaTex1LanguageHandler;
-    applyScoreMetaData(importer: IAlphaTexImporter, score: Score, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
-    private _checkArgumentTypes;
-    applyStaffMetaData(importer: IAlphaTexImporter, staff: Staff, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
-    applyBarMetaData(importer: IAlphaTexImporter, bar: Bar, metaData: AlphaTexMetaDataNode): ApplyNodeResult;
-    private static _handleAccidentalMode;
-    private static _getChordId;
-    private _buildSyncPoint;
-    private _validateArgumentTypes;
-    private _headerFooterStyle;
-    private _readTrackInstrument;
-    private _chordProperties;
-    private _tuningProperties;
-    private static _booleanLikeValue;
-    applyStructuralMetaData(importer: IAlphaTexImporter, metaData: AlphaTexMetaDataNode): ApplyStructuralMetaDataResult;
-    private _checkProperty;
-    private _staffProperties;
-    private _trackProperties;
-    applyBeatDurationProperty(importer: IAlphaTexImporter, p: AlphaTexPropertyNode): ApplyNodeResult;
-    private static _getTupletDenominator;
-    private _allKnownBarMetaDataTags;
-    get allKnownMetaDataTags(): Set<string>;
-    private _knownScoreMetaDataTags;
-    get knownScoreMetaDataTags(): Set<string>;
-    private _knownStructuralMetaDataTags;
-    get knownStructuralMetaDataTags(): Set<string>;
-    private _knownBarMetaDataTags;
-    get knownBarMetaDataTags(): Set<string>;
-    private _knownStaffMetaDataTags;
-    get knownStaffMetaDataTags(): Set<string>;
-    private _knownBeatDurationProperties;
-    get knownBeatDurationProperties(): Set<string>;
-    private _knownBeatProperties;
-    get knownBeatProperties(): Set<string>;
-    private _knownNoteProperties;
-    get knownNoteProperties(): Set<string>;
-    applyBeatProperty(importer: IAlphaTexImporter, beat: Beat, p: AlphaTexPropertyNode): ApplyNodeResult;
-    private static _applySustainPedal;
-    private static _applyBrush;
-    applyNoteProperty(importer: IAlphaTexImporter, note: Note, p: AlphaTexPropertyNode): ApplyNodeResult;
-    private static _toFinger;
-    private static _harmonicValue;
-    private _getBendPoints;
-    private static _parseEnumValue;
-    private static readonly _defaultScore;
-    private static readonly _defaultTrack;
-    buildScoreMetaDataNodes(score: Score): AlphaTexMetaDataNode[];
-    private static _buildStyleSheetMetaData;
-    private static _buildScoreInfoMeta;
-    buildSyncPointNodes(score: Score): AlphaTexMetaDataNode[];
-    buildBarMetaDataNodes(staff: Staff, bar: Bar | undefined, voice: number, isMultiVoice: boolean): AlphaTexMetaDataNode[];
-    private static _buildStaffMetaDataNodes;
-    private static _buildChordNode;
-    private static _buildMasterBarMetaDataNodes;
-    private static _buildStructuralMetaDataNodes;
-    private static _buildNewStaffNode;
-    private static _buildNewTrackNode;
-    buildNoteEffects(note: Note): AlphaTexPropertyNode[];
-    buildBeatEffects(beat: Beat): AlphaTexPropertyNode[];
-}

package/dist/types/alphatab/src/importer/alphaTex/AlphaTex1MetaDataReader.d.ts

@@ -1,42 +0,0 @@
-import { type AlphaTexSignatureDefinition } from "./AlphaTex1LanguageDefinitions";
-import { type AlphaTexArgumentList, type AlphaTexMetaDataTagNode, type AlphaTexNumberLiteral, type AlphaTexPropertyNode, type IAlphaTexArgumentValue, type IAlphaTexAstNode } from "./AlphaTexAst";
-import { type AlphaTexParser } from "./AlphaTexParser";
-import type { IAlphaTexMetaDataReader } from "./IAlphaTexMetaDataReader";
-/**
- * @internal
- * @record
- */
-export interface SignatureResolutionInfo {
-    signature: AlphaTexSignatureDefinition;
-    parameterIndex: number;
-    parameterHasValues: boolean;
-    parameterValueMatches: number;
-}
-/**
- * @internal
- */
-export declare class AlphaTex1MetaDataReader implements IAlphaTexMetaDataReader {
-    static readonly instance: AlphaTex1MetaDataReader;
-    private static readonly _argumentTypes;
-    readMetaDataArguments(parser: AlphaTexParser, metaData: AlphaTexMetaDataTagNode): AlphaTexArgumentList | undefined;
-    readMetaDataPropertyArguments(parser: AlphaTexParser, metaData: AlphaTexMetaDataTagNode, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
-    readBeatPropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
-    readDurationChangePropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
-    readNotePropertyArguments(parser: AlphaTexParser, property: AlphaTexPropertyNode): AlphaTexArgumentList | undefined;
-    private _readPropertyArguments;
-    private _readArguments;
-    private _validateArguments;
-    private _createArgumentList;
-    private _filterCandidates;
-    static sortCandidates(allCandidates: [number, SignatureResolutionInfo][]): void;
-    private _skipRemainingArguments;
-    private static _hasExactMatch;
-    static filterIncompleteCandidates(candidates: Map<number, SignatureResolutionInfo>): void;
-    static generateSignaturesFromArguments(args: IAlphaTexArgumentValue[] | undefined): string;
-    static generateSignatures(signatures: AlphaTexSignatureDefinition[], ambiguousOverloads?: Set<number>): string;
-    private static _generateSignature;
-    private static _generateSignatureParameter;
-    static filterSignatureCandidates(candidates: Map<number, SignatureResolutionInfo>, value: IAlphaTexAstNode, valueCanBeEndOfList: boolean, trackValue: (value: IAlphaTexAstNode, signature: number) => void, extendToFloat?: (value: AlphaTexNumberLiteral) => void): boolean;
-    private static _checkArgumentMatch;
-    private static _isValueListMatch;
-}