@coderline/alphatab-language-server 1.7.0-alpha.1626

package/dist/types/alphatab/src/platform/javascript/AudioElementBackingTrackSynthOutput.d.ts

@@ -0,0 +1,49 @@
+import { type IEventEmitter, type IEventEmitterOfT } from "./../../EventEmitter";
+import type { BackingTrack } from "./../../model/BackingTrack";
+import type { IBackingTrackSynthOutput } from "./../../synth/BackingTrackPlayer";
+import type { ISynthOutputDevice } from "./../../synth/ISynthOutput";
+/**
+ * A {@link IBackingTrackSynthOutput} which uses a HTMLAudioElement as playback mechanism.
+ * Allows the access to the element for further custom usage.
+ * @target web
+ * @public
+ */
+export interface IAudioElementBackingTrackSynthOutput extends IBackingTrackSynthOutput {
+    /**
+     * The audio element used for playing the backing track.
+     * @remarks
+     * Direct interaction with the element might not result in correct alphaTab behavior.
+     */
+    readonly audioElement: HTMLAudioElement;
+}
+/**
+ * @target web
+ * @internal
+ */
+export declare class AudioElementBackingTrackSynthOutput implements IAudioElementBackingTrackSynthOutput {
+    readonly sampleRate: number;
+    audioElement: HTMLAudioElement;
+    private _updateInterval;
+    get backingTrackDuration(): number;
+    get playbackRate(): number;
+    set playbackRate(value: number);
+    get masterVolume(): number;
+    set masterVolume(value: number);
+    seekTo(time: number): void;
+    loadBackingTrack(backingTrack: BackingTrack): void;
+    open(_bufferTimeInMilliseconds: number): void;
+    private _updatePosition;
+    play(): void;
+    destroy(): void;
+    pause(): void;
+    addSamples(_samples: Float32Array): void;
+    resetSamples(): void;
+    activate(): void;
+    readonly ready: IEventEmitter;
+    readonly samplesPlayed: IEventEmitterOfT<number>;
+    readonly timeUpdate: IEventEmitterOfT<number>;
+    readonly sampleRequest: IEventEmitter;
+    enumerateOutputDevices(): Promise<ISynthOutputDevice[]>;
+    setOutputDevice(device: ISynthOutputDevice | null): Promise<void>;
+    getOutputDevice(): Promise<ISynthOutputDevice | null>;
+}

package/dist/types/alphatab/src/platform/javascript/BrowserMouseEventArgs.d.ts

@@ -0,0 +1,14 @@
+import type { IContainer } from "./../IContainer";
+import type { IMouseEventArgs } from "./../IMouseEventArgs";
+/**
+ * @target web
+ * @internal
+ */
+export declare class BrowserMouseEventArgs implements IMouseEventArgs {
+    readonly mouseEvent: MouseEvent;
+    get isLeftMouseButton(): boolean;
+    getX(relativeTo: IContainer): number;
+    getY(relativeTo: IContainer): number;
+    preventDefault(): void;
+    constructor(e: MouseEvent);
+}

package/dist/types/alphatab/src/platform/javascript/BrowserUiFacade.d.ts

