@coderline/alphatab-monaco 1.7.0-alpha.1626

package/dist/types/alphatex/src/types.d.ts

@@ -0,0 +1,161 @@
+import type * as alphaTab from '@coderline/alphatab';
+/**
+ * Common props for elements with descriptions.
+ */
+export interface WithDescription {
+    /**
+     * An optional long description, typically shown in the extended doc popup
+     * shown on hovers and code completions.
+     */
+    longDescription?: string;
+    /**
+     * A short description, typically shown in the code completion box.
+     */
+    shortDescription: string;
+    /**
+     * If defined, the element is deprecated.
+     */
+    deprecated?: string;
+    /**
+     * Additional remarks relevant for this item.
+     */
+    remarks?: string;
+}
+/**
+ * Describes an individual value for a specific parameter.
+ */
+export interface ParameterValueDefinition extends WithDescription {
+    /**
+     * The name of the item
+     */
+    name: string;
+    /**
+     * The snippet to insert
+     */
+    snippet: string;
+    /**
+     * Whether this value has no code completion and mapping but for completeness on enum mappings
+     */
+    skip?: true;
+}
+/**
+ * Defines the details of a single parameter for a {@link SignatureDefinition}
+ */
+export interface ParameterDefinition extends WithDescription {
+    /**
+     * The name of the parameter
+     */
+    name: string;
+    /**
+     * The mode used to parse this parameter.
+     */
+    parseMode: alphaTab.importer.alphaTex.ArgumentListParseTypesMode;
+    /**
+     * The node type for this parameter.
+     */
+    type: alphaTab.importer.alphaTex.AlphaTexNodeType | alphaTab.importer.alphaTex.AlphaTexNodeType[];
+    /**
+     * Whether to allow strings in place of identifiers and vice versa.
+     */
+    allowAllStringTypes?: boolean;
+    /**
+     * The default value of this parameter if not provided.
+     */
+    defaultValue?: unknown;
+    /**
+     * Whether the values list should only be used for providing completion items.
+     * If set to true the parser will parse tokens of any value into the AST and
+     * separately semantic errors have to be created.
+     */
+    valuesOnlyForCompletion?: true;
+    /**
+     * A list of possible values
+     */
+    values?: ParameterValueDefinition[];
+    /**
+     * A list of identifiers which are reserved and cannot be used for this parameter.
+     */
+    reservedIdentifiers?: string[];
+}
+/**
+ * Defines a signature for values which can be passed into the containing element
+ * (e.g. metadata or properties)
+ */
+export interface SignatureDefinition {
+    /**
+     * An additional description specific for this signature.
+     */
+    description?: string;
+    /**
+     * Whether parsing should be strict, meaning: single values can be without parenthesis
+     * multiple values need parenthesis.
+     */
+    strict?: boolean;
+    /**
+     * The parameters which can be passed into this signature.
+     */
+    parameters: ParameterDefinition[];
+}
+/**
+ * Common props for documented elements.
+ */
+export interface WithSignatures extends WithDescription {
+    /**
+     * A list of signatures defining all overloads which can be called for this element.
+     */
+    signatures: SignatureDefinition[];
+    /**
+     * The snippet to insert on autocompleting this item.
+     */
+    snippet: string;
+    /**
+     * One or more examples demonstrating the usage of this element.
+     */
+    examples: AlphaTexExample | AlphaTexExample[];
+    /**
+     * Whether this item is hidden from auto completes and the docs
+     * (e.g. because of outdated mechanisms or aliases)
+     */
+    hidden?: true;
+}
+/**
+ * The documentation for a property.
+ */
+export interface PropertyDefinition extends WithSignatures {
+    /**
+     * The name of the property.
+     */
+    property: string;
+}
+/**
+ * An alphaTex example demonstrating the usage of elements.
+ */
+export type AlphaTexExample = string | {
+    /**
+     * The options to apply when rendering the example
+     */
+    options?: alphaTab.json.SettingsJson;
+    /**
+     * The plain alphaTex code.
+     */
+    tex: string;
+    /**
+     * An alternative MDX code to use for extended documentation, mainly used for the
+     * alphaTab website when advanced examples are needed.
+     */
+    websiteMdx?: string;
+};
+/**
+ * A definition for an alphaTex metadata tag
+ */
+export interface MetadataTagDefinition extends WithSignatures {
+    /**
+     * The metadata tag (including the backslash)
+     */
+    tag: string;
+    /**
+     * A lookup containing the properties available for this metadata.
+     * The key is the lowercase identifier of the property.
+     */
+    properties?: Map<string, PropertyDefinition>;
+}

