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

package/dist/types/alphatab/src/AlphaTabError.d.ts

@@ -1,15 +0,0 @@
-/**
- * @public
- */
-export declare enum AlphaTabErrorType {
-    General = 0,
-    Format = 1,
-    AlphaTex = 2
-}
-/**
- * @public
- */
-export declare class AlphaTabError extends Error {
-    type: AlphaTabErrorType;
-    constructor(type: AlphaTabErrorType, message?: string | null, inner?: Error);
-}

package/dist/types/alphatab/src/CoreSettings.d.ts

@@ -1,212 +0,0 @@
-import { LogLevel } from "./LogLevel";
-/**
- * Lists the known file formats for font files.
- * @target web
- * @public
- */
-export declare enum FontFileFormat {
-    /**
-     * .eot
-     */
-    EmbeddedOpenType = 0,
-    /**
-     * .woff
-     */
-    Woff = 1,
-    /**
-     * .woff2
-     */
-    Woff2 = 2,
-    /**
-     * .otf
-     */
-    OpenType = 3,
-    /**
-     * .ttf
-     */
-    TrueType = 4,
-    /**
-     * .svg
-     */
-    Svg = 5
-}
-/**
- * All main settings of alphaTab controlling rather general aspects of its behavior.
- * @json
- * @json_declaration
- * @public
- */
-export declare class CoreSettings {
-    /**
-     * The full URL to the alphaTab JavaScript file.
-     * @remarks
-     * AlphaTab needs to know the full URL to the script file it is contained in to launch the web workers. AlphaTab will do its best to auto-detect
-     * this path but in case it fails, this setting can be used to explicitly define it. Altenatively also a global variable `ALPHATAB_ROOT` can
-     * be defined before initializing. Please be aware that bundling alphaTab together with other scripts might cause errors
-     * in case those scripts are not suitable for web workers. e.g. if there is a script bundled together with alphaTab that accesses the DOM,
-     * this will cause an error when alphaTab starts this script as worker.
-     * @defaultValue Absolute url to JavaScript file containing alphaTab. (auto detected)
-     * @category Core - JavaScript Specific
-     * @target web
-     * @since 0.9.6
-     */
-    scriptFile: string | null;
-    /**
-     * The full URL to the alphaTab font directory.
-     * @remarks
-     * AlphaTab will generate some dynamic CSS that is needed for displaying the music symbols correctly. For this it needs to know
-     * where the Web Font files of [Bravura](https://github.com/steinbergmedia/bravura) are. Normally alphaTab expects
-     * them to be in a `font` subfolder beside the script file. If this is not the case, this setting must be used to configure the path.
-     * Alternatively also a global variable `ALPHATAB_FONT` can be set on the page before initializing alphaTab.
-     *
-     * Use {@link smuflFontSources} for more flexible font configuration.
-     * @defaultValue `"${AlphaTabScriptFolder}/font/"`
-     * @category Core - JavaScript Specific
-     * @target web
-     * @since 0.9.6
-     */
-    fontDirectory: string | null;
-    /**
-     * Defines the URLs from which to load the SMuFL compliant font files.
-     * @remarks
-     * These sources will be used to load and register the webfonts on the page so
-     * they are available for rendering the music sheet. The sources can be set to any
-     * CSS compatible URL which can be passed into `url()`.
-     * See https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face/src#url
-     *
-     * If you customize the SmuFL font used in alphaTab, you will also need to provide
-     * the respective SMuFL Metadata information to alphaTab.
-     * Set the metadata via {@link EngravingSettings.fillFromSmufl} on the rendering resources.
-     *
-     * @defaultValue Bravura files located at {@link fontDirectory} .
-     * @category Core - JavaScript Specific
-     * @target web
-     * @since 1.6.0
-     */
-    smuflFontSources: Map<FontFileFormat, string> | null;
-    /**
-     * Builds the default SMuFL font sources for the usage with alphaTab in cases
-     * where no custom {@link smuflFontSources} are provided.
-     * @param fontDirectory The {@link CoreSettings.fontDirectory} configured.
-     * @target web
-     */
-    static buildDefaultSmuflFontSources(fontDirectory: string | null): Map<FontFileFormat, string>;
-    /**
-     * The full URL to the input file to be loaded.
-     * @remarks
-     * AlphaTab can automatically load and render a file after initialization. This eliminates the need of manually calling
-     * one of the load methods which are available. alphaTab will automatically initiate an `XMLHttpRequest` after initialization
-     * to load and display the provided url of this setting. Note that this setting is only interpreted once on initialization.
-     * @defaultValue `null`
-     * @category Core - JavaScript Specific
-     * @target web
-     * @since 0.9.6
-     */
-    file: string | null;
-    /**
-     * Whether the contents of the DOM element should be loaded as alphaTex.
-     * @target web
-     * @remarks
-     * This setting allows you to fill alphaTex code into the DOM element and make alphaTab automatically
-     * load it when initializing. Note that this setting is only interpreted once on initialization.
-     * @defaultValue `false`
-     * @category Core - JavaScript Specific
-     * @since 0.9.6
-     * @example
-     * JavaScript
-     * ```html
-     * <div id="alphaTab">\title "Simple alphaTex init" . 3.3*4</div>
-     * <script>
-     * const api = new alphaTab.AlphaTabApi(document.getElementById('alphaTab'), { core: { tex: true }});
-     * </script>
-     * ```
-     */
-    tex: boolean;
-    /**
-     * The tracks to display for the initally loaded file.
-     * @json_raw
-     * @remarks
-     * This setting can be used in combinition with the {@link file} or {@link tex} option. It controls which of the tracks
-     * of the initially loaded file should be displayed.
-     * @defaultValue `null`
-     * @category Core - JavaScript Specific
-     * @target web
-     * @since 0.9.6
-     */
-    tracks: number | number[] | 'all' | null;
-    /**
-     * Enables lazy loading of the rendered music sheet chunks.
-     * @remarks
-     * AlphaTab renders the music sheet in smaller sub-chunks to have fast UI feedback. Not all of those sub-chunks are immediately
-     * appended to the DOM due to performance reasons. AlphaTab tries to detect which elements are visible on the screen, and only
-     * appends those elements to the DOM. This reduces the load of the browser heavily but is not working for all layouts and use cases.
-     * This setting set to false, ensures that all rendered items are instantly appended to the DOM.
-     * The lazy rendering of partial might not be available on all platforms.
-     * @defaultValue `true`
-     * @category Core
-     * @since 0.9.6
-     */
-    enableLazyLoading: boolean;
-    /**
-     * The engine which should be used to render the the tablature.
-     * @remarks
-     * AlphaTab can use various render engines to draw the music notation. The available render engines is specific to the platform. Please refer to the table below to find out which engines are available on which platform.
-     * - `default`- Platform specific default engine
-     * - `html5`- Uses HTML5 canvas elements to render the music notation (browser only)
-     * - `svg`- Outputs SVG strings (all platforms, default for web)
-     * - `skia` - Uses [Skia](https://skia.org/) for rendering (all non-browser platforms via [alphaSkia](https://github.com/CoderLine/alphaSkia), default for non-web)
-     * - `gdi` - Uses [GDI+](https://docs.microsoft.com/en-us/dotnet/framework/winforms/advanced/graphics-and-drawing-in-windows-forms) for rendering (only on .net)
-     * - `android` - Uses [android.graphics.Canvas](https://developer.android.com/reference/android/graphics/Canvas) for rendering (only on Android)
-     * @defaultValue `"default"`
-     * @category Core
-     * @since 0.9.6
-     */
-    engine: string;
-    /**
-     * The log level to use within alphaTab
-     * @remarks
-     * AlphaTab internally does quite a bit of logging for debugging and informational purposes. The log level of alphaTab can be controlled via this setting.
-     * @defaultValue `LogLevel.Info`
-     * @category Core
-     * @since 0.9.6
-     */
-    logLevel: LogLevel;
-    /**
-     * Whether the rendering should be done in a worker if possible.
-     * @remarks
-     * AlphaTab normally tries to render the music sheet asynchronously in a worker. This reduces the load on the UI side and avoids hanging. However sometimes it might be more desirable to have
-     * a synchronous rendering behavior. This setting can be set to false to synchronously render the music sheet on the UI side.
-     * @defaultValue `true`
-     * @category Core
-     * @since 0.9.6
-     */
-    useWorkers: boolean;
-    /**
-     * Whether in the {@link BoundsLookup} also the position and area of each individual note is provided.
-     * @remarks
-     * AlphaTab collects the position of the rendered music notation elements during the rendering process. This way some level of interactivity can be provided like the feature that seeks to the corresponding position when clicking on a beat.
-     * By default the position of the individual notes is not collected due to performance reasons. If access to note position information is needed, this setting can enable it.
-     * @defaultValue `false`
-     * @category Core
-     * @since 0.9.6
-     * @example
-     * JavaScript
-     * ```js
-     * const settings = new alphaTab.model.Settings();
-     * settings.core.includeNoteBounds = true;
-     * const api = new alphaTab.AlphaTabApi(document.querySelector('#alphaTab'), settings);
-     * api.renderFinished.on(() => {
-     *     const lookup = api.renderer.boundsLookup;
-     *     const x = 100;
-     *     const y = 100;
-     *     const beat = lookup.getBeatAtPos(x, y);
-     *     const note = lookup.getNoteAtPos(beat, x, y);
-     * });
-     * ```
-     */
-    includeNoteBounds: boolean;
-    /**
-     * @target web
-     */
-    constructor();
-}