@@ -0,0 +1,96 @@
+import type { AlphaTabApiBase } from "./../../AlphaTabApiBase";
+import type { IAlphaSynth } from "./../../synth/IAlphaSynth";
+import { type IEventEmitter } from "./../../EventEmitter";
+import { Score } from "./../../model/Score";
+import type { IContainer } from "./../IContainer";
+import type { IScoreRenderer } from "./../../rendering/IScoreRenderer";
+import type { RenderFinishedEventArgs } from "./../../rendering/RenderFinishedEventArgs";
+import { Bounds } from "./../../rendering/utils/Bounds";
+import { Settings } from "./../../Settings";
+import type { IMouseEventArgs } from "./../IMouseEventArgs";
+import type { IUiFacade } from "./../IUiFacade";
+import { Cursors } from "./../Cursors";
+import { ScalableHtmlElementContainer } from "./ScalableHtmlElementContainer";
+import type { SettingsJson } from "./../../generated/SettingsJson";
+import type { IAudioExporterWorker } from "./../../synth/IAudioExporter";
+/**
+ * @target web
+ * @internal
+ */
+export declare class BrowserUiFacade implements IUiFacade<unknown> {
+    private _fontCheckers;
+    private _api;
+    private _contents;
+    private _file;
+    private _totalResultCount;
+    private _initialTrackIndexes;
+    private _intersectionObserver;
+    private _barToElementLookup;
+    private _resultIdToElementLookup;
+    private _webFont;
+    rootContainerBecameVisible: IEventEmitter;
+    canRenderChanged: IEventEmitter;
+    get resizeThrottle(): number;
+    rootContainer: IContainer;
+    areWorkersSupported: boolean;
+    get canRender(): boolean;
+    private _areAllFontsLoaded;
+    private _onFontLoaded;
+    constructor(rootElement: HTMLElement);
+    private _onElementVisibilityChanged;
+    createWorkerRenderer(): IScoreRenderer;
+    initialize(api: AlphaTabApiBase<unknown>, raw: SettingsJson | Settings): void;
+    private _setupFontCheckers;
+    private _registerFontChecker;
+    destroy(): void;
+    createCanvasElement(): IContainer;
+    triggerEvent(container: IContainer, name: string, details?: unknown, originalEvent?: IMouseEventArgs): void;
+    load(data: unknown, success: (score: Score) => void, error: (error: Error) => void): boolean;
+    loadSoundFont(data: unknown, append: boolean): boolean;
+    initialRender(): void;
+    private _createStyleElements;
+    private static _cssFormat;
+    private static _registeredWebFonts;
+    /**
+     * cyrb53 (c) 2018 bryc (github.com/bryc)
+     * License: Public domain (or MIT if needed). Attribution appreciated.
+     * A fast and simple 53-bit string hash function with decent collision resistance.
+     * Largely inspired by MurmurHash2/3, but with a focus on speed/simplicity
+     * @param str
+     * @param seed
+     * @returns
+     */
+    private static _cyrb53;
+    /**
+     * Creates the default CSS styles used across all alphaTab instances.
+     * @target web
+     * @internal
+     */
+    static createSharedStyleElement(root: Document): void;
+    parseTracks(tracksData: unknown): number[];
+    private _getDataAttributes;
+    beginUpdateRenderResults(renderResult: RenderFinishedEventArgs): void;
+    beginAppendRenderResults(renderResult: RenderFinishedEventArgs | null): void;
+    /**
+     * This method creates the player. It detects browser compatibility and
+     * initializes a alphaSynth version for the client.
+     */
+    createWorkerPlayer(): IAlphaSynth | null;
+    createWorkerAudioExporter(synth: IAlphaSynth | null): IAudioExporterWorker;
+    beginInvoke(action: () => void): void;
+    private _highlightedElements;
+    highlightElements(groupId: string, masterBarIndex: number): void;
+    removeHighlights(): void;
+    destroyCursors(): void;
+    createCursors(): Cursors | null;
+    getOffset(scrollContainer: IContainer | null, container: IContainer): Bounds;
+    private _scrollContainer;
+    getScrollContainer(): IContainer;
+    createSelectionElement(): IContainer | null;
+    createScalingElement(): ScalableHtmlElementContainer;
+    scrollToY(element: IContainer, scrollTargetY: number, speed: number): void;
+    scrollToX(element: IContainer, scrollTargetY: number, speed: number): void;
+    private _internalScrollToY;
+    private _internalScrollToX;
+    createBackingTrackPlayer(): IAlphaSynth | null;
+}

package/dist/types/alphatab/src/platform/javascript/Html5Canvas.d.ts

@@ -0,0 +1,57 @@
+import { Color } from "./../../model/Color";
+import { Font } from "./../../model/Font";
+import { MusicFontSymbol } from "./../../model/MusicFontSymbol";
+import { type ICanvas, TextAlign, TextBaseline, MeasuredText } from "./../ICanvas";
+import type { Settings } from "./../../Settings";
+/**
+ * A canvas implementation for HTML5 canvas
+ * @target web
+ * @internal
+ */
+export declare class Html5Canvas implements ICanvas {
+    private _measureCanvas;
+    private _measureContext;
+    private _canvas;
+    private _context;
+    private _color;
+    private _font;
+    private _musicFont?;
+    private _lineWidth;
+    settings: Settings;
+    constructor();
+    destroy(): void;
+    onRenderFinished(): unknown;
+    beginRender(width: number, height: number): void;
+    endRender(): unknown;
+    get color(): Color;
+    set color(value: Color);
+    get lineWidth(): number;
+    set lineWidth(value: number);
+    fillRect(x: number, y: number, w: number, h: number): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    fillCircle(x: number, y: number, radius: number): void;
+    strokeCircle(x: number, y: number, radius: number): void;
+    fill(): void;
+    stroke(): void;
+    get font(): Font;
+    set font(value: Font);
+    get textAlign(): TextAlign;
+    set textAlign(value: TextAlign);
+    get textBaseline(): TextBaseline;
+    set textBaseline(value: TextBaseline);
+    beginGroup(_: string): void;
+    endGroup(): void;
+    fillText(text: string, x: number, y: number): void;
+    measureText(text: string): MeasuredText;
+    fillMusicFontSymbol(x: number, y: number, relativeScale: number, symbol: MusicFontSymbol, centerAtPosition?: boolean): void;
+    fillMusicFontSymbols(x: number, y: number, relativeScale: number, symbols: MusicFontSymbol[], centerAtPosition?: boolean): void;
+    private _fillMusicFontSymbolText;
+    beginRotate(centerX: number, centerY: number, angle: number): void;
+    endRotate(): void;
+}