package/dist/types/lsp/src/index.d.ts

@@ -0,0 +1,21 @@
+import { startNodeLanguageServer, startWebWorkerLanguageServer } from "./server";
+declare const documentation: {
+    structuralMetaData: Map<string, MetadataTagDefinition>;
+    scoreMetaData: Map<string, MetadataTagDefinition>;
+    staffMetaData: Map<string, MetadataTagDefinition>;
+    barMetaData: Map<string, MetadataTagDefinition>;
+    durationChangeProperties: Map<string, PropertyDefinition>;
+    beatProperties: Map<string, PropertyDefinition>;
+    noteProperties: Map<string, PropertyDefinition>;
+};
+import type { AlphaTexExample, MetadataTagDefinition, ParameterDefinition, ParameterValueDefinition, PropertyDefinition, SignatureDefinition, WithDescription, WithSignatures } from "./../../alphatex/src/types";
+/**
+ * The TextMate grammar definition as JSON encoded.
+ * Write this to a local json (e.g. alphatex.tmLanguage.json ) or pass it to any supported parser for further use.
+ */
+declare const textMateGrammar: any;
+/**
+ * The contents of a language-configuration.json to use in editors like VSCode.
+ */
+declare const languageConfiguration: any;
+export { documentation, languageConfiguration, startNodeLanguageServer, startWebWorkerLanguageServer, textMateGrammar, type AlphaTexExample, type MetadataTagDefinition, type ParameterDefinition, type ParameterValueDefinition, type PropertyDefinition, type SignatureDefinition, type WithDescription, type WithSignatures };

package/dist/types/lsp/src/server/completion.d.ts