package/dist/types/alphatab/src/DisplaySettings.d.ts

@@ -1,340 +0,0 @@
-import { RenderingResources } from "./RenderingResources";
-import { LayoutMode } from "./LayoutMode";
-import { StaveProfile } from "./StaveProfile";
-/**
- * Lists the different modes in which the staves and systems are arranged.
- * @public
- */
-export declare enum SystemsLayoutMode {
-    /**
-     * Use the automatic alignment system provided by alphaTab (default)
-     */
-    Automatic = 0,
-    /**
-     * Use the systems layout and sizing information stored from the score model.
-     */
-    UseModelLayout = 1
-}
-/**
- * The display settings control how the general layout and display of alphaTab is done.
- * @json
- * @json_declaration
- * @public
- */
-export declare class DisplaySettings {
-    /**
-     * The zoom level of the rendered notation.
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `1.0`
-     * @remarks
-     * AlphaTab can scale up or down the rendered music notation for more optimized display scenarios. By default music notation is rendered at 100% scale (value 1) and can be scaled up or down by
-     * percental values.
-     */
-    scale: number;
-    /**
-     * The default stretch force to use for layouting.
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `1`
-     * @remarks
-     * The stretch force is a setting that controls the spacing of the music notation. AlphaTab uses a varaint of the Gourlay algorithm for spacing which has springs and rods for
-     * aligning elements. This setting controls the "strength" of the springs. The stronger the springs, the wider the spacing.
-     *
-     * | Force 1                                                      | Force 0.5                                             |
-     * |--------------------------------------------------------------|-------------------------------------------------------|
-     * | ![Default](https://alphatab.net/img/reference/property/stretchforce-default.png) | ![0.5](https://alphatab.net/img/reference/property/stretchforce-half.png) |
-     */
-    stretchForce: number;
-    /**
-     * The layouting mode used to arrange the the notation.
-     * @remarks
-     * AlphaTab has various layout engines that arrange the rendered bars differently. This setting controls which layout mode is used.
-     *
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `LayoutMode.Page`
-     */
-    layoutMode: LayoutMode;
-    /**
-     * The stave profile defining which staves are shown for the music sheet.
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `StaveProfile.Default`
-     * @remarks
-     * AlphaTab has various stave profiles that define which staves will be shown in for the rendered tracks. Its recommended
-     * to keep this on {@link StaveProfile.Default} and rather rely on the options available ob {@link Staff} level
-     */
-    staveProfile: StaveProfile;
-    /**
-     * Limit the displayed bars per system (row). (-1 for automatic mode)
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `-1`
-     * @remarks
-     * This setting sets the number of bars that should be put into one row during layouting. This setting is only respected
-     * when using the {@link LayoutMode.Page} where bars are aligned in systems. [Demo](https://alphatab.net/docs/showcase/layouts#page-layout-5-bars-per-row).
-     */
-    barsPerRow: number;
-    /**
-     * The bar start index to start layouting with.
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `1`
-     * @remarks
-     * This setting sets the index of the first bar that should be rendered from the overall song. This setting can be used to
-     * achieve a paging system or to only show partial bars of the same file. By this a tutorial alike display can be achieved
-     * that explains various parts of the song. Please note that this is the bar number as shown in the music sheet (1-based) not the array index (0-based).
-     * [Demo](https://alphatab.net/docs/showcase/layouts#page-layout-bar-5-to-8)
-     */
-    startBar: number;
-    /**
-     * The total number of bars that should be rendered from the song. (-1 for all bars)
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `-1`
-     * @remarks
-     * This setting sets the number of bars that should be rendered from the overall song. This setting can be used to
-     * achieve a paging system or to only show partial bars of the same file. By this a tutorial alike display can be achieved
-     * that explains various parts of the song. [Demo](https://alphatab.net/docs/showcase/layouts)
-     */
-    barCount: number;
-    /**
-     * The number of bars that should be placed within one partial render.
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `10`
-     * @remarks
-     * AlphaTab renders the whole music sheet in smaller chunks named "partials". This is to reduce the risk of
-     * encountering browser performance restrictions and it gives faster visual feedback to the user. This
-     * setting controls how many bars are placed within such a partial.
-     */
-    barCountPerPartial: number;
-    /**
-     * Whether to justify also the last system in page layouts.
-     * @remarks
-     * Setting this option to `true` tells alphaTab to also justify the last system (row) like it
-     * already does for the systems which are full.
-     * | Justification Disabled                                       | Justification Enabled                                |
-     * |--------------------------------------------------------------|-------------------------------------------------------|
-     * | ![Disabled](https://alphatab.net/img/reference/property/justify-last-system-false.png) | ![Enabled](https://alphatab.net/img/reference/property/justify-last-system-true.png) |
-     * @since 1.3.0
-     * @category Display
-     * @defaultValue `false`
-     */
-    justifyLastSystem: boolean;
-    /**
-     * Allows adjusting of the used fonts and colors for rendering.
-     * @json_partial_names
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `false`
-     * @domWildcard
-     * @remarks
-     * AlphaTab allows configuring the colors and fonts used for rendering via the rendering resources settings. Please note that as of today
-     * this is the primary way of changing the way how alphaTab styles elements. CSS styling in the browser cannot be guaranteed to work due to its flexibility.
-     *
-     *
-     * Due to space reasons in the following table the common prefix of the settings are removed. Please refer to these examples to eliminate confusion on the usage:
-     *
-     * | Platform   | Prefix                    | Example Usage                                                      |
-     * |------------|---------------------------|--------------------------------------------------------------------|
-     * | JavaScript | `display.resources.`      | `settings.display.resources.wordsFont = ...`                       |
-     * | JSON       | `display.resources.`      | `var settings = { display: { resources: { wordsFonts: '...'} } };` |
-     * | JSON       | `resources.`              | `var settings = { resources: { wordsFonts: '...'} };`              |
-     * | .net       | `Display.Resources.`      | `settings.Display.Resources.WordsFonts = ...`                      |
-     * | Android    | `display.resources.`      | `settings.display.resources.wordsFonts = ...`                      |
-     * ## Types
-     *
-     * ### Fonts
-     *
-     * For the JavaScript platform any font that might be installed on the client machines can be used.
-     * Any additional fonts can be added via WebFonts. The rendering of the score will be delayed until it is detected that the font was loaded.
-     * Simply use any CSS font property compliant string as configuration. Relative font sizes with percentual values are not supported, remaining values will be considered if supported.
-     *
-     * {@since 1.2.3} Multiple fonts are also supported for the Web version. alphaTab will check if any of the fonts in the list is loaded instead of all. If none is available at the time alphaTab is initialized, it will try to initiate the load of the specified fonts individual through the Browser Font APIs.
-     *
-     * For the .net platform any installed font on the system can be used. Simply construct the `Font` object to configure your desired fonts.
-     *
-     * ### Colors
-     *
-     * For JavaScript you can use any CSS font property compliant string. (#RGB, #RGBA, #RRGGBB, #RRGGBBAA, rgb(r,g,b), rgba(r,g,b,a) )
-     *
-     * On .net simply construct the `Color` object to configure your desired color.
-     */
-    resources: RenderingResources;
-    /**
-     * Adjusts the padding between the music notation and the border.
-     * @remarks
-     * Adjusts the padding between the music notation and the outer border of the container element.
-     * The array is either:
-     * * 2 elements: `[left-right, top-bottom]`
-     * * 4 elements: ``[left, top, right, bottom]``
-     * @since 0.9.6
-     * @category Display
-     * @defaultValue `[35, 35]`
-     */
-    padding: number[];
-    /**
-     * The top padding applied to first system.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `5`
-     */
-    firstSystemPaddingTop: number;
-    /**
-     * The top padding applied systems beside the first one.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `10`
-     */
-    systemPaddingTop: number;
-    /**
-     * The bottom padding applied to systems beside the last one.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `20`
-     */
-    systemPaddingBottom: number;
-    /**
-     * The bottom padding applied to the last system.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `0`
-     */
-    lastSystemPaddingBottom: number;
-    /**
-     * The padding left to the track name label of the system.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `0`
-     */
-    systemLabelPaddingLeft: number;
-    /**
-     * The padding left to the track name label of the system.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `3`
-     */
-    systemLabelPaddingRight: number;
-    /**
-     * The padding between the accolade bar and the start of the bar itself.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `3`
-     */
-    accoladeBarPaddingRight: number;
-    /**
-     * The bottom padding applied to main notation staves (standard, tabs, numbered, slash).
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `5`
-     */
-    notationStaffPaddingTop: number;
-    /**
-     * The bottom padding applied to main notation staves (standard, tabs, numbered, slash).
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `5`
-     */
-    notationStaffPaddingBottom: number;
-    /**
-     * The top padding applied to effect annotation staffs.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `0`
-     */
-    effectStaffPaddingTop: number;
-    /**
-     * The bottom padding applied to effect annotation staffs.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `0`
-     */
-    effectStaffPaddingBottom: number;
-    /**
-     * The left padding applied between the left line and the first glyph in the first staff in a system.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `6`
-     */
-    firstStaffPaddingLeft: number;
-    /**
-     * The left padding applied between the left line and the first glyph in the following staff in a system.
-     * @since 1.4.0
-     * @category Display
-     * @defaultValue `2`
-     */
-    staffPaddingLeft: number;
-    /**
-     * The padding between individual effect bands.
-     * @since 1.7.0
-     * @category Display
-     * @defaultValue `2`
-     */
-    effectBandPaddingBottom: number;
-    /**
-     * The mode used to arrange staves and systems.
-     * @since 1.3.0
-     * @category Display
-     * @defaultValue `1`
-     * @remarks
-     * By default alphaTab uses an own (automatic) mode to arrange and scale the bars when
-     * putting them into staves. This property allows changing this mode to change the music sheet arrangement.
-     *
-     * ## Supported File Formats:
-     * * Guitar Pro 6-8 {@since 1.3.0}
-     * If you want/need support for more file formats to respect the sizing information feel free to [open a discussion](https://github.com/CoderLine/alphaTab/discussions/new?category=ideas) on GitHub.
-     *
-     * ## Automatic Mode
-     *
-     * In the automatic mode alphaTab arranges the bars and staves using its internal mechanisms.
-     *
-     * For the `page` layout this means it will scale the bars according to the `stretchForce` and available width.
-     * Wrapping into new systems (rows) will happen when the row is considered "full".
-     *
-     * For the `horizontal` layout the `stretchForce` defines the sizing and no wrapping happens at all.
-     *
-     * ## Model Layout mode
-     *
-     * File formats like Guitar Pro embed information about the layout in the file and alphaTab can read and use this information.
-     * When this mode is enabled, alphaTab will also actively use this information and try to respect it.
-     *
-     * alphaTab holds following information in the data model and developers can change those values (e.g. by tapping into the `scoreLoaded`) event.
-     *
-     * **Used when single tracks are rendered:**
-     *
-     * * `score.tracks[index].systemsLayout` - An array of numbers describing how many bars should be placed within each system (row).
-     * * `score.tracks[index].defaultSystemsLayout` - The number of bars to place in a system (row) when no value is defined in the `systemsLayout`.
-     * * `score.tracks[index].staves[index].bars[index].displayScale` - The relative size of this bar in the system it is placed. Note that this is not directly a percentage value. e.g. if there are 3 bars and all define scale 1, they are sized evenly.
-     * * `score.tracks[index].staves[index].bars[index].displayWidth` - The absolute size of this bar when displayed.
-     *
-     * **Used when multiple tracks are rendered:**
-     *
-     * * `score.systemsLayout` - Like the `systemsLayout` on track level.
-     * * `score.defaultSystemsLayout` - Like the `defaultSystemsLayout` on track level.
-     * * `score.masterBars[index].displayScale` - Like the `displayScale` on bar level.
-     * * `score.masterBars[index].displayWidth` - Like the `displayWidth` on bar level.
-     *
-     * ### Page Layout
-     *
-     * The page layout uses the `systemsLayout` and `defaultSystemsLayout` to decide how many bars go into a single system (row).
-     * Additionally when sizing the bars within the system the `displayScale` is used. As indicated above, the scale is rather a ratio than a percentage value but percentages work also:
-     *
-     * ![Page Layout](https://alphatab.net/img/reference/property/systems-layout-page-examples.png)
-     *
-     * The page layout does not use `displayWidth`. The use of absolute widths would break the proper alignments needed for this kind of display.
-     *
-     * Also note that the sizing is including any glyphs and notation elements within the bar. e.g. if there are clefs in the bar, they are still "squeezed" into the available size.
-     * It is not the case that the actual notes with their lengths are sized accordingly. This fits the sizing system of Guitar Pro and when files are customized there,
-     * alphaTab will match this layout quite close.
-     *
-     * ### Horizontal Layout
-     *
-     * The horizontal layout uses the `displayWidth` to scale the bars to size the bars exactly as specified. This kind of sizing and layout can be useful for usecases like:
-     *
-     * * Comparing files against each other (top/bottom comparison)
-     * * Aligning the playback of multiple files on one screen assuming the same tempo (e.g. one file per track).
-     */
-    systemsLayoutMode: SystemsLayoutMode;
-}