package/dist/types/alphatab/src/platform/javascript/HtmlElementContainer.d.ts

@@ -0,0 +1,45 @@
+import type { IEventEmitter, IEventEmitterOfT } from "./../../EventEmitter";
+import type { IContainer } from "./../IContainer";
+import type { IMouseEventArgs } from "./../IMouseEventArgs";
+import { Bounds } from "./../../rendering/utils/Bounds";
+/**
+ * @target web
+ * @internal
+ */
+export declare class HtmlElementContainer implements IContainer {
+    private static _resizeObserver;
+    private _resizeListeners;
+    get width(): number;
+    set width(value: number);
+    get scrollLeft(): number;
+    set scrollLeft(value: number);
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    get height(): number;
+    set height(value: number);
+    get isVisible(): boolean;
+    readonly element: HTMLElement;
+    constructor(element: HTMLElement);
+    stopAnimation(): void;
+    transitionToX(duration: number, x: number): void;
+    protected lastBounds: Bounds;
+    setBounds(x: number, y: number, w: number, h: number): void;
+    /**
+     * This event occurs when the control was resized.
+     */
+    resize: IEventEmitter;
+    /**
+     * This event occurs when a mouse/finger press happened on the control.
+     */
+    mouseDown: IEventEmitterOfT<IMouseEventArgs>;
+    /**
+     * This event occurs when a mouse/finger moves on top of the control.
+     */
+    mouseMove: IEventEmitterOfT<IMouseEventArgs>;
+    /**
+     * This event occurs when a mouse/finger is released from the control.
+     */
+    mouseUp: IEventEmitterOfT<IMouseEventArgs>;
+    appendChild(child: IContainer): void;
+    clear(): void;
+}

package/dist/types/alphatab/src/platform/javascript/IWorkerScope.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @target web
+ * @internal
+ */
+export interface IWorkerScope {
+    addEventListener(eventType: string, listener: (e: MessageEvent) => void, capture?: boolean): void;
+    postMessage(message: unknown): void;
+}

package/dist/types/alphatab/src/platform/javascript/IntersectionObserverPolyfill.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A polyfill of the InsersectionObserver
+ * @target web
+ * @internal
+ */
+export declare class IntersectionObserverPolyfill {
+    private _callback;
+    private _elements;
+    private _timer;
+    constructor(callback: IntersectionObserverCallback);
+    private _check;
+    observe(target: HTMLElement): void;
+    unobserve(target: HTMLElement): void;
+    private _doCheck;
+}

package/dist/types/alphatab/src/platform/javascript/JQueryAlphaTab.d.ts