@@ -0,0 +1,3 @@
+import type { AlphaTexTextDocument, Connection } from "./types";
+import { type TextDocuments } from "./types";
+export declare function setupCompletion(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

package/dist/types/lsp/src/server/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import { type AlphaTexTextDocument, type Connection, type TextDocuments } from "./types";
+export declare function setupDiagnostics(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

package/dist/types/lsp/src/server/hover.d.ts

@@ -0,0 +1,2 @@
+import type { AlphaTexTextDocument, Connection, TextDocuments } from "./types";
+export declare function setupHover(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

package/dist/types/lsp/src/server/index.d.ts

@@ -0,0 +1,13 @@
+import { BrowserMessageReader } from 'vscode-languageserver/lib/browser/main.js';
+type Port = ConstructorParameters<typeof BrowserMessageReader>[0];
+/**
+ * Starts a new language server communicating via WebWorker.
+ * @param readerPort The port used to reading incoming language server messages
+ * @param writerPort The port used to writer outgoing language server messages
+ */
+export declare function startWebWorkerLanguageServer(readerPort: Port, writerPort: Port): void;
+/**
+ * Starts a new language server communicating from a Node.js process with a parent Node.js.
+ */
+export declare function startNodeLanguageServer(): void;
+export {};

package/dist/types/lsp/src/server/signatureHelp.d.ts

@@ -0,0 +1,2 @@
+import { type AlphaTexTextDocument, type Connection, type TextDocuments } from "./types";
+export declare function setupSignatureHelp(connection: Connection, documents: TextDocuments<AlphaTexTextDocument>): void;

package/dist/types/lsp/src/server/types.d.ts

@@ -0,0 +1,15 @@
+import type * as alphaTab from '@coderline/alphatab';
+import type { createConnection as createBrowserConnection } from 'vscode-languageserver/lib/browser/main.js';
+import type { createConnection as createNodeConnection } from 'vscode-languageserver/lib/node/main.js';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+export type NodeConnection = ReturnType<typeof createNodeConnection>;
+export type BrowserConnection = ReturnType<typeof createBrowserConnection>;
+export type Connection = NodeConnection | BrowserConnection;
+export interface AlphaTexTextDocument extends TextDocument {
+    score?: alphaTab.model.Score;
+    ast?: alphaTab.importer.alphaTex.AlphaTexScoreNode;
+}
+export { type RemoteConsole, type TextDocumentPositionParams, TextDocuments } from 'vscode-languageserver';
+export { type DocumentDiagnosticReport, DocumentDiagnosticReportKind, type InitializeParams, type InitializeResult, PositionEncodingKind, TextDocumentSyncKind } from 'vscode-languageserver-protocol';
+export { TextDocument } from 'vscode-languageserver-textdocument';
+export { type CompletionItem, CompletionItemKind, type Diagnostic, DiagnosticSeverity, type Hover, InsertTextFormat, ParameterInformation, type SignatureHelp, SignatureInformation, TextEdit, uinteger } from 'vscode-languageserver-types';

package/dist/types/lsp/src/server/utils.d.ts

@@ -0,0 +1,6 @@
+import * as alphaTab from '@coderline/alphatab';
+import type { ParameterDefinition, SignatureDefinition } from "./../../../alphatex/src/types";
+export declare function binaryNodeSearch<T extends alphaTab.importer.alphaTex.AlphaTexAstNode>(items: T[], offset: number, trailingEnd?: number): T | undefined;
+export declare function resolveSignature(signatures: SignatureDefinition[], args: alphaTab.importer.alphaTex.AlphaTexArgumentList): Map<number, SignatureDefinition>;
+export declare function parameterToSyntax(parameter: ParameterDefinition, onlyParameterNames: boolean): string;
+export declare function nodeTypesToTypeDocs(parameter: ParameterDefinition): string;

package/dist/types/monaco/src/alphaTab.monaco.d.ts

@@ -0,0 +1,2 @@
+export * from './alphatex';
+export * from './textmate';

package/dist/types/monaco/src/alphatex.d.ts

@@ -0,0 +1,6 @@
+import type { TextMateGrammarSupport } from "./types";
+/**
+ * Registers alphaTex as language in the provided grammar support context.
+ * @param grammarSupport The context for handling grammar support in Monaco.
+ */
+export declare function registerAlphaTexGrammar(grammarSupport: TextMateGrammarSupport): Promise<void>;

package/dist/types/monaco/src/lsp.d.ts

@@ -0,0 +1,20 @@
+import * as monaco from 'monaco-editor';
+import { type InitializeParams, type Logger } from 'vscode-languageserver-protocol';
+/**
+ * Enables a basic Language Server integration for the given editor covering:
+ * * A single document backend (no workspace integration with file open,close, rename etc.)
+ * * Diagnostics Provider (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_pullDiagnostics)
+ * * Completions (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_completion)
+ * * Hover (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_hover)
+ * * Signature Help (https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocument_signatureHelp)
+ *
+ * This feature set is mainly aligned with the capabilities of the alphaTab language server.
+ *
+ * @param editor The editor to integrate with.
+ * @param languageServerWorker The web worker with a language server listening for messages.
+ */
+export declare function basicEditorLspIntegration(editor: monaco.editor.IStandaloneCodeEditor, languageServerWorker: Worker, info: {
+    languageId: string;
+    logger?: Logger;
+    clientInfo?: InitializeParams['clientInfo'];
+}): Promise<void>;

package/dist/types/monaco/src/lspMonacoMappings.d.ts

@@ -0,0 +1,24 @@
+import { DiagnosticSeverity } from "./../../lsp/src/server/types";
+import * as monaco from 'monaco-editor';
+import { CompletionTriggerKind, SignatureHelpTriggerKind, type TextDocumentContentChangeEvent } from 'vscode-languageserver-protocol';
+import type { CompletionItem, Diagnostic, DiagnosticRelatedInformation, Hover, Range, SignatureHelp, TextEdit } from 'vscode-languageserver-types';
+import { CompletionItemKind, CompletionItemTag } from 'vscode-languageserver-types';
+export declare function lspToMonacoSeverity(severity: DiagnosticSeverity | undefined): monaco.MarkerSeverity;
+export type MonacoLocation = Pick<monaco.editor.IRelatedInformation, 'startColumn' | 'startLineNumber' | 'endColumn' | 'endLineNumber'>;
+export declare function lspToMonacoMarker(diagnostic: Diagnostic): monaco.editor.IMarkerData;
+export declare function lspToMonacoRange(range: Range): monaco.Range;
+export declare function monacoToLspRange(range: monaco.IRange): Range;
+export declare function lspToMonacoRelatedInformation(value: DiagnosticRelatedInformation): monaco.editor.IRelatedInformation;
+export declare function monacoToLspContentChange(change: monaco.editor.IModelContentChange): TextDocumentContentChangeEvent;
+export declare function monacoToLspCompletionTriggerKind(triggerKind: monaco.languages.CompletionTriggerKind): CompletionTriggerKind;
+export declare function lspToMonacoCompletionItem(value: CompletionItem, cursorPosition: monaco.languages.CompletionItem['range']): monaco.languages.CompletionItem;
+export declare function lspToMonacoCompletionKind(kind: CompletionItemKind | undefined): monaco.languages.CompletionItemKind;
+export declare function monacoToLspCompletionKind(kind: monaco.languages.CompletionItemKind): CompletionItemKind;
+export declare function lspToMonacoTextEdit(value: TextEdit): monaco.editor.ISingleEditOperation;
+export declare function monacoToLspTextEdit(value: monaco.editor.ISingleEditOperation): TextEdit;
+export declare function monacoToLspCompletionItem(value: monaco.languages.CompletionItem): CompletionItem;
+export declare function monacoToLspTag(value: monaco.languages.CompletionItemTag): CompletionItemTag;
+export declare function lspToMonacoHover(response: Hover): monaco.languages.Hover;
+export declare function monacoToLspSignatureHelpTriggerKind(triggerKind: monaco.languages.SignatureHelpTriggerKind): SignatureHelpTriggerKind;
+export declare function monacoToLspSignatureHelp(v: monaco.languages.SignatureHelp): SignatureHelp;
+export declare function lspToMonacoSignatureHelp(response: SignatureHelp): monaco.languages.SignatureHelpResult;

package/dist/types/monaco/src/textmate.d.ts

@@ -0,0 +1,15 @@
+import type { TextMateGrammarSupport } from "./types";
+import * as monaco from 'monaco-editor';
+/**
+ * Adds TextMate grammar support to Monaco via `vscode-oniguruma` and `vscode-textmate`
+ * @param onigurumaWasm The `onig.wasm` file shipped together with vscode-oniguruma.
+ */
+export declare function addTextMateGrammarSupport(onigurumaWasm: ArrayBuffer): TextMateGrammarSupport;
+/**
+ * Registers a TextMate grammar in moncao.
+ * @param grammarSupport The support object in which to register the grammar.
+ * @param languageId The ID of the language
+ * @param loadGrammar A promise to load the grammar source code.
+ * @param loadLanguageConfiguration A promise to load the monaco language configuration.
+ */
+export declare function registerGrammar(grammarSupport: TextMateGrammarSupport, languageId: string, loadGrammar: () => Promise<string>, loadLanguageConfiguration: () => Promise<monaco.languages.LanguageConfiguration>): Promise<void>;

package/dist/types/monaco/src/types.d.ts

@@ -0,0 +1,15 @@
+import type { Registry } from 'vscode-textmate';
+/**
+ * A wrapper around components related to textmate grammar support for Monaco.
+ */
+export type TextMateGrammarSupport = {
+    /**
+     * The underlying {@link Registry} handling loading of grammars.
+     */
+    registry: Registry;
+    /**
+     * A lookup to register supported grammars. The key is the `scopeName` requested
+     * by a language and the value is a promise to load the grammar in a supported formats.
+     */
+    grammars: Record<string, () => Promise<string>>;
+};

package/dist/types/monaco/src/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/monaco/test/placeholder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/monaco/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfigFnObject;
+export default _default;

package/dist/types/tooling/src/typescript.d.ts

@@ -0,0 +1,9 @@
+import * as ts from 'typescript';
+type Logger = Pick<Console, 'log' | 'info' | 'warn' | 'error'>;
+export declare function createDiagnosticReporter(pretty: boolean, logger: Logger): ts.DiagnosticReporter;
+export declare function symbolFromNode(checker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;
+export declare function resolveImportedSourceFile(checker: ts.TypeChecker, node: ts.ImportDeclaration): ts.SourceFile | undefined;
+export declare function createApiDtsFiles(dtsBaseDir: string, dtsFiles: string[], projectDir: string, outDir: string, logger: Logger): Promise<void>;
+export declare function isElementStyleHelper(node: ts.Statement): boolean;
+export declare function elementStyleUsingTransformer(): (context: ts.TransformationContext) => (source: ts.SourceFile) => ts.SourceFile;
+export {};

package/dist/types/tooling/src/vite.d.ts

@@ -0,0 +1,13 @@
+import { type RollupTypescriptOptions } from '@rollup/plugin-typescript';
+import type { OutputChunk } from 'rollup';
+import ts from 'typescript';
+import { type UserConfig } from 'vite';
+export declare function licenseHeaderPlugin(): import("rollup").Plugin<any>;
+export declare function defineEsmAndCommonJsConfig(entry: string): import("vite").UserConfigFnObject;
+export declare function defaultBuildUserConfig(): UserConfig;
+export declare function enableTypeScript(config: UserConfig, o?: Partial<RollupTypescriptOptions>, types?: boolean): void;
+export declare function umd(config: UserConfig, projectDir: string, name: string, entry: string, tsOptions?: RollupTypescriptOptions, withMin?: boolean): void;
+export declare function commonjs(config: UserConfig, projectDir: string, name: string, entry: string, tsOptions?: RollupTypescriptOptions): void;
+export declare function esm(config: UserConfig, projectDir: string, name: string, entry: string, tsOptions?: RollupTypescriptOptions, shouldCreateDts?: (chunk: OutputChunk) => boolean, withMin?: boolean): void;
+export declare function dtsPathsTransformer(mapping?: Record<string, string>, externals?: (string | RegExp)[]): (context: ts.TransformationContext) => (source: ts.SourceFile | ts.Bundle) => ts.SourceFile | ts.Bundle;
+export declare function defineEsmLibConfig(): import("vite").UserConfigFnObject;

package/dist/types/tooling/src/vite.plugin.dts.d.ts

@@ -0,0 +1 @@
+export default function generateDts(root: string, dtsPath: string, outputFile: string, externals: (string | RegExp)[]): void;

package/dist/types/tooling/src/vite.plugin.min.d.ts

@@ -0,0 +1,3 @@
+import type { OutputPlugin } from 'rollup';
+import { type MinifyOptions } from 'terser';
+export default function min(options: MinifyOptions): OutputPlugin;