@@ -0,0 +1,68 @@
+import type { IAlphaSynth } from "./../../synth/IAlphaSynth";
+import type { PlayerState } from "./../../synth/PlayerState";
+import type { Score } from "./../../model/Score";
+import type { Track } from "./../../model/Track";
+import { AlphaTabApi } from "./AlphaTabApi";
+import type { IScoreRenderer } from "./../../rendering/IScoreRenderer";
+import type { Settings } from "./../../Settings";
+import type { MidiEventType } from "./../../midi/MidiEvent";
+/**
+ * @target web
+ * @internal
+ */
+declare class jQuery extends Array<HTMLElement> {
+    constructor(v?: any);
+    readonly context: HTMLElement;
+    readonly length: number;
+    data(key: string): unknown;
+    data(key: string, value: any): void;
+    removeData(key: string): void;
+    each(action: (i: number, x: HTMLElement) => void): void;
+    empty(): jQuery;
+}
+/**
+ * @target web
+ * @deprecated Migrate to {@link AlphaTabApi}.
+ * @internal
+ */
+export declare class JQueryAlphaTab {
+    exec(element: HTMLElement, method: string, args: any[]): unknown;
+    init(element: jQuery, context: AlphaTabApi, options: any): void;
+    destroy(element: jQuery, context: AlphaTabApi): void;
+    print(_element: jQuery, context: AlphaTabApi, width: string, additionalSettings?: unknown): void;
+    load(_element: jQuery, context: AlphaTabApi, data: unknown, tracks?: number[]): boolean;
+    render(_element: jQuery, context: AlphaTabApi): void;
+    renderScore(_element: jQuery, context: AlphaTabApi, score: Score, tracks?: number[]): void;
+    renderTracks(_element: jQuery, context: AlphaTabApi, tracks: Track[]): void;
+    invalidate(_element: jQuery, context: AlphaTabApi): void;
+    tex(_element: jQuery, context: AlphaTabApi, tex: string, tracks: number[]): void;
+    muteTrack(_element: jQuery, context: AlphaTabApi, tracks: Track[], mute: boolean): void;
+    soloTrack(_element: jQuery, context: AlphaTabApi, tracks: Track[], solo: boolean): void;
+    trackVolume(_element: jQuery, context: AlphaTabApi, tracks: Track[], volume: number): void;
+    loadSoundFont(_element: jQuery, context: AlphaTabApi, value: unknown, append: boolean): void;
+    resetSoundFonts(_element: jQuery, context: AlphaTabApi): void;
+    pause(_element: jQuery, context: AlphaTabApi): void;
+    play(_element: jQuery, context: AlphaTabApi): boolean;
+    playPause(_element: jQuery, context: AlphaTabApi): void;
+    stop(_element: jQuery, context: AlphaTabApi): void;
+    api(_element: jQuery, context: AlphaTabApi): AlphaTabApi;
+    player(_element: jQuery, context: AlphaTabApi): IAlphaSynth | null;
+    isReadyForPlayback(_element: jQuery, context: AlphaTabApi): boolean;
+    playerState(_element: jQuery, context: AlphaTabApi): PlayerState;
+    masterVolume(_element: jQuery, context: AlphaTabApi, masterVolume?: number): number;
+    metronomeVolume(_element: jQuery, context: AlphaTabApi, metronomeVolume?: number): number;
+    countInVolume(_element: jQuery, context: AlphaTabApi, countInVolume?: number): number;
+    midiEventsPlayedFilter(_element: jQuery, context: AlphaTabApi, midiEventsPlayedFilter?: MidiEventType[]): MidiEventType[];
+    playbackSpeed(_element: jQuery, context: AlphaTabApi, playbackSpeed?: number): number;
+    tickPosition(_element: jQuery, context: AlphaTabApi, tickPosition?: number): number;
+    timePosition(_element: jQuery, context: AlphaTabApi, timePosition?: number): number;
+    loop(_element: jQuery, context: AlphaTabApi, loop?: boolean): boolean;
+    renderer(_element: jQuery, context: AlphaTabApi): IScoreRenderer;
+    score(_element: jQuery, context: AlphaTabApi): Score | null;
+    settings(_element: jQuery, context: AlphaTabApi): Settings;
+    tracks(_element: jQuery, context: AlphaTabApi): Track[];
+    private _initListeners;
+    _oninit(listener: (jq: jQuery, api: AlphaTabApi, params: any[]) => void): void;
+    static restore(selector: string): void;
+}
+export {};

package/dist/types/alphatab/src/platform/javascript/ResizeObserverPolyfill.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A very basic polyfill of the ResizeObserver which triggers
+ * a the callback on window resize for all registered targets.
+ * @target web
+ * @internal
+ */
+export declare class ResizeObserverPolyfill {
+    private _callback;
+    private _targets;
+    constructor(callback: ResizeObserverCallback);
+    observe(target: Element): void;
+    unobserve(target: Element): void;
+    disconnect(): void;
+    private _onWindowResize;
+}

package/dist/types/alphatab/src/platform/javascript/ScalableHtmlElementContainer.d.ts

@@ -0,0 +1,26 @@
+import { HtmlElementContainer } from "./HtmlElementContainer";
+/**
+ * An IContainer implementation which can be used for cursors and select ranges
+ * where browser scaling is relevant.
+ *
+ * The problem is that with having 1x1 pixel elements which are sized then to the actual size with a
+ * scale transform this cannot be combined properly with a browser zoom.
+ *
+ * The browser will apply first the browser zoom to the 1x1px element and then apply the scale leaving it always
+ * at full scale instead of a 50% browser zoom.
+ *
+ * This is solved in this container by scaling the element first up to a higher degree (as specified)
+ * so that the browser can do a scaling according to typical zoom levels and then the scaling will work.
+ * @target web
+ * @internal
+ */
+export declare class ScalableHtmlElementContainer extends HtmlElementContainer {
+    private _xscale;
+    private _yscale;
+    constructor(element: HTMLElement, xscale: number, yscale: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    setBounds(x: number, y: number, w: number, h: number): void;
+}

package/dist/types/alphatab/src/platform/javascript/WebPlatform.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lists all web specific platforms alphaTab might run in
+ * like browser, nodejs.
+ * @public
+ */
+export declare enum WebPlatform {
+    Browser = 0,
+    NodeJs = 1,
+    BrowserModule = 2
+}

package/dist/types/alphatab/src/platform/skia/SkiaCanvas.d.ts

@@ -0,0 +1,86 @@
+import { Color } from "./../../model/Color";
+import { Font } from "./../../model/Font";
+import { MusicFontSymbol } from "./../../model/MusicFontSymbol";
+import { type ICanvas, TextAlign, TextBaseline, MeasuredText } from "./../ICanvas";
+import type { Settings } from "./../../Settings";
+import type * as alphaSkia from '@coderline/alphaskia';
+/**
+ * Describes the members of the alphaSkia module.
+ * @target web
+ * @internal
+ */
+export interface AlphaSkiaModule {
+    AlphaSkiaCanvas: typeof alphaSkia.AlphaSkiaCanvas;
+    AlphaSkiaImage: typeof alphaSkia.AlphaSkiaImage;
+    AlphaSkiaTextAlign: typeof alphaSkia.AlphaSkiaTextAlign;
+    AlphaSkiaTextBaseline: typeof alphaSkia.AlphaSkiaTextBaseline;
+    AlphaSkiaTypeface: typeof alphaSkia.AlphaSkiaTypeface;
+    AlphaSkiaTextStyle: typeof alphaSkia.AlphaSkiaTextStyle;
+    AlphaSkiaTextMetrics: typeof alphaSkia.AlphaSkiaTextMetrics;
+}
+/**
+ * A canvas implementation using alphaSkia as rendering backend
+ * @partial
+ * @internal
+ */
+export declare class SkiaCanvas implements ICanvas {
+    /**
+     * @target web
+     * @delegated csharp
+     * @delegated kotlin
+     */
+    private static _alphaSkia;
+    private static _defaultMusicTextStyle;
+    /**
+     * @target web
+     * @partial
+     */
+    static enable(musicFontData: ArrayBuffer, alphaSkia: unknown): void;
+    static initializeMusicFont(musicFont: alphaSkia.AlphaSkiaTypeface): void;
+    static registerFont(fontData: Uint8Array, fontInfo?: Font | undefined): Font;
+    private _canvas;
+    private _color;
+    private _lineWidth;
+    private _textStyle;
+    private _scale;
+    private _textStyles;
+    private _font;
+    private _musicTextStyle;
+    settings: Settings;
+    get font(): Font;
+    set font(value: Font);
+    private _textStyleKey;
+    constructor();
+    destroy(): void;
+    onRenderFinished(): unknown;
+    beginRender(width: number, height: number): void;
+    endRender(): unknown;
+    get color(): Color;
+    set color(value: Color);
+    get lineWidth(): number;
+    set lineWidth(value: number);
+    fillRect(x: number, y: number, w: number, h: number): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1X: number, cp1Y: number, cp2X: number, cp2Y: number, x: number, y: number): void;
+    fillCircle(x: number, y: number, radius: number): void;
+    strokeCircle(x: number, y: number, radius: number): void;
+    fill(): void;
+    stroke(): void;
+    textAlign: TextAlign;
+    textBaseline: TextBaseline;
+    beginGroup(_identifier: string): void;
+    endGroup(): void;
+    fillText(text: string, x: number, y: number): void;
+    measureText(text: string): MeasuredText;
+    private _getTextWidthAndHeight;
+    fillMusicFontSymbol(x: number, y: number, relativeScale: number, symbol: MusicFontSymbol, centerAtPosition?: boolean): void;
+    fillMusicFontSymbols(x: number, y: number, relativeScale: number, symbols: MusicFontSymbol[], centerAtPosition?: boolean): void;
+    private _fillMusicFontSymbolText;
+    beginRotate(centerX: number, centerY: number, angle: number): void;
+    endRotate(): void;
+}

package/dist/types/alphatab/src/platform/svg/CssFontSvgCanvas.d.ts

@@ -0,0 +1,11 @@
+import { SvgCanvas } from "./SvgCanvas";
+import { MusicFontSymbol } from "./../../model/MusicFontSymbol";
+/**
+ * This SVG canvas renders the music symbols by adding a CSS class 'at' to all elements.
+ * @internal
+ */
+export declare class CssFontSvgCanvas extends SvgCanvas {
+    fillMusicFontSymbol(x: number, y: number, relativeScale: number, symbol: MusicFontSymbol, centerAtPosition?: boolean): void;
+    fillMusicFontSymbols(x: number, y: number, relativeScale: number, symbols: MusicFontSymbol[], centerAtPosition?: boolean): void;
+    private _fillMusicFontSymbolText;
+}

package/dist/types/alphatab/src/platform/svg/FontSizes.d.ts

@@ -0,0 +1,32 @@
+import { FontStyle, FontWeight } from "./../../model/Font";
+import { MeasuredText } from "./../ICanvas";
+/**
+ * Describes the sizes of a font for measuring purposes.
+ * @internal
+ */
+export declare class FontSizeDefinition {
+    /**
+     * The widths of each character starting with the ascii code 0x20 at index 0.
+     */
+    characterWidths: Uint8Array;
+    /**
+     * The heights of each character starting with the ascii code 0x20 at index 0.
+     */
+    characterHeights: Uint8Array;
+    constructor(characterWidths: Uint8Array, characterHeights: Uint8Array);
+}
+/**
+ * This public class stores text widths for several fonts and allows width calculation
+ * @partial
+ * @internal
+ */
+export declare class FontSizes {
+    static readonly fontSizeLookupTables: Map<string, FontSizeDefinition>;
+    static readonly ControlChars: number;
+    /**
+     * @target web
+     * @partial
+     */
+    static generateFontLookup(family: string): void;
+    static measureString(s: string, families: string[], size: number, style: FontStyle, weight: FontWeight): MeasuredText;
+}

package/dist/types/alphatab/src/platform/svg/SvgCanvas.d.ts

@@ -0,0 +1,48 @@
+import { Color } from "./../../model/Color";
+import { Font } from "./../../model/Font";
+import { type ICanvas, TextAlign, TextBaseline, MeasuredText } from "./../ICanvas";
+import type { MusicFontSymbol } from "./../../model/MusicFontSymbol";
+import type { Settings } from "./../../Settings";
+/**
+ * A canvas implementation storing SVG data
+ * @internal
+ */
+export declare abstract class SvgCanvas implements ICanvas {
+    protected buffer: string;
+    private _currentPath;
+    private _currentPathIsEmpty;
+    scale: number;
+    color: Color;
+    lineWidth: number;
+    font: Font;
+    textAlign: TextAlign;
+    textBaseline: TextBaseline;
+    settings: Settings;
+    destroy(): void;
+    beginRender(width: number, height: number): void;
+    beginGroup(identifier: string): void;
+    endGroup(): void;
+    endRender(): unknown;
+    fillRect(x: number, y: number, w: number, h: number): void;
+    strokeRect(x: number, y: number, w: number, h: number): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1X: number, cp1Y: number, cp2X: number, cp2Y: number, x: number, y: number): void;
+    fillCircle(x: number, y: number, radius: number): void;
+    strokeCircle(x: number, y: number, radius: number): void;
+    fill(): void;
+    stroke(): void;
+    fillText(text: string, x: number, y: number): void;
+    private static _escapeText;
+    protected getSvgTextAlignment(textAlign: TextAlign): string;
+    protected getSvgBaseLine(): string;
+    measureText(text: string): MeasuredText;
+    abstract fillMusicFontSymbol(x: number, y: number, relativeScale: number, symbol: MusicFontSymbol, centerAtPosition?: boolean): void;
+    abstract fillMusicFontSymbols(x: number, y: number, relativeScale: number, symbols: MusicFontSymbol[], centerAtPosition?: boolean): void;
+    onRenderFinished(): unknown;
+    beginRotate(centerX: number, centerY: number, angle: number): void;
+    endRotate(): void;
+}