From 0fd6f29a23b1e250b8e1fe11dfbcb6a8e7824b3b Mon Sep 17 00:00:00 2001 From: Henning Dieterichs Date: Fri, 10 Oct 2025 12:18:12 +0200 Subject: [PATCH] First iteration of monaco editor lsp client (#5044) --- .husky/pre-commit | 2 - build/amd/rollup-types.config.mjs | 2 +- build/amd/src/editor.main.ts | 9 + build/amd/vite.config.js | 3 + monaco-lsp-client/README.md | 5 + monaco-lsp-client/generator/index.ts | 687 ++ monaco-lsp-client/package-lock.json | 1564 ++++ monaco-lsp-client/package.json | 26 + monaco-lsp-client/rolldown.config.mjs | 33 + .../src/adapters/ITextModelBridge.ts | 40 + .../src/adapters/LspCapabilitiesRegistry.ts | 254 + monaco-lsp-client/src/adapters/LspClient.ts | 90 + .../src/adapters/LspConnection.ts | 13 + .../src/adapters/TextDocumentSynchronizer.ts | 183 + .../languageFeatures/LspCodeActionFeature.ts | 169 + .../languageFeatures/LspCodeLensFeature.ts | 90 + .../languageFeatures/LspCompletionFeature.ts | 202 + .../languageFeatures/LspDeclarationFeature.ts | 60 + .../languageFeatures/LspDefinitionFeature.ts | 60 + .../languageFeatures/LspDiagnosticsFeature.ts | 208 + .../LspDocumentHighlightFeature.ts | 58 + .../LspDocumentLinkFeature.ts | 71 + .../LspDocumentSymbolFeature.ts | 101 + .../LspFoldingRangeFeature.ts | 63 + .../languageFeatures/LspFormattingFeature.ts | 60 + .../languageFeatures/LspHoverFeature.ts | 79 + .../LspImplementationFeature.ts | 60 + .../languageFeatures/LspInlayHintsFeature.ts | 212 + .../LspOnTypeFormattingFeature.ts | 71 + .../LspRangeFormattingFeature.ts | 62 + .../languageFeatures/LspReferencesFeature.ts | 64 + .../languageFeatures/LspRenameFeature.ts | 142 + .../LspSelectionRangeFeature.ts | 71 + .../LspSemanticTokensFeature.ts | 130 + .../LspSignatureHelpFeature.ts | 101 + .../LspTypeDefinitionFeature.ts | 60 + .../src/adapters/languageFeatures/common.ts | 401 + monaco-lsp-client/src/index.ts | 5 + monaco-lsp-client/src/types.ts | 7514 +++++++++++++++++ monaco-lsp-client/src/utils.ts | 75 + package-lock.json | 926 ++ package.json | 4 +- 42 files changed, 14026 insertions(+), 4 deletions(-) create mode 100644 monaco-lsp-client/README.md create mode 100644 monaco-lsp-client/generator/index.ts create mode 100644 monaco-lsp-client/package-lock.json create mode 100644 monaco-lsp-client/package.json create mode 100644 monaco-lsp-client/rolldown.config.mjs create mode 100644 monaco-lsp-client/src/adapters/ITextModelBridge.ts create mode 100644 monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts create mode 100644 monaco-lsp-client/src/adapters/LspClient.ts create mode 100644 monaco-lsp-client/src/adapters/LspConnection.ts create mode 100644 monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts create mode 100644 monaco-lsp-client/src/adapters/languageFeatures/common.ts create mode 100644 monaco-lsp-client/src/index.ts create mode 100644 monaco-lsp-client/src/types.ts create mode 100644 monaco-lsp-client/src/utils.ts diff --git a/.husky/pre-commit b/.husky/pre-commit index 9129110b..6700f512 100755 --- a/.husky/pre-commit +++ b/.husky/pre-commit @@ -1,4 +1,2 @@ #!/bin/sh . "$(dirname "$0")/_/husky.sh" - -npm run pretty-quick diff --git a/build/amd/rollup-types.config.mjs b/build/amd/rollup-types.config.mjs index 8412ecbc..0a591923 100644 --- a/build/amd/rollup-types.config.mjs +++ b/build/amd/rollup-types.config.mjs @@ -60,7 +60,7 @@ export default defineConfig({ compilerOptions: { stripInternal: true }, - includeExternal: ['monaco-editor-core'] + includeExternal: ['monaco-editor-core', '@vscode/monaco-lsp-client'] }) ] }); diff --git a/build/amd/src/editor.main.ts b/build/amd/src/editor.main.ts index 1f4e960c..527d4ddf 100644 --- a/build/amd/src/editor.main.ts +++ b/build/amd/src/editor.main.ts @@ -65,6 +65,15 @@ function getWorkerBootstrapUrl(workerScriptUrl: string | URL) { import 'vs/nls.messages-loader!'; export * from '../../../src/editor/editor.main'; +// for now, lsp is only available to amd build +import * as lsp from '@vscode/monaco-lsp-client'; +export { lsp }; + +// TODO@hediet get rid of the monaco global +if ((globalThis as any).monaco) { + (globalThis as any).monaco.lsp = lsp; +} + const styleSheetUrl = require.toUrl('vs/editor/editor.main.css'); const link = document.createElement('link'); diff --git a/build/amd/vite.config.js b/build/amd/vite.config.js index f26ab097..b4f735f4 100644 --- a/build/amd/vite.config.js +++ b/build/amd/vite.config.js @@ -21,6 +21,9 @@ export default defineConfig(async (args) => { /** @type {import('vite').UserConfig} */ return { base: './', + resolve: { + dedupe: ['monaco-editor-core'] + }, build: { lib: { cssFileName: 'editor/editor.main', diff --git a/monaco-lsp-client/README.md b/monaco-lsp-client/README.md new file mode 100644 index 00000000..8e6f3433 --- /dev/null +++ b/monaco-lsp-client/README.md @@ -0,0 +1,5 @@ +# Monaco LSP Client + +Provides a Language Server Protocol (LSP) client for the Monaco Editor. + +This package is in alpha stage and might contain many bugs. diff --git a/monaco-lsp-client/generator/index.ts b/monaco-lsp-client/generator/index.ts new file mode 100644 index 00000000..df3b100c --- /dev/null +++ b/monaco-lsp-client/generator/index.ts @@ -0,0 +1,687 @@ +import * as fs from 'fs'; +import * as path from 'path'; + +/** + * Utility class for writing formatted code with proper indentation + */ +class LineWriter { + private lines: string[] = []; + private indentLevel: number = 0; + private indentStr: string = ' '; // 4 spaces + + /** + * Write a line with current indentation + */ + writeLine(line: string = ''): void { + if (line.trim() === '') { + this.lines.push(''); + } else { + this.lines.push(this.indentStr.repeat(this.indentLevel) + line); + } + } + + /** + * Write text without adding a new line + */ + write(text: string): void { + if (this.lines.length === 0) { + this.lines.push(''); + } + const lastIndex = this.lines.length - 1; + if (this.lines[lastIndex] === '') { + this.lines[lastIndex] = this.indentStr.repeat(this.indentLevel) + text; + } else { + this.lines[lastIndex] += text; + } + } + + /** + * Increase indentation level + */ + indent(): void { + this.indentLevel++; + } + + /** + * Decrease indentation level + */ + outdent(): void { + if (this.indentLevel > 0) { + this.indentLevel--; + } + } + + /** + * Get the generated content as a string + */ + toString(): string { + return this.lines.join('\n'); + } + + /** + * Clear all content and reset indentation + */ + clear(): void { + this.lines = []; + this.indentLevel = 0; + } +} + +/** + * Interface definitions based on the metaModel schema + */ +interface MetaModel { + metaData: MetaData; + requests: Request[]; + notifications: Notification[]; + structures: Structure[]; + enumerations: Enumeration[]; + typeAliases: TypeAlias[]; +} + +interface MetaData { + version: string; +} + +interface Request { + method: string; + result: Type; + messageDirection: MessageDirection; + params?: Type | Type[]; + partialResult?: Type; + errorData?: Type; + registrationOptions?: Type; + registrationMethod?: string; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +interface Notification { + method: string; + messageDirection: MessageDirection; + params?: Type | Type[]; + registrationOptions?: Type; + registrationMethod?: string; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +interface Structure { + name: string; + properties: Property[]; + extends?: Type[]; + mixins?: Type[]; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +interface Property { + name: string; + type: Type; + optional?: boolean; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +interface Enumeration { + name: string; + type: EnumerationType; + values: EnumerationEntry[]; + supportsCustomValues?: boolean; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +interface EnumerationEntry { + name: string; + value: string | number; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +interface EnumerationType { + kind: 'base'; + name: 'string' | 'integer' | 'uinteger'; +} + +interface TypeAlias { + name: string; + type: Type; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +type MessageDirection = 'clientToServer' | 'serverToClient' | 'both'; + +type Type = + | BaseType + | ReferenceType + | ArrayType + | MapType + | AndType + | OrType + | TupleType + | StructureLiteralType + | StringLiteralType + | IntegerLiteralType + | BooleanLiteralType; + +interface BaseType { + kind: 'base'; + name: + | 'URI' + | 'DocumentUri' + | 'integer' + | 'uinteger' + | 'decimal' + | 'RegExp' + | 'string' + | 'boolean' + | 'null'; +} + +interface ReferenceType { + kind: 'reference'; + name: string; +} + +interface ArrayType { + kind: 'array'; + element: Type; +} + +interface MapType { + kind: 'map'; + key: Type; + value: Type; +} + +interface AndType { + kind: 'and'; + items: Type[]; +} + +interface OrType { + kind: 'or'; + items: Type[]; +} + +interface TupleType { + kind: 'tuple'; + items: Type[]; +} + +interface StructureLiteralType { + kind: 'literal'; + value: StructureLiteral; +} + +interface StructureLiteral { + properties: Property[]; + documentation?: string; + since?: string; + proposed?: boolean; + deprecated?: string; +} + +interface StringLiteralType { + kind: 'stringLiteral'; + value: string; +} + +interface IntegerLiteralType { + kind: 'integerLiteral'; + value: number; +} + +interface BooleanLiteralType { + kind: 'booleanLiteral'; + value: boolean; +} + +/** + * TypeScript types generator for LSP client + */ +class LSPTypesGenerator { + private writer = new LineWriter(); + + /** + * Load and parse the metaModel.json file + */ + private loadMetaModel(): MetaModel { + const metaModelPath = path.join(__dirname, '..', 'metaModel.json'); + const content = fs.readFileSync(metaModelPath, 'utf-8'); + return JSON.parse(content) as MetaModel; + } + + /** + * Convert Type to TypeScript type string + */ + private typeToTypeScript(type: Type): string { + switch (type.kind) { + case 'base': + switch (type.name) { + case 'string': + case 'DocumentUri': + case 'URI': + return 'string'; + case 'integer': + case 'uinteger': + case 'decimal': + return 'number'; + case 'boolean': + return 'boolean'; + case 'null': + return 'null'; + case 'RegExp': + return 'RegExp'; + default: + return 'any'; + } + case 'reference': + return type.name; + case 'array': + return `(${this.typeToTypeScript(type.element)})[]`; + case 'map': + return `{ [key: ${this.typeToTypeScript(type.key)}]: ${this.typeToTypeScript( + type.value + )} }`; + case 'and': + return type.items.map((item) => this.typeToTypeScript(item)).join(' & '); + case 'or': + return type.items.map((item) => this.typeToTypeScript(item)).join(' | '); + case 'tuple': + return `[${type.items.map((item) => this.typeToTypeScript(item)).join(', ')}]`; + case 'literal': + return this.structureLiteralToTypeScript(type.value); + case 'stringLiteral': + return `'${type.value}'`; + case 'integerLiteral': + return type.value.toString(); + case 'booleanLiteral': + return type.value.toString(); + default: + return 'any'; + } + } + + /** + * Convert structure literal to TypeScript interface + */ + private structureLiteralToTypeScript(literal: StructureLiteral): string { + const properties = literal.properties.map((prop) => { + const optional = prop.optional ? '?' : ''; + return `${prop.name}${optional}: ${this.typeToTypeScript(prop.type)}`; + }); + return `{\n ${properties.join(';\n ')}\n}`; + } + + /** + * Generate TypeScript interface for a structure + */ + private generateStructure(structure: Structure): void { + if (structure.documentation) { + this.writer.writeLine('/**'); + this.writer.writeLine(` * ${structure.documentation.replace(/\n/g, '\n * ')}`); + this.writer.writeLine(' */'); + } + + // Build extends clause combining extends and mixins + const allParents: string[] = []; + + if (structure.extends && structure.extends.length > 0) { + allParents.push(...structure.extends.map((type) => this.typeToTypeScript(type))); + } + + if (structure.mixins && structure.mixins.length > 0) { + allParents.push(...structure.mixins.map((type) => this.typeToTypeScript(type))); + } + + const extendsClause = allParents.length > 0 ? ` extends ${allParents.join(', ')}` : ''; + + this.writer.writeLine(`export interface ${structure.name}${extendsClause} {`); + this.writer.indent(); + + // Add properties + for (const property of structure.properties) { + if (property.documentation) { + this.writer.writeLine('/**'); + this.writer.writeLine(` * ${property.documentation.replace(/\n/g, '\n * ')}`); + this.writer.writeLine(' */'); + } + const optional = property.optional ? '?' : ''; + this.writer.writeLine( + `${property.name}${optional}: ${this.typeToTypeScript(property.type)};` + ); + } + + this.writer.outdent(); + this.writer.writeLine('}'); + this.writer.writeLine(''); + } + + /** + * Generate TypeScript enum for an enumeration + */ + private generateEnumeration(enumeration: Enumeration): void { + if (enumeration.documentation) { + this.writer.writeLine('/**'); + this.writer.writeLine(` * ${enumeration.documentation.replace(/\n/g, '\n * ')}`); + this.writer.writeLine(' */'); + } + + this.writer.writeLine(`export enum ${enumeration.name} {`); + this.writer.indent(); + + for (let i = 0; i < enumeration.values.length; i++) { + const entry = enumeration.values[i]; + if (entry.documentation) { + this.writer.writeLine('/**'); + this.writer.writeLine(` * ${entry.documentation.replace(/\n/g, '\n * ')}`); + this.writer.writeLine(' */'); + } + const isLast = i === enumeration.values.length - 1; + const comma = isLast ? '' : ','; + if (typeof entry.value === 'string') { + this.writer.writeLine(`${entry.name} = '${entry.value}'${comma}`); + } else { + this.writer.writeLine(`${entry.name} = ${entry.value}${comma}`); + } + } + + this.writer.outdent(); + this.writer.writeLine('}'); + this.writer.writeLine(''); + } + + /** + * Generate TypeScript type alias + */ + private generateTypeAlias(typeAlias: TypeAlias): void { + if (typeAlias.documentation) { + this.writer.writeLine('/**'); + this.writer.writeLine(` * ${typeAlias.documentation.replace(/\n/g, '\n * ')}`); + this.writer.writeLine(' */'); + } + + this.writer.writeLine( + `export type ${typeAlias.name} = ${this.typeToTypeScript(typeAlias.type)};` + ); + this.writer.writeLine(''); + } + + /** + * Generate the Capability class + */ + private generateCapabilityClass(): void { + this.writer.writeLine('/**'); + this.writer.writeLine( + ' * Represents a capability with its associated method and registration options type' + ); + this.writer.writeLine(' */'); + this.writer.writeLine('export class Capability {'); + this.writer.indent(); + this.writer.writeLine('constructor(public readonly method: string) {}'); + this.writer.outdent(); + this.writer.writeLine('}'); + this.writer.writeLine(''); + } + + /** + * Generate the capabilities map + */ + private generateCapabilitiesMap(metaModel: MetaModel): void { + this.writer.writeLine('/**'); + this.writer.writeLine(' * Map of all LSP capabilities with their registration options'); + this.writer.writeLine(' */'); + this.writer.writeLine('export const capabilities = {'); + this.writer.indent(); + + // Collect all requests and notifications with registration options + const itemsWithRegistration: Array<{ method: string; registrationOptions?: Type }> = []; + + for (const request of metaModel.requests) { + if (request.registrationOptions) { + itemsWithRegistration.push({ + method: request.method, + registrationOptions: request.registrationOptions + }); + } + } + + for (const notification of metaModel.notifications) { + if (notification.registrationOptions) { + itemsWithRegistration.push({ + method: notification.method, + registrationOptions: notification.registrationOptions + }); + } + } + + // Generate capability entries + for (const item of itemsWithRegistration) { + const methodIdentifier = this.methodToIdentifier(item.method); + const registrationType = item.registrationOptions + ? this.typeToTypeScript(item.registrationOptions) + : 'unknown'; + + this.writer.writeLine( + `${methodIdentifier}: new Capability<${registrationType}>('${item.method}'),` + ); + } + + this.writer.outdent(); + this.writer.writeLine('};'); + this.writer.writeLine(''); + } + + /** + * Convert LSP method name to valid JavaScript identifier + */ + private methodToIdentifier(method: string): string { + const parts = method + .replace(/\$/g, '') // Remove $ characters + .split('/') // Split on forward slashes + .filter((part) => part.length > 0); // Remove empty parts + + return parts + .map((part, index) => { + // Convert kebab-case to camelCase for each part + const camelCase = part.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()); + // Capitalize first letter of all parts except the first non-empty part + return index === 0 ? camelCase : camelCase.charAt(0).toUpperCase() + camelCase.slice(1); + }) + .join(''); + } + + /** + * Generate the API contract object + */ + private generateApiContract(metaModel: MetaModel): void { + this.writer.writeLine('/**'); + this.writer.writeLine(' * LSP API Contract'); + this.writer.writeLine(' */'); + + this.writer.writeLine('export const api = contract({'); + this.writer.indent(); + + this.writer.writeLine('name: "LSP",'); + + // Helper function to generate request entries + const generateRequest = (request: Request, isOptional: boolean = false) => { + const methodIdentifier = this.methodToIdentifier(request.method); + const paramsType = this.getParamsType(request.params); + const resultType = this.typeToTypeScript(request.result); + + if (request.documentation) { + this.writer.writeLine('/**'); + this.writer.writeLine(` * ${request.documentation.replace(/\n/g, '\n * ')}`); + this.writer.writeLine(' */'); + } + + const optional = isOptional ? '.optional()' : ''; + this.writer.writeLine( + `${methodIdentifier}: unverifiedRequest<${paramsType}, ${resultType}>({ method: "${request.method}" })${optional},` + ); + }; + + // Helper function to generate notification entries + const generateNotification = (notification: Notification) => { + const methodIdentifier = this.methodToIdentifier(notification.method); + const paramsType = this.getParamsType(notification.params); + + if (notification.documentation) { + this.writer.writeLine('/**'); + this.writer.writeLine(` * ${notification.documentation.replace(/\n/g, '\n * ')}`); + this.writer.writeLine(' */'); + } + this.writer.writeLine( + `${methodIdentifier}: unverifiedNotification<${paramsType}>({ method: "${notification.method}" }),` + ); + }; + + // Server section + this.writer.writeLine('server: {'); + this.writer.indent(); + + // Server requests (sent from client to server) + for (const request of metaModel.requests) { + if (request.messageDirection === 'clientToServer' || request.messageDirection === 'both') { + generateRequest(request); + } + } + + // Server notifications (sent from client to server) + for (const notification of metaModel.notifications) { + if ( + notification.messageDirection === 'clientToServer' || + notification.messageDirection === 'both' + ) { + generateNotification(notification); + } + } + + this.writer.outdent(); + this.writer.writeLine('},'); + + // Client section + this.writer.writeLine('client: {'); + this.writer.indent(); + + // Client requests (handled by server) + for (const request of metaModel.requests) { + if (request.messageDirection === 'serverToClient' || request.messageDirection === 'both') { + generateRequest(request, true); // serverToClient requests are optional + } + } + + // Client notifications (sent from server to client) + for (const notification of metaModel.notifications) { + if ( + notification.messageDirection === 'serverToClient' || + notification.messageDirection === 'both' + ) { + generateNotification(notification); + } + } + + this.writer.outdent(); + this.writer.writeLine('}'); + + this.writer.outdent(); + this.writer.writeLine('});'); + this.writer.writeLine(''); + } + + /** + * Helper method to get parameter type + */ + private getParamsType(params?: Type | Type[]): string { + if (!params) { + return 'void'; + } + if (Array.isArray(params)) { + const paramTypes = params.map((p) => this.typeToTypeScript(p)); + return `[${paramTypes.join(', ')}]`; + } else { + return this.typeToTypeScript(params); + } + } + + /** + * Generate the complete TypeScript types + */ + generate(): void { + const metaModel = this.loadMetaModel(); + + this.writer.clear(); + this.writer.writeLine('// Generated TypeScript definitions for LSP'); + this.writer.writeLine(`// Protocol version: ${metaModel.metaData.version}`); + this.writer.writeLine('// This file is auto-generated. Do not edit manually.'); + this.writer.writeLine(''); + + // Import contract types from @hediet/json-rpc + this.writer.writeLine('import {'); + this.writer.indent(); + this.writer.writeLine('contract,'); + this.writer.writeLine('Contract,'); + this.writer.writeLine('unverifiedRequest,'); + this.writer.writeLine('unverifiedNotification,'); + this.writer.outdent(); + this.writer.writeLine('} from "@hediet/json-rpc";'); + this.writer.writeLine(''); + + // Generate enumerations + for (const enumeration of metaModel.enumerations) { + this.generateEnumeration(enumeration); + } + + // Generate type aliases + for (const typeAlias of metaModel.typeAliases) { + this.generateTypeAlias(typeAlias); + } + + // Generate structures + for (const structure of metaModel.structures) { + this.generateStructure(structure); + } + + // Generate Capability class + this.generateCapabilityClass(); + + // Generate capabilities map + this.generateCapabilitiesMap(metaModel); + + // Generate API contract + this.generateApiContract(metaModel); + + // Write types file + const srcDir = path.join(__dirname, '..', 'src'); + if (!fs.existsSync(srcDir)) { + fs.mkdirSync(srcDir, { recursive: true }); + } + fs.writeFileSync(path.join(srcDir, 'types.ts'), this.writer.toString()); + + console.log('Generated LSP types file: src/types.ts'); + } +} + +// Run the generator +if (require.main === module) { + const generator = new LSPTypesGenerator(); + generator.generate(); +} diff --git a/monaco-lsp-client/package-lock.json b/monaco-lsp-client/package-lock.json new file mode 100644 index 00000000..03240878 --- /dev/null +++ b/monaco-lsp-client/package-lock.json @@ -0,0 +1,1564 @@ +{ + "name": "@vscode/monaco-lsp-client", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@vscode/monaco-lsp-client", + "version": "0.1.0", + "dependencies": { + "@hediet/json-rpc": "^0.5.0", + "@hediet/json-rpc-browser": "^0.5.1", + "@hediet/json-rpc-websocket": "^0.5.1" + }, + "devDependencies": { + "rolldown": "^1.0.0-beta.41", + "rolldown-plugin-dts": "^0.16.11", + "rollup-plugin-delete": "^3.0.1" + }, + "peerDependencies": { + "monaco-editor-core": "^0.54.0-dev-20250929" + } + }, + "../../../hediet/typed-json-rpc/json-rpc": { + "name": "@hediet/json-rpc", + "version": "0.5.0", + "license": "MIT", + "devDependencies": { + "typescript": "^5.8.3" + } + }, + "../../../hediet/typed-json-rpc/json-rpc-browser": { + "name": "@hediet/json-rpc-browser", + "version": "0.5.1", + "license": "MIT", + "dependencies": { + "@hediet/json-rpc": "^0.5.0" + } + }, + "../../../hediet/typed-json-rpc/json-rpc-node": { + "name": "@hediet/json-rpc-node", + "version": "0.5.0", + "extraneous": true, + "license": "MIT", + "dependencies": { + "@hediet/json-rpc": "^0.5.0", + "@types/node": "^12.0.7" + }, + "devDependencies": { + "@types/mocha": "^5.2.7", + "coveralls": "^3.0.4", + "mocha": "^6.1.4", + "mocha-lcov-reporter": "^1.3.0", + "nyc": "^14.1.1", + "source-map-support": "^0.5.12" + } + }, + "../../../hediet/typed-json-rpc/json-rpc-websocket": { + "name": "@hediet/json-rpc-websocket", + "version": "0.5.1", + "license": "MIT", + "dependencies": { + "@hediet/json-rpc": "^0.5.0", + "@types/ws": "^6.0.4", + "isomorphic-ws": "^5.0.0" + } + }, + "../../hediet/typed-json-rpc/json-rpc-browser": { + "extraneous": true + }, + "node_modules/@babel/generator": { + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz", + "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.28.3", + "@babel/types": "^7.28.2", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", + "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz", + "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.4" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz", + "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@emnapi/core": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.5.0.tgz", + "integrity": "sha512-sbP8GzB1WDzacS8fgNPpHlp6C9VZe+SJP3F90W9rLemaQj2PzIuTEl1qDOYQf58YIpyjViI24y9aPWCjEzY2cg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/wasi-threads": "1.1.0", + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/runtime": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.5.0.tgz", + "integrity": "sha512-97/BJ3iXHww3djw6hYIfErCZFee7qCtrneuLa20UXFCOTCfBM2cvQHjWJ2EG0s0MtdNwInarqCTz35i4wWXHsQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/wasi-threads": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz", + "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@hediet/json-rpc": { + "resolved": "../../../hediet/typed-json-rpc/json-rpc", + "link": true + }, + "node_modules/@hediet/json-rpc-browser": { + "resolved": "../../../hediet/typed-json-rpc/json-rpc-browser", + "link": true + }, + "node_modules/@hediet/json-rpc-websocket": { + "resolved": "../../../hediet/typed-json-rpc/json-rpc-websocket", + "link": true + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@napi-rs/wasm-runtime": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.0.6.tgz", + "integrity": "sha512-DXj75ewm11LIWUk198QSKUTxjyRjsBwk09MuMk5DGK+GDUtyPhhEHOGP/Xwwj3DjQXXkivoBirmOnKrLfc0+9g==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/core": "^1.5.0", + "@emnapi/runtime": "^1.5.0", + "@tybys/wasm-util": "^0.10.1" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@oxc-project/types": { + "version": "0.94.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.94.0.tgz", + "integrity": "sha512-+UgQT/4o59cZfH6Cp7G0hwmqEQ0wE+AdIwhikdwnhWI9Dp8CgSY081+Q3O67/wq3VJu8mgUEB93J9EHHn70fOw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, + "node_modules/@rolldown/binding-android-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-W5ZKF3TP3bOWuBfotAGp+UGjxOkGV7jRmIRbBA7NFjggx7Oi6vOmGDqpHEIX7kDCiry1cnIsWQaxNvWbMdkvzQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-abw/wtgJA8OCgaTlL+xJxnN/Z01BwV1rfzIp5Hh9x+IIO6xOBfPsQ0nzi0+rWx3TyZ9FZXyC7bbC+5NpQ9EaXQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-x64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-beta.42.tgz", + "integrity": "sha512-Y/UrZIRVr8CvXVEB88t6PeC46r1K9/QdPEo2ASE/b/KBEyXIx+QbM6kv9QfQVWU2Atly2+SVsQzxQsIvuk3lZQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-freebsd-x64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-beta.42.tgz", + "integrity": "sha512-zRM0oOk7BZiy6DoWBvdV4hyEg+j6+WcBZIMHVirMEZRu8hd18kZdJkg+bjVMfCEhwpWeFUfBfZ1qcaZ5UdYzlQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm-gnueabihf": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-beta.42.tgz", + "integrity": "sha512-6RjFaC52QNwo7ilU8C5H7swbGlgfTkG9pudXwzr3VYyT18s0C9gLg3mvc7OMPIGqNxnQ0M5lU8j6aQCk2DTRVg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-gnu": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-beta.42.tgz", + "integrity": "sha512-LMYHM5Sf6ROq+VUwHMDVX2IAuEsWTv4SnlFEedBnMGpvRuQ14lCmD4m5Q8sjyAQCgyha9oghdGoK8AEg1sXZKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-musl": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-beta.42.tgz", + "integrity": "sha512-/bNTYb9aKNhzdbPn3O4MK2aLv55AlrkUKPE4KNfBYjkoZUfDr4jWp7gsSlvTc5A/99V1RCm9axvt616ZzeXGyA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-beta.42.tgz", + "integrity": "sha512-n/SLa4h342oyeGykZdch7Y3GNCNliRPL4k5wkeZ/5eQZs+c6/ZG1SHCJQoy7bZcmxiMyaXs9HoFmv1PEKrZgWg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-musl": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-beta.42.tgz", + "integrity": "sha512-4PSd46sFzqpLHSGdaSViAb1mk55sCUMpJg+X8ittXaVocQsV3QLG/uydSH8RyL0ngHX5fy3D70LcCzlB15AgHw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-openharmony-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-BmWoeJJyeZXmZBcfoxG6J9+rl2G7eO47qdTkAzEegj4n3aC6CBIHOuDcbE8BvhZaEjQR0nh0nJrtEDlt65Q7Sw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-wasm32-wasi": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-beta.42.tgz", + "integrity": "sha512-2Ft32F7uiDTrGZUKws6CLNTlvTWHC33l4vpXrzUucf9rYtUThAdPCOt89Pmn13tNX6AulxjGEP2R0nZjTSW3eQ==", + "cpu": [ + "wasm32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@napi-rs/wasm-runtime": "^1.0.6" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@rolldown/binding-win32-arm64-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-hC1kShXW/z221eG+WzQMN06KepvPbMBknF0iGR3VMYJLOe9gwnSTfGxFT5hf8XrPv7CEZqTWRd0GQpkSHRbGsw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-ia32-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-AICBYromawouGjj+GS33369E8Vwhy6UwhQEhQ5evfS8jPCsyVvoICJatbDGDGH01dwtVGLD5eDFzPicUOVpe4g==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-x64-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-XpZ0M+tjoEiSc9c+uZR7FCnOI0uxDRNs1elGOMjeB0pUP1QmvVbZGYNsyLbLoP4u7e3VQN8rie1OQ8/mB6rcJg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.42.tgz", + "integrity": "sha512-N7pQzk9CyE7q0bBN/q0J8s6Db279r5kUZc6d7/wWRe9/zXqC52HQovVyu6iXPIDY4BEzzgbVLhVFXrOuGJ22ZQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.52.4.tgz", + "integrity": "sha512-BTm2qKNnWIQ5auf4deoetINJm2JzvihvGb9R6K/ETwKLql/Bb3Eg2H1FBp1gUb4YGbydMA3jcmQTR73q7J+GAA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "peer": true + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.52.4.tgz", + "integrity": "sha512-P9LDQiC5vpgGFgz7GSM6dKPCiqR3XYN1WwJKA4/BUVDjHpYsf3iBEmVz62uyq20NGYbiGPR5cNHI7T1HqxNs2w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "peer": true + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.52.4.tgz", + "integrity": "sha512-QRWSW+bVccAvZF6cbNZBJwAehmvG9NwfWHwMy4GbWi/BQIA/laTIktebT2ipVjNncqE6GLPxOok5hsECgAxGZg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "peer": true + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.52.4.tgz", + "integrity": "sha512-hZgP05pResAkRJxL1b+7yxCnXPGsXU0fG9Yfd6dUaoGk+FhdPKCJ5L1Sumyxn8kvw8Qi5PvQ8ulenUbRjzeCTw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "peer": true + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.52.4.tgz", + "integrity": "sha512-xmc30VshuBNUd58Xk4TKAEcRZHaXlV+tCxIXELiE9sQuK3kG8ZFgSPi57UBJt8/ogfhAF5Oz4ZSUBN77weM+mQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "peer": true + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.52.4.tgz", + "integrity": "sha512-WdSLpZFjOEqNZGmHflxyifolwAiZmDQzuOzIq9L27ButpCVpD7KzTRtEG1I0wMPFyiyUdOO+4t8GvrnBLQSwpw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.52.4.tgz", + "integrity": "sha512-xRiOu9Of1FZ4SxVbB0iEDXc4ddIcjCv2aj03dmW8UrZIW7aIQ9jVJdLBIhxBI+MaTnGAKyvMwPwQnoOEvP7FgQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.52.4.tgz", + "integrity": "sha512-FbhM2p9TJAmEIEhIgzR4soUcsW49e9veAQCziwbR+XWB2zqJ12b4i/+hel9yLiD8pLncDH4fKIPIbt5238341Q==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.52.4.tgz", + "integrity": "sha512-4n4gVwhPHR9q/g8lKCyz0yuaD0MvDf7dV4f9tHt0C73Mp8h38UCtSCSE6R9iBlTbXlmA8CjpsZoujhszefqueg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.52.4.tgz", + "integrity": "sha512-u0n17nGA0nvi/11gcZKsjkLj1QIpAuPFQbR48Subo7SmZJnGxDpspyw2kbpuoQnyK+9pwf3pAoEXerJs/8Mi9g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.52.4.tgz", + "integrity": "sha512-0G2c2lpYtbTuXo8KEJkDkClE/+/2AFPdPAbmaHoE870foRFs4pBrDehilMcrSScrN/fB/1HTaWO4bqw+ewBzMQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.52.4.tgz", + "integrity": "sha512-teSACug1GyZHmPDv14VNbvZFX779UqWTsd7KtTM9JIZRDI5NUwYSIS30kzI8m06gOPB//jtpqlhmraQ68b5X2g==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.52.4.tgz", + "integrity": "sha512-/MOEW3aHjjs1p4Pw1Xk4+3egRevx8Ji9N6HUIA1Ifh8Q+cg9dremvFCUbOX2Zebz80BwJIgCBUemjqhU5XI5Eg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.52.4.tgz", + "integrity": "sha512-1HHmsRyh845QDpEWzOFtMCph5Ts+9+yllCrREuBR/vg2RogAQGGBRC8lDPrPOMnrdOJ+mt1WLMOC2Kao/UwcvA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.52.4.tgz", + "integrity": "sha512-seoeZp4L/6D1MUyjWkOMRU6/iLmCU2EjbMTyAG4oIOs1/I82Y5lTeaxW0KBfkUdHAWN7j25bpkt0rjnOgAcQcA==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.52.4.tgz", + "integrity": "sha512-Wi6AXf0k0L7E2gteNsNHUs7UMwCIhsCTs6+tqQ5GPwVRWMaflqGec4Sd8n6+FNFDw9vGcReqk2KzBDhCa1DLYg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.52.4.tgz", + "integrity": "sha512-dtBZYjDmCQ9hW+WgEkaffvRRCKm767wWhxsFW3Lw86VXz/uJRuD438/XvbZT//B96Vs8oTA8Q4A0AfHbrxP9zw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "peer": true + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.52.4.tgz", + "integrity": "sha512-1ox+GqgRWqaB1RnyZXL8PD6E5f7YyRUJYnCqKpNzxzP0TkaUh112NDrR9Tt+C8rJ4x5G9Mk8PQR3o7Ku2RKqKA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "peer": true + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.52.4.tgz", + "integrity": "sha512-8GKr640PdFNXwzIE0IrkMWUNUomILLkfeHjXBi/nUvFlpZP+FA8BKGKpacjW6OUUHaNI6sUURxR2U2g78FOHWQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "peer": true + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.52.4.tgz", + "integrity": "sha512-AIy/jdJ7WtJ/F6EcfOb2GjR9UweO0n43jNObQMb6oGxkYTfLcnN7vYYpG+CN3lLxrQkzWnMOoNSHTW54pgbVxw==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "peer": true + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.52.4.tgz", + "integrity": "sha512-UF9KfsH9yEam0UjTwAgdK0anlQ7c8/pWPU2yVjyWcF1I1thABt6WXE47cI71pGiZ8wGvxohBoLnxM04L/wj8mQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "peer": true + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.52.4.tgz", + "integrity": "sha512-bf9PtUa0u8IXDVxzRToFQKsNCRz9qLYfR/MpECxl4mRoWYjAeFjgxj1XdZr2M/GNVpT05p+LgQOHopYDlUu6/w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "peer": true + }, + "node_modules/@sindresorhus/merge-streams": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-2.3.0.tgz", + "integrity": "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@tybys/wasm-util": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz", + "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/ansis": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/ansis/-/ansis-4.2.0.tgz", + "integrity": "sha512-HqZ5rWlFjGiV0tDm3UxxgNRqsOTniqoKZu0pIAfh7TZQMGuZK+hH0drySty0si0QXj1ieop4+SkSfPZBPPkHig==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + } + }, + "node_modules/ast-kit": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ast-kit/-/ast-kit-2.1.3.tgz", + "integrity": "sha512-TH+b3Lv6pUjy/Nu0m6A2JULtdzLpmqF9x1Dhj00ZoEiML8qvVA9j1flkzTKNYgdEhWrjDwtWNpyyCUbfQe514g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.28.4", + "pathe": "^2.0.3" + }, + "engines": { + "node": ">=20.19.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + } + }, + "node_modules/birpc": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.6.1.tgz", + "integrity": "sha512-LPnFhlDpdSH6FJhJyn4M0kFO7vtQ5iPw24FnG0y21q09xC7e8+1LeR31S1MAIrDAHp4m7aas4bEkTDTvMAtebQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/del": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/del/-/del-8.0.1.tgz", + "integrity": "sha512-gPqh0mKTPvaUZGAuHbrBUYKZWBNAeHG7TU3QH5EhVwPMyKvmfJaNXhcD2jTcXsJRRcffuho4vaYweu80dRrMGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "globby": "^14.0.2", + "is-glob": "^4.0.3", + "is-path-cwd": "^3.0.0", + "is-path-inside": "^4.0.0", + "p-map": "^7.0.2", + "presentable-error": "^0.0.1", + "slash": "^5.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/dompurify": { + "version": "3.1.7", + "license": "(MPL-2.0 OR Apache-2.0)", + "peer": true + }, + "node_modules/dts-resolver": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/dts-resolver/-/dts-resolver-2.1.2.tgz", + "integrity": "sha512-xeXHBQkn2ISSXxbJWD828PFjtyg+/UrMDo7W4Ffcs7+YWCquxU8YjV1KoxuiL+eJ5pg3ll+bC6flVv61L3LKZg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.18.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + }, + "peerDependencies": { + "oxc-resolver": ">=11.0.0" + }, + "peerDependenciesMeta": { + "oxc-resolver": { + "optional": true + } + } + }, + "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fastq": { + "version": "1.19.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", + "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-tsconfig": { + "version": "4.11.0", + "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.11.0.tgz", + "integrity": "sha512-sNsqf7XKQ38IawiVGPOoAlqZo1DMrO7TU+ZcZwi7yLl7/7S0JwmoBMKz/IkUPhSoXM0Ng3vT0yB1iCe5XavDeQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve-pkg-maps": "^1.0.0" + }, + "funding": { + "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/globby": { + "version": "14.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-14.1.0.tgz", + "integrity": "sha512-0Ia46fDOaT7k4og1PDW4YbodWWr3scS2vAr2lTbsplOt2WkKp0vQbkI9wKis/T5LV/dqPjO3bpS/z6GTJB82LA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sindresorhus/merge-streams": "^2.1.0", + "fast-glob": "^3.3.3", + "ignore": "^7.0.3", + "path-type": "^6.0.0", + "slash": "^5.1.0", + "unicorn-magic": "^0.3.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ignore": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz", + "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-path-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-3.0.0.tgz", + "integrity": "sha512-kyiNFFLU0Ampr6SDZitD/DwUo4Zs1nSdnygUBqsu3LooL00Qvb5j+UnvApUn/TTj1J3OuE6BTdQ5rudKmU2ZaA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-path-inside": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-4.0.0.tgz", + "integrity": "sha512-lJJV/5dYS+RcL8uQdBDW9c9uWFLLBNRyFhnAKXw5tVqLlKZ4RMGZKv+YQ/IA3OhD+RpbJa1LLFM1FQPGyIXvOA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/magic-string": { + "version": "0.30.19", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.19.tgz", + "integrity": "sha512-2N21sPY9Ws53PZvsEpVtNuSW+ScYbQdp4b9qUaL+9QkHUrGFKo56Lg9Emg5s9V/qrtNBmiR01sYhUOwu3H+VOw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/marked": { + "version": "14.0.0", + "license": "MIT", + "peer": true, + "bin": { + "marked": "bin/marked.js" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/monaco-editor-core": { + "version": "0.54.0", + "license": "MIT", + "peer": true, + "dependencies": { + "dompurify": "3.1.7", + "marked": "14.0.0" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/p-map": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.3.tgz", + "integrity": "sha512-VkndIv2fIB99swvQoA65bm+fsmt6UNdGeIB0oxBs+WhAhdh08QA04JXpI7rbB9r08/nkbysKoya9rtDERYOYMA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/path-type": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-6.0.0.tgz", + "integrity": "sha512-Vj7sf++t5pBD637NSfkxpHSMfWaeig5+DKWLhcqIYx6mWQz5hdJTGDVMQiJcw1ZYkhs7AazKDGpRVji1LJCZUQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true, + "license": "MIT" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/presentable-error": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/presentable-error/-/presentable-error-0.0.1.tgz", + "integrity": "sha512-E6rsNU1QNJgB3sjj7OANinGncFKuK+164sLXw1/CqBjj/EkXSoSdHCtWQGBNlREIGLnL7IEUEGa08YFVUbrhVg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/resolve-pkg-maps": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", + "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rolldown": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-beta.42.tgz", + "integrity": "sha512-xaPcckj+BbJhYLsv8gOqezc8EdMcKKe/gk8v47B0KPvgABDrQ0qmNPAiT/gh9n9Foe0bUkEv2qzj42uU5q1WRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.94.0", + "@rolldown/pluginutils": "1.0.0-beta.42", + "ansis": "=4.2.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm64": "1.0.0-beta.42", + "@rolldown/binding-darwin-arm64": "1.0.0-beta.42", + "@rolldown/binding-darwin-x64": "1.0.0-beta.42", + "@rolldown/binding-freebsd-x64": "1.0.0-beta.42", + "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-beta.42", + "@rolldown/binding-linux-arm64-gnu": "1.0.0-beta.42", + "@rolldown/binding-linux-arm64-musl": "1.0.0-beta.42", + "@rolldown/binding-linux-x64-gnu": "1.0.0-beta.42", + "@rolldown/binding-linux-x64-musl": "1.0.0-beta.42", + "@rolldown/binding-openharmony-arm64": "1.0.0-beta.42", + "@rolldown/binding-wasm32-wasi": "1.0.0-beta.42", + "@rolldown/binding-win32-arm64-msvc": "1.0.0-beta.42", + "@rolldown/binding-win32-ia32-msvc": "1.0.0-beta.42", + "@rolldown/binding-win32-x64-msvc": "1.0.0-beta.42" + } + }, + "node_modules/rolldown-plugin-dts": { + "version": "0.16.11", + "resolved": "https://registry.npmjs.org/rolldown-plugin-dts/-/rolldown-plugin-dts-0.16.11.tgz", + "integrity": "sha512-9IQDaPvPqTx3RjG2eQCK5GYZITo203BxKunGI80AGYicu1ySFTUyugicAaTZWRzFWh9DSnzkgNeMNbDWBbSs0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/generator": "^7.28.3", + "@babel/parser": "^7.28.4", + "@babel/types": "^7.28.4", + "ast-kit": "^2.1.2", + "birpc": "^2.6.1", + "debug": "^4.4.3", + "dts-resolver": "^2.1.2", + "get-tsconfig": "^4.10.1", + "magic-string": "^0.30.19" + }, + "engines": { + "node": ">=20.18.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + }, + "peerDependencies": { + "@ts-macro/tsc": "^0.3.6", + "@typescript/native-preview": ">=7.0.0-dev.20250601.1", + "rolldown": "^1.0.0-beta.9", + "typescript": "^5.0.0", + "vue-tsc": "~3.1.0" + }, + "peerDependenciesMeta": { + "@ts-macro/tsc": { + "optional": true + }, + "@typescript/native-preview": { + "optional": true + }, + "typescript": { + "optional": true + }, + "vue-tsc": { + "optional": true + } + } + }, + "node_modules/rollup": { + "version": "4.52.4", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.4.tgz", + "integrity": "sha512-CLEVl+MnPAiKh5pl4dEWSyMTpuflgNQiLGhMv8ezD5W/qP8AKvmYpCOKRRNOh7oRKnauBZ4SyeYkMS+1VSyKwQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.52.4", + "@rollup/rollup-android-arm64": "4.52.4", + "@rollup/rollup-darwin-arm64": "4.52.4", + "@rollup/rollup-darwin-x64": "4.52.4", + "@rollup/rollup-freebsd-arm64": "4.52.4", + "@rollup/rollup-freebsd-x64": "4.52.4", + "@rollup/rollup-linux-arm-gnueabihf": "4.52.4", + "@rollup/rollup-linux-arm-musleabihf": "4.52.4", + "@rollup/rollup-linux-arm64-gnu": "4.52.4", + "@rollup/rollup-linux-arm64-musl": "4.52.4", + "@rollup/rollup-linux-loong64-gnu": "4.52.4", + "@rollup/rollup-linux-ppc64-gnu": "4.52.4", + "@rollup/rollup-linux-riscv64-gnu": "4.52.4", + "@rollup/rollup-linux-riscv64-musl": "4.52.4", + "@rollup/rollup-linux-s390x-gnu": "4.52.4", + "@rollup/rollup-linux-x64-gnu": "4.52.4", + "@rollup/rollup-linux-x64-musl": "4.52.4", + "@rollup/rollup-openharmony-arm64": "4.52.4", + "@rollup/rollup-win32-arm64-msvc": "4.52.4", + "@rollup/rollup-win32-ia32-msvc": "4.52.4", + "@rollup/rollup-win32-x64-gnu": "4.52.4", + "@rollup/rollup-win32-x64-msvc": "4.52.4", + "fsevents": "~2.3.2" + } + }, + "node_modules/rollup-plugin-delete": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/rollup-plugin-delete/-/rollup-plugin-delete-3.0.1.tgz", + "integrity": "sha512-4tyijMQFwSDLA04DAHwbI2TrRwPiRwAqBQ17dxyr9CgHeHXLdgk8IDVWHFWPrL3UZJWrAmHohQ2MgmVghQDrlg==", + "dev": true, + "license": "MIT", + "dependencies": { + "del": "^8.0.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "rollup": "*" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/slash": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz", + "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, + "license": "0BSD", + "optional": true + }, + "node_modules/unicorn-magic": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz", + "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/monaco-lsp-client/package.json b/monaco-lsp-client/package.json new file mode 100644 index 00000000..98b09fe5 --- /dev/null +++ b/monaco-lsp-client/package.json @@ -0,0 +1,26 @@ +{ + "name": "@vscode/monaco-lsp-client", + "description": "description", + "authors": "vscode", + "version": "0.1.0", + "main": "out/index.js", + "types": "out/index.d.ts", + "dependencies": { + "@hediet/json-rpc": "^0.5.0", + "@hediet/json-rpc-browser": "^0.5.1", + "@hediet/json-rpc-websocket": "^0.5.1" + }, + "peerDependencies": { + "monaco-editor-core": "^0.54.0-dev-20250929" + }, + "devDependencies": { + "rolldown": "^1.0.0-beta.41", + "rolldown-plugin-dts": "^0.16.11", + "rollup-plugin-delete": "^3.0.1" + }, + "scripts": { + "build": "npx rolldown -c rolldown.config.mjs", + "dev": "npx rolldown -c rolldown.config.mjs --watch", + "generate": "tsx generator/index.ts" + } +} diff --git a/monaco-lsp-client/rolldown.config.mjs b/monaco-lsp-client/rolldown.config.mjs new file mode 100644 index 00000000..e6336a2b --- /dev/null +++ b/monaco-lsp-client/rolldown.config.mjs @@ -0,0 +1,33 @@ +// @ts-check + +import { join } from 'path'; +import { defineConfig } from 'rolldown'; +import { dts } from 'rolldown-plugin-dts'; +import del from 'rollup-plugin-delete'; +import alias from '@rollup/plugin-alias'; + +export default defineConfig({ + input: { + index: join(import.meta.dirname, './src/index.ts') + }, + output: { + dir: join(import.meta.dirname, './out'), + format: 'es' + }, + external: ['monaco-editor-core'], + plugins: [ + del({ targets: 'out/*' }), + alias({ + entries: { + ws: 'undefined' + } + }), + dts({ + tsconfig: false, + compilerOptions: { + stripInternal: true + }, + resolve: true + }) + ] +}); diff --git a/monaco-lsp-client/src/adapters/ITextModelBridge.ts b/monaco-lsp-client/src/adapters/ITextModelBridge.ts new file mode 100644 index 00000000..2193bb85 --- /dev/null +++ b/monaco-lsp-client/src/adapters/ITextModelBridge.ts @@ -0,0 +1,40 @@ +import * as monaco from 'monaco-editor-core'; +import { Position, Range, TextDocumentIdentifier } from '../../src/types'; + +export interface ITextModelBridge { + translate( + textModel: monaco.editor.ITextModel, + monacoPos: monaco.Position + ): { + textDocument: TextDocumentIdentifier; + position: Position; + }; + + translateRange(textModel: monaco.editor.ITextModel, monacoRange: monaco.Range): Range; + + translateBack( + textDocument: TextDocumentIdentifier, + position: Position + ): { + textModel: monaco.editor.ITextModel; + position: monaco.Position; + }; + + translateBackRange( + textDocument: TextDocumentIdentifier, + range: Range + ): { + textModel: monaco.editor.ITextModel; + range: monaco.Range; + }; +} + +export function assertTargetTextModel( + input: T, + expectedTextModel: monaco.editor.ITextModel +): T { + if (input.textModel !== expectedTextModel) { + throw new Error(`Expected text model to be ${expectedTextModel}, but got ${input.textModel}`); + } + return input; +} diff --git a/monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts b/monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts new file mode 100644 index 00000000..0f87f574 --- /dev/null +++ b/monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts @@ -0,0 +1,254 @@ +import { TypedChannel } from '@hediet/json-rpc'; +import { ClientCapabilities, Capability, ServerCapabilities, api, capabilities, TextDocumentChangeRegistrationOptions, TextDocumentSyncKind } from '../../src/types'; +import { IDisposable, Disposable } from '../utils'; + +export interface ILspCapabilitiesRegistry { + addStaticClientCapabilities(capability: ClientCapabilities): IDisposable; + registerCapabilityHandler(capability: Capability, handleStaticCapability: boolean, handler: (capability: T) => IDisposable): IDisposable; +} + +export class LspCapabilitiesRegistry extends Disposable implements ILspCapabilitiesRegistry { + private readonly _staticCapabilities = new Set<{ cap: ClientCapabilities; }>(); + private readonly _dynamicFromStatic = DynamicFromStaticOptions.create(); + private readonly _registrations = new Map, CapabilityInfo>(); + private _serverCapabilities: ServerCapabilities | undefined = undefined; + + constructor( + private readonly _connection: TypedChannel + ) { + super(); + + this._register(this._connection.registerRequestHandler(api.client.clientRegisterCapability, async (params) => { + for (const registration of params.registrations) { + const capability = getCapabilityByMethod(registration.method); + const r = new CapabilityRegistration(registration.id, capability, registration.registerOptions, false); + this._registerCapabilityOptions(r); + } + return { ok: null }; + })); + + this._register(this._connection.registerRequestHandler(api.client.clientUnregisterCapability, async (params) => { + for (const unregistration of params.unregisterations) { + const capability = getCapabilityByMethod(unregistration.method); + const info = this._registrations.get(capability); + const handlerInfo = info?.registrations.get(unregistration.id); + if (!handlerInfo) { + throw new Error(`No registration for method ${unregistration.method} with id ${unregistration.id}`); + } + handlerInfo?.handlerDisposables.forEach(d => d.dispose()); + info?.registrations.delete(unregistration.id); + } + return { ok: null }; + })); + } + + private _registerCapabilityOptions(registration: CapabilityRegistration) { + let registrationForMethod = this._registrations.get(registration.capability); + if (!registrationForMethod) { + registrationForMethod = new CapabilityInfo(); + this._registrations.set(registration.capability, registrationForMethod); + } + if (registrationForMethod.registrations.has(registration.id)) { + throw new Error(`Handler for method ${registration.capability.method} with id ${registration.id} already registered`); + } + registrationForMethod.registrations.set(registration.id, registration); + for (const h of registrationForMethod.handlers) { + if (!h.handleStaticCapability && registration.isFromStatic) { + continue; + } + registration.handlerDisposables.set(h, h.handler(registration.options)); + } + } + + setServerCapabilities(serverCapabilities: ServerCapabilities) { + if (this._serverCapabilities) { + throw new Error('Server capabilities already set'); + } + this._serverCapabilities = serverCapabilities; + for (const cap of Object.values(capabilities)) { + const options = this._dynamicFromStatic.getOptions(cap, serverCapabilities); + if (options) { + this._registerCapabilityOptions(new CapabilityRegistration(cap.method, cap, options, true)); + } + } + } + + getClientCapabilities(): ClientCapabilities { + const result: ClientCapabilities = {}; + for (const c of this._staticCapabilities) { + deepAssign(result, c.cap); + } + return result; + } + + addStaticClientCapabilities(capability: ClientCapabilities): IDisposable { + const obj = { cap: capability }; + this._staticCapabilities.add(obj); + return { + dispose: () => { + this._staticCapabilities.delete(obj); + } + }; + } + + registerCapabilityHandler(capability: Capability, handleStaticCapability: boolean, handler: (capability: T) => IDisposable): IDisposable { + let info = this._registrations.get(capability); + if (!info) { + info = new CapabilityInfo(); + this._registrations.set(capability, info); + } + const handlerInfo = new CapabilityHandler(capability, handleStaticCapability, handler); + info.handlers.add(handlerInfo); + + for (const registration of info.registrations.values()) { + if (!handlerInfo.handleStaticCapability && registration.isFromStatic) { + continue; + } + registration.handlerDisposables.set(handlerInfo, handler(registration.options)); + } + + return { + dispose: () => { + info.handlers.delete(handlerInfo); + for (const registration of info.registrations.values()) { + const disposable = registration.handlerDisposables.get(handlerInfo); + if (disposable) { + disposable.dispose(); + registration.handlerDisposables.delete(handlerInfo); + } + } + } + }; + } +} + +class CapabilityHandler { + constructor( + public readonly capability: Capability, + public readonly handleStaticCapability: boolean, + public readonly handler: (capabilityOptions: T) => IDisposable + ) { } +} + +class CapabilityRegistration { + public readonly handlerDisposables = new Map, IDisposable>(); + + constructor( + public readonly id: string, + public readonly capability: Capability, + public readonly options: T, + public readonly isFromStatic: boolean + ) { } +} + +const capabilitiesByMethod = new Map([...Object.values(capabilities)].map(c => [c.method, c])); +function getCapabilityByMethod(method: string): Capability { + const c = capabilitiesByMethod.get(method); + if (!c) { + throw new Error(`No capability found for method ${method}`); + } + return c; +} + +class CapabilityInfo { + public readonly handlers = new Set>(); + public readonly registrations = new Map>(); +} + +class DynamicFromStaticOptions { + private readonly _mappings = new Map any>(); + + public static create(): DynamicFromStaticOptions { + const o = new DynamicFromStaticOptions(); + o.set(capabilities.textDocumentDidChange, s => { + if (s.textDocumentSync === undefined) { + return undefined; + } + if (typeof s.textDocumentSync === 'object') { + return { + syncKind: s.textDocumentSync.change ?? TextDocumentSyncKind.None, + documentSelector: null, + } satisfies TextDocumentChangeRegistrationOptions; + } else { + return { + syncKind: s.textDocumentSync, + documentSelector: null, + } satisfies TextDocumentChangeRegistrationOptions; + } + return null!; + }); + + o.set(capabilities.textDocumentCompletion, s => s.completionProvider); + o.set(capabilities.textDocumentHover, s => s.hoverProvider); + o.set(capabilities.textDocumentSignatureHelp, s => s.signatureHelpProvider); + o.set(capabilities.textDocumentDefinition, s => s.definitionProvider); + o.set(capabilities.textDocumentReferences, s => s.referencesProvider); + o.set(capabilities.textDocumentDocumentHighlight, s => s.documentHighlightProvider); + o.set(capabilities.textDocumentDocumentSymbol, s => s.documentSymbolProvider); + o.set(capabilities.textDocumentCodeAction, s => s.codeActionProvider); + o.set(capabilities.textDocumentCodeLens, s => s.codeLensProvider); + o.set(capabilities.textDocumentDocumentLink, s => s.documentLinkProvider); + o.set(capabilities.textDocumentFormatting, s => s.documentFormattingProvider); + o.set(capabilities.textDocumentRangeFormatting, s => s.documentRangeFormattingProvider); + o.set(capabilities.textDocumentOnTypeFormatting, s => s.documentOnTypeFormattingProvider); + o.set(capabilities.textDocumentRename, s => s.renameProvider); + o.set(capabilities.textDocumentFoldingRange, s => s.foldingRangeProvider); + o.set(capabilities.textDocumentDeclaration, s => s.declarationProvider); + o.set(capabilities.textDocumentTypeDefinition, s => s.typeDefinitionProvider); + o.set(capabilities.textDocumentImplementation, s => s.implementationProvider); + o.set(capabilities.textDocumentDocumentColor, s => s.colorProvider); + o.set(capabilities.textDocumentSelectionRange, s => s.selectionRangeProvider); + o.set(capabilities.textDocumentLinkedEditingRange, s => s.linkedEditingRangeProvider); + o.set(capabilities.textDocumentPrepareCallHierarchy, s => s.callHierarchyProvider); + o.set(capabilities.textDocumentSemanticTokensFull, s => s.semanticTokensProvider); + o.set(capabilities.textDocumentInlayHint, s => s.inlayHintProvider); + o.set(capabilities.textDocumentInlineValue, s => s.inlineValueProvider); + o.set(capabilities.textDocumentDiagnostic, s => s.diagnosticProvider); + o.set(capabilities.textDocumentMoniker, s => s.monikerProvider); + o.set(capabilities.textDocumentPrepareTypeHierarchy, s => s.typeHierarchyProvider); + o.set(capabilities.workspaceSymbol, s => s.workspaceSymbolProvider); + o.set(capabilities.workspaceExecuteCommand, s => s.executeCommandProvider); + return o; + } + + set(capability: Capability, getOptionsFromStatic: (serverCapabilities: ServerCapabilities) => T | boolean | undefined): void { + if (this._mappings.has(capability.method)) { + throw new Error(`Capability for method ${capability.method} already registered`); + } + this._mappings.set(capability.method, getOptionsFromStatic); + } + + getOptions(capability: Capability, serverCapabilities: ServerCapabilities): T | undefined { + const getter = this._mappings.get(capability.method); + if (!getter) { + return undefined; + } + const result = getter(serverCapabilities); + return result; + } +} + +function deepAssign(target: any, source: any) { + for (const key of Object.keys(source)) { + const srcValue = source[key]; + if (srcValue === undefined) { + continue; + } + const tgtValue = target[key]; + if (tgtValue === undefined) { + target[key] = srcValue; + continue; + } + + if (typeof srcValue !== 'object' || srcValue === null) { + target[key] = srcValue; + continue; + } + if (typeof tgtValue !== 'object' || tgtValue === null) { + target[key] = srcValue; + continue; + } + + deepAssign(tgtValue, srcValue); + } +} diff --git a/monaco-lsp-client/src/adapters/LspClient.ts b/monaco-lsp-client/src/adapters/LspClient.ts new file mode 100644 index 00000000..1c5d7321 --- /dev/null +++ b/monaco-lsp-client/src/adapters/LspClient.ts @@ -0,0 +1,90 @@ +import { IMessageTransport, TypedChannel } from "@hediet/json-rpc"; +import { LspCompletionFeature } from "./languageFeatures/LspCompletionFeature"; +import { LspHoverFeature } from "./languageFeatures/LspHoverFeature"; +import { LspSignatureHelpFeature } from "./languageFeatures/LspSignatureHelpFeature"; +import { LspDefinitionFeature } from "./languageFeatures/LspDefinitionFeature"; +import { LspDeclarationFeature } from "./languageFeatures/LspDeclarationFeature"; +import { LspTypeDefinitionFeature } from "./languageFeatures/LspTypeDefinitionFeature"; +import { LspImplementationFeature } from "./languageFeatures/LspImplementationFeature"; +import { LspReferencesFeature } from "./languageFeatures/LspReferencesFeature"; +import { LspDocumentHighlightFeature } from "./languageFeatures/LspDocumentHighlightFeature"; +import { LspDocumentSymbolFeature } from "./languageFeatures/LspDocumentSymbolFeature"; +import { LspRenameFeature } from "./languageFeatures/LspRenameFeature"; +import { LspCodeActionFeature } from "./languageFeatures/LspCodeActionFeature"; +import { LspCodeLensFeature } from "./languageFeatures/LspCodeLensFeature"; +import { LspDocumentLinkFeature } from "./languageFeatures/LspDocumentLinkFeature"; +import { LspFormattingFeature } from "./languageFeatures/LspFormattingFeature"; +import { LspRangeFormattingFeature } from "./languageFeatures/LspRangeFormattingFeature"; +import { LspOnTypeFormattingFeature } from "./languageFeatures/LspOnTypeFormattingFeature"; +import { LspFoldingRangeFeature } from "./languageFeatures/LspFoldingRangeFeature"; +import { LspSelectionRangeFeature } from "./languageFeatures/LspSelectionRangeFeature"; +import { LspInlayHintsFeature } from "./languageFeatures/LspInlayHintsFeature"; +import { LspSemanticTokensFeature } from "./languageFeatures/LspSemanticTokensFeature"; +import { LspDiagnosticsFeature } from "./languageFeatures/LspDiagnosticsFeature"; +import { api } from "../../src/types"; +import { LspConnection } from "./LspConnection"; +import { LspCapabilitiesRegistry } from './LspCapabilitiesRegistry'; +import { TextDocumentSynchronizer } from "./TextDocumentSynchronizer"; +import { DisposableStore, IDisposable } from "../utils"; + +export class MonacoLspClient { + private _connection: LspConnection; + private readonly _capabilitiesRegistry: LspCapabilitiesRegistry; + private readonly _bridge: TextDocumentSynchronizer; + + private _initPromise: Promise; + + constructor(transport: IMessageTransport) { + const c = TypedChannel.fromTransport(transport); + const s = api.getServer(c, {}); + c.startListen(); + + this._capabilitiesRegistry = new LspCapabilitiesRegistry(c); + this._bridge = new TextDocumentSynchronizer(s.server, this._capabilitiesRegistry); + + this._connection = new LspConnection(s.server, this._bridge, this._capabilitiesRegistry, c); + this.createFeatures(); + + this._initPromise = this._init(); + } + + private async _init() { + const result = await this._connection.server.initialize({ + processId: null, + capabilities: this._capabilitiesRegistry.getClientCapabilities(), + rootUri: null, + }); + + this._connection.server.initialized({}); + this._capabilitiesRegistry.setServerCapabilities(result.capabilities); + } + + protected createFeatures(): IDisposable { + const store = new DisposableStore(); + + store.add(new LspCompletionFeature(this._connection)); + store.add(new LspHoverFeature(this._connection)); + store.add(new LspSignatureHelpFeature(this._connection)); + store.add(new LspDefinitionFeature(this._connection)); + store.add(new LspDeclarationFeature(this._connection)); + store.add(new LspTypeDefinitionFeature(this._connection)); + store.add(new LspImplementationFeature(this._connection)); + store.add(new LspReferencesFeature(this._connection)); + store.add(new LspDocumentHighlightFeature(this._connection)); + store.add(new LspDocumentSymbolFeature(this._connection)); + store.add(new LspRenameFeature(this._connection)); + store.add(new LspCodeActionFeature(this._connection)); + store.add(new LspCodeLensFeature(this._connection)); + store.add(new LspDocumentLinkFeature(this._connection)); + store.add(new LspFormattingFeature(this._connection)); + store.add(new LspRangeFormattingFeature(this._connection)); + store.add(new LspOnTypeFormattingFeature(this._connection)); + store.add(new LspFoldingRangeFeature(this._connection)); + store.add(new LspSelectionRangeFeature(this._connection)); + store.add(new LspInlayHintsFeature(this._connection)); + store.add(new LspSemanticTokensFeature(this._connection)); + store.add(new LspDiagnosticsFeature(this._connection)); + + return store; + } +} diff --git a/monaco-lsp-client/src/adapters/LspConnection.ts b/monaco-lsp-client/src/adapters/LspConnection.ts new file mode 100644 index 00000000..b9f619a2 --- /dev/null +++ b/monaco-lsp-client/src/adapters/LspConnection.ts @@ -0,0 +1,13 @@ +import { TypedChannel } from '@hediet/json-rpc'; +import { api } from '../../src/types'; +import { ITextModelBridge } from './ITextModelBridge'; +import { LspCapabilitiesRegistry } from './LspCapabilitiesRegistry'; + +export class LspConnection { + constructor( + public readonly server: typeof api.TServerInterface, + public readonly bridge: ITextModelBridge, + public readonly capabilities: LspCapabilitiesRegistry, + public readonly connection: TypedChannel, + ) { } +} diff --git a/monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts b/monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts new file mode 100644 index 00000000..c2b3620c --- /dev/null +++ b/monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts @@ -0,0 +1,183 @@ +import * as monaco from 'monaco-editor-core'; +import { api, capabilities, Position, Range, TextDocumentContentChangeEvent, TextDocumentIdentifier } from '../../src/types'; +import { Disposable } from '../utils'; +import { ITextModelBridge } from './ITextModelBridge'; +import { ILspCapabilitiesRegistry } from './LspCapabilitiesRegistry'; + +export class TextDocumentSynchronizer extends Disposable implements ITextModelBridge { + private readonly _managedModels = new Map(); + private readonly _managedModelsReverse = new Map(); + + private _started = false; + + constructor( + private readonly _server: typeof api.TServerInterface, + private readonly _capabilities: ILspCapabilitiesRegistry, + ) { + super(); + + this._register(this._capabilities.addStaticClientCapabilities({ + textDocument: { + synchronization: { + dynamicRegistration: true, + willSave: false, + willSaveWaitUntil: false, + didSave: false, + } + } + })); + + this._register(_capabilities.registerCapabilityHandler(capabilities.textDocumentDidChange, true, e => { + if (this._started) { + return { + dispose: () => { + } + } + } + this._started = true; + this._register(monaco.editor.onDidCreateModel(m => { + this._getOrCreateManagedModel(m); + })); + for (const m of monaco.editor.getModels()) { + this._getOrCreateManagedModel(m); + } + return { + dispose: () => { + } + } + })); + } + + private _getOrCreateManagedModel(m: monaco.editor.ITextModel) { + if (!this._started) { + throw new Error('Not started'); + } + + const uriStr = m.uri.toString(true).toLowerCase(); + let mm = this._managedModels.get(m); + if (!mm) { + mm = new ManagedModel(m, this._server); + this._managedModels.set(m, mm); + this._managedModelsReverse.set(uriStr, m); + } + m.onWillDispose(() => { + mm!.dispose(); + this._managedModels.delete(m); + this._managedModelsReverse.delete(uriStr); + }); + return mm; + } + + translateBack(textDocument: TextDocumentIdentifier, position: Position): { textModel: monaco.editor.ITextModel; position: monaco.Position; } { + const uri = textDocument.uri.toLowerCase(); + const textModel = this._managedModelsReverse.get(uri); + if (!textModel) { + throw new Error(`No text model for uri ${uri}`); + } + const monacoPosition = new monaco.Position(position.line + 1, position.character + 1); + return { textModel, position: monacoPosition }; + } + + translateBackRange(textDocument: TextDocumentIdentifier, range: Range): { textModel: monaco.editor.ITextModel; range: monaco.Range; } { + const uri = textDocument.uri.toLowerCase(); + const textModel = this._managedModelsReverse.get(uri); + if (!textModel) { + throw new Error(`No text model for uri ${uri}`); + } + const monacoRange = new monaco.Range( + range.start.line + 1, + range.start.character + 1, + range.end.line + 1, + range.end.character + 1 + ); + return { textModel, range: monacoRange }; + } + + translate(textModel: monaco.editor.ITextModel, monacoPos: monaco.Position): { textDocument: TextDocumentIdentifier; position: Position; } { + return { + textDocument: { + uri: textModel.uri.toString(true), + }, + position: { + line: monacoPos.lineNumber - 1, + character: monacoPos.column - 1, + } + }; + } + + translateRange(textModel: monaco.editor.ITextModel, monacoRange: monaco.Range): Range { + return { + start: { + line: monacoRange.startLineNumber - 1, + character: monacoRange.startColumn - 1, + }, + end: { + line: monacoRange.endLineNumber - 1, + character: monacoRange.endColumn - 1, + } + }; + } +} + +class ManagedModel extends Disposable { + constructor( + private readonly _textModel: monaco.editor.ITextModel, + private readonly _api: typeof api.TServerInterface + ) { + super(); + + const uri = _textModel.uri.toString(true).toLowerCase(); + + this._api.textDocumentDidOpen({ + textDocument: { + languageId: _textModel.getLanguageId(), + uri: uri, + version: _textModel.getVersionId(), + text: _textModel.getValue(), + } + }); + + this._register(_textModel.onDidChangeContent(e => { + const contentChanges = e.changes.map(c => toLspTextDocumentContentChangeEvent(c)); + + this._api.textDocumentDidChange({ + textDocument: { + uri: uri, + version: _textModel.getVersionId(), + }, + contentChanges: contentChanges + }); + })); + + this._register({ + dispose: () => { + this._api.textDocumentDidClose({ + textDocument: { + uri: uri, + } + }); + } + }); + } +} + +function toLspTextDocumentContentChangeEvent(change: monaco.editor.IModelContentChange): TextDocumentContentChangeEvent { + return { + range: toLspRange(change.range), + rangeLength: change.rangeLength, + text: change.text, + }; +} + +function toLspRange(range: monaco.IRange): Range { + return { + start: { + line: range.startLineNumber - 1, + character: range.startColumn - 1, + }, + end: { + line: range.endLineNumber - 1, + character: range.endColumn - 1, + } + }; +} \ No newline at end of file diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts new file mode 100644 index 00000000..aed4e0dd --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts @@ -0,0 +1,169 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, CodeActionRegistrationOptions, Command, WorkspaceEdit, CodeAction } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { lspCodeActionKindToMonacoCodeActionKind, toMonacoCodeActionKind, toLspDiagnosticSeverity, toLspCodeActionTriggerKind, toMonacoCommand } from './common'; + +export class LspCodeActionFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + codeAction: { + dynamicRegistration: true, + codeActionLiteralSupport: { + codeActionKind: { + valueSet: Array.from(lspCodeActionKindToMonacoCodeActionKind.keys()), + } + }, + isPreferredSupport: true, + disabledSupport: true, + dataSupport: true, + resolveSupport: { + properties: ['edit'], + }, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentCodeAction, true, capability => { + return monaco.languages.registerCodeActionProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspCodeActionProvider(this._connection, capability), + ); + })); + } +} + +interface ExtendedCodeAction extends monaco.languages.CodeAction { + _lspAction?: CodeAction; +} + +class LspCodeActionProvider implements monaco.languages.CodeActionProvider { + public readonly resolveCodeAction; + + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: CodeActionRegistrationOptions, + ) { + if (_capabilities.resolveProvider) { + this.resolveCodeAction = async (codeAction: ExtendedCodeAction, token: monaco.CancellationToken): Promise => { + if (codeAction._lspAction) { + const resolved = await this._client.server.codeActionResolve(codeAction._lspAction); + if (resolved.edit) { + codeAction.edit = toMonacoWorkspaceEdit(resolved.edit, this._client); + } + if (resolved.command) { + codeAction.command = toMonacoCommand(resolved.command); + } + } + return codeAction; + }; + } + } + + async provideCodeActions( + model: monaco.editor.ITextModel, + range: monaco.Range, + context: monaco.languages.CodeActionContext, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, range.getStartPosition()); + + const result = await this._client.server.textDocumentCodeAction({ + textDocument: translated.textDocument, + range: this._client.bridge.translateRange(model, range), + context: { + diagnostics: context.markers.map(marker => ({ + range: this._client.bridge.translateRange(model, monaco.Range.lift(marker)), + message: marker.message, + severity: toLspDiagnosticSeverity(marker.severity), + })), + triggerKind: toLspCodeActionTriggerKind(context.trigger), + }, + }); + + if (!result) { + return null; + } + + const actions = Array.isArray(result) ? result : [result]; + + return { + actions: actions.map(action => { + if ('title' in action && !('kind' in action)) { + // Command + const cmd = action as Command; + const monacoAction: ExtendedCodeAction = { + title: cmd.title, + command: toMonacoCommand(cmd), + }; + return monacoAction; + } else { + // CodeAction + const codeAction = action as CodeAction; + const monacoAction: ExtendedCodeAction = { + title: codeAction.title, + kind: toMonacoCodeActionKind(codeAction.kind), + isPreferred: codeAction.isPreferred, + disabled: codeAction.disabled?.reason, + edit: codeAction.edit ? toMonacoWorkspaceEdit(codeAction.edit, this._client) : undefined, + command: toMonacoCommand(codeAction.command), + _lspAction: codeAction, + }; + return monacoAction; + } + }), + dispose: () => { }, + }; + } +} + +function toMonacoWorkspaceEdit( + edit: WorkspaceEdit, + client: LspConnection +): monaco.languages.WorkspaceEdit { + const edits: monaco.languages.IWorkspaceTextEdit[] = []; + + if (edit.changes) { + for (const uri in edit.changes) { + const textEdits = edit.changes[uri]; + for (const textEdit of textEdits) { + const translated = client.bridge.translateBackRange({ uri }, textEdit.range); + edits.push({ + resource: translated.textModel.uri, + versionId: undefined, + textEdit: { + range: translated.range, + text: textEdit.newText, + }, + }); + } + } + } + + if (edit.documentChanges) { + for (const change of edit.documentChanges) { + if ('textDocument' in change) { + const uri = change.textDocument.uri; + for (const textEdit of change.edits) { + const translated = client.bridge.translateBackRange({ uri }, textEdit.range); + edits.push({ + resource: translated.textModel.uri, + versionId: change.textDocument.version ?? undefined, + textEdit: { + range: translated.range, + text: textEdit.newText, + }, + }); + } + } + } + } + + return { edits }; +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts new file mode 100644 index 00000000..f11fdf71 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts @@ -0,0 +1,90 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, CodeLensRegistrationOptions, CodeLens } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { assertTargetTextModel } from '../ITextModelBridge'; +import { toMonacoCommand } from './common'; + +export class LspCodeLensFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + codeLens: { + dynamicRegistration: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentCodeLens, true, capability => { + return monaco.languages.registerCodeLensProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspCodeLensProvider(this._connection, capability), + ); + })); + } +} + +interface ExtendedCodeLens extends monaco.languages.CodeLens { + _lspCodeLens?: CodeLens; +} + +class LspCodeLensProvider implements monaco.languages.CodeLensProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: CodeLensRegistrationOptions, + ) { } + + async provideCodeLenses( + model: monaco.editor.ITextModel, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, new monaco.Position(1, 1)); + + const result = await this._client.server.textDocumentCodeLens({ + textDocument: translated.textDocument, + }); + + if (!result) { + return null; + } + + return { + lenses: result.map(lens => { + const monacoLens: ExtendedCodeLens = { + range: assertTargetTextModel(this._client.bridge.translateBackRange(translated.textDocument, lens.range), model).range, + command: toMonacoCommand(lens.command), + _lspCodeLens: lens, + }; + return monacoLens; + }), + dispose: () => { }, + }; + } + + async resolveCodeLens( + model: monaco.editor.ITextModel, + codeLens: ExtendedCodeLens, + token: monaco.CancellationToken + ): Promise { + if (!this._capabilities.resolveProvider || !codeLens._lspCodeLens) { + return codeLens; + } + + const resolved = await this._client.server.codeLensResolve(codeLens._lspCodeLens); + + if (resolved.command) { + codeLens.command = { + id: resolved.command.command, + title: resolved.command.title, + arguments: resolved.command.arguments, + }; + } + + return codeLens; + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts new file mode 100644 index 00000000..2c11ea1a --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts @@ -0,0 +1,202 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, CompletionRegistrationOptions, MarkupContent, CompletionItem, TextDocumentPositionParams } from '../../../src/types'; +import { assertTargetTextModel, ITextModelBridge } from '../ITextModelBridge'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { + lspCompletionItemKindToMonacoCompletionItemKind, + lspCompletionItemTagToMonacoCompletionItemTag, + toMonacoCompletionItemKind, + toMonacoCompletionItemTag, + toLspCompletionTriggerKind, + toMonacoInsertTextRules, + toMonacoCommand, +} from './common'; + +export class LspCompletionFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + completion: { + dynamicRegistration: true, + contextSupport: true, + completionItemKind: { + valueSet: Array.from(lspCompletionItemKindToMonacoCompletionItemKind.keys()), + }, + completionItem: { + tagSupport: { + valueSet: Array.from(lspCompletionItemTagToMonacoCompletionItemTag.keys()), + }, + commitCharactersSupport: true, + deprecatedSupport: true, + preselectSupport: true, + } + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentCompletion, true, capability => { + return monaco.languages.registerCompletionItemProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspCompletionProvider(this._connection, capability), + ); + })); + } +} + +interface ExtendedCompletionItem extends monaco.languages.CompletionItem { + _lspItem: CompletionItem; + _translated: TextDocumentPositionParams; + _model: monaco.editor.ITextModel; +} + +class LspCompletionProvider implements monaco.languages.CompletionItemProvider { + public readonly resolveCompletionItem; + + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: CompletionRegistrationOptions, + ) { + if (_capabilities.resolveProvider) { + this.resolveCompletionItem = async (item: ExtendedCompletionItem, token: monaco.CancellationToken): Promise => { + const resolved = await this._client.server.completionItemResolve(item._lspItem); + applyLspCompletionItemProperties(item, resolved, this._client.bridge, item._translated, item._model); + return item; + } + } + } + + get triggerCharacters(): string[] | undefined { + return this._capabilities.triggerCharacters; + } + + async provideCompletionItems( + model: monaco.editor.ITextModel, + position: monaco.Position, + context: monaco.languages.CompletionContext, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentCompletion({ + textDocument: translated.textDocument, + position: translated.position, + context: context.triggerCharacter ? { + triggerKind: toLspCompletionTriggerKind(context.triggerKind), + triggerCharacter: context.triggerCharacter, + } : undefined, + }); + if (!result) { + return { suggestions: [] }; + } + + const items = Array.isArray(result) ? result : result.items; + + return { + suggestions: items.map(i => { + const item: ExtendedCompletionItem = { + ...convertLspToMonacoCompletionItem( + i, + this._client.bridge, + translated, + model, + position + ), + _lspItem: i, + _translated: translated, + _model: model, + }; + + return item; + }) + }; + } +} + +function convertLspToMonacoCompletionItem( + lspItem: CompletionItem, + bridge: ITextModelBridge, + translated: TextDocumentPositionParams, + model: monaco.editor.ITextModel, + position: monaco.Position +): monaco.languages.CompletionItem { + let insertText = lspItem.insertText || lspItem.label; + let range: monaco.IRange | monaco.languages.CompletionItemRanges | undefined = undefined; + + if (lspItem.textEdit) { + if ('range' in lspItem.textEdit) { + insertText = lspItem.textEdit.newText; + range = assertTargetTextModel(bridge.translateBackRange(translated.textDocument, lspItem.textEdit.range), model).range; + } else { + insertText = lspItem.textEdit.newText; + range = { + insert: assertTargetTextModel(bridge.translateBackRange(translated.textDocument, lspItem.textEdit.insert), model).range, + replace: assertTargetTextModel(bridge.translateBackRange(translated.textDocument, lspItem.textEdit.replace), model).range, + }; + } + } + + if (!range) { + range = monaco.Range.fromPositions(position, position); + } + + const item: monaco.languages.CompletionItem = { + label: lspItem.label, + kind: toMonacoCompletionItemKind(lspItem.kind), + insertText, + sortText: lspItem.sortText, + filterText: lspItem.filterText, + preselect: lspItem.preselect, + commitCharacters: lspItem.commitCharacters, + range: range, + }; + + applyLspCompletionItemProperties(item, lspItem, bridge, translated, model); + + return item; +} + +function applyLspCompletionItemProperties( + monacoItem: monaco.languages.CompletionItem, + lspItem: CompletionItem, + bridge: ITextModelBridge, + translated: TextDocumentPositionParams, + targetModel: monaco.editor.ITextModel +): void { + if (lspItem.detail !== undefined) { + monacoItem.detail = lspItem.detail; + } + if (lspItem.documentation !== undefined) { + monacoItem.documentation = toMonacoDocumentation(lspItem.documentation); + } + if (lspItem.insertTextFormat !== undefined) { + const insertTextRules = toMonacoInsertTextRules(lspItem.insertTextFormat); + monacoItem.insertTextRules = insertTextRules; + } + if (lspItem.tags && lspItem.tags.length > 0) { + monacoItem.tags = lspItem.tags.map(toMonacoCompletionItemTag).filter((tag): tag is monaco.languages.CompletionItemTag => tag !== undefined); + } + if (lspItem.additionalTextEdits && lspItem.additionalTextEdits.length > 0) { + monacoItem.additionalTextEdits = lspItem.additionalTextEdits.map(edit => ({ + range: assertTargetTextModel(bridge.translateBackRange(translated.textDocument, edit.range), targetModel).range, + text: edit.newText, + })); + } + if (lspItem.command) { + monacoItem.command = toMonacoCommand(lspItem.command); + } +} + +function toMonacoDocumentation(doc: string | MarkupContent | undefined): string | monaco.IMarkdownString | undefined { + if (!doc) return undefined; + if (typeof doc === 'string') return doc; + return { + value: doc.value, + isTrusted: true, + }; +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts new file mode 100644 index 00000000..ab306047 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts @@ -0,0 +1,60 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DeclarationRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { toMonacoLocation } from "./common"; + +export class LspDeclarationFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + declaration: { + dynamicRegistration: true, + linkSupport: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDeclaration, true, capability => { + return monaco.languages.registerDeclarationProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspDeclarationProvider(this._connection, capability), + ); + })); + } +} + +class LspDeclarationProvider implements monaco.languages.DeclarationProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DeclarationRegistrationOptions, + ) { } + + async provideDeclaration( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentDeclaration({ + textDocument: translated.textDocument, + position: translated.position, + }); + + if (!result) { + return null; + } + + if (Array.isArray(result)) { + return result.map(loc => toMonacoLocation(loc, this._client)); + } + + return toMonacoLocation(result, this._client); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts new file mode 100644 index 00000000..bf87f896 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts @@ -0,0 +1,60 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DefinitionRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { toMonacoLocation } from "./common"; + +export class LspDefinitionFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + definition: { + dynamicRegistration: true, + linkSupport: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDefinition, true, capability => { + return monaco.languages.registerDefinitionProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspDefinitionProvider(this._connection, capability), + ); + })); + } +} + +class LspDefinitionProvider implements monaco.languages.DefinitionProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DefinitionRegistrationOptions, + ) { } + + async provideDefinition( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentDefinition({ + textDocument: translated.textDocument, + position: translated.position, + }); + + if (!result) { + return null; + } + + if (Array.isArray(result)) { + return result.map(loc => toMonacoLocation(loc, this._client)); + } + + return toMonacoLocation(result, this._client); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts new file mode 100644 index 00000000..2ba7bdea --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts @@ -0,0 +1,208 @@ +import * as monaco from 'monaco-editor-core'; +import { api, capabilities, Diagnostic, DiagnosticRegistrationOptions, DocumentDiagnosticReport, PublishDiagnosticsParams } from '../../../src/types'; +import { Disposable, DisposableStore } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { lspDiagnosticTagToMonacoMarkerTag, matchesDocumentSelector, toDiagnosticMarker } from './common'; + +export class LspDiagnosticsFeature extends Disposable { + private readonly _diagnosticsMarkerOwner = 'lsp'; + private readonly _pullDiagnosticProviders = new Map(); + + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + publishDiagnostics: { + relatedInformation: true, + tagSupport: { + valueSet: [...lspDiagnosticTagToMonacoMarkerTag.keys()], + }, + versionSupport: true, + codeDescriptionSupport: true, + dataSupport: true, + }, + diagnostic: { + dynamicRegistration: true, + relatedDocumentSupport: true, + } + } + })); + + debugger; + this._register(this._connection.connection.registerNotificationHandler( + api.client.textDocumentPublishDiagnostics, + (params) => this._handlePublishDiagnostics(params) + )); + + this._register(this._connection.capabilities.registerCapabilityHandler( + capabilities.textDocumentDiagnostic, + true, + (capability) => { + const disposables = new DisposableStore(); + for (const model of monaco.editor.getModels()) { + this._addPullDiagnosticProvider(model, capability, disposables); + } + disposables.add(monaco.editor.onDidCreateModel(model => { + this._addPullDiagnosticProvider(model, capability, disposables); + })); + return disposables; + } + )); + } + + private _addPullDiagnosticProvider( + model: monaco.editor.ITextModel, + capability: DiagnosticRegistrationOptions, + disposables: DisposableStore + ): void { + // Check if model matches the document selector + const languageId = model.getLanguageId(); + + if (!matchesDocumentSelector(model, capability.documentSelector)) { + return; + } + + const provider = new ModelDiagnosticProvider( + model, + this._connection, + this._diagnosticsMarkerOwner, + capability + ); + + this._pullDiagnosticProviders.set(model, provider); + disposables.add(provider); + + disposables.add(model.onWillDispose(() => { + this._pullDiagnosticProviders.delete(model); + })); + } + + private _handlePublishDiagnostics(params: PublishDiagnosticsParams): void { + const uri = params.uri; + + try { + const translated = this._connection.bridge.translateBack({ uri }, { line: 0, character: 0 }); + const model = translated.textModel; + + if (!model || model.isDisposed()) { + return; + } + + const markers = params.diagnostics.map(diagnostic => + toDiagnosticMarker(diagnostic) + ); + + monaco.editor.setModelMarkers(model, this._diagnosticsMarkerOwner, markers); + } catch (error) { + // Model not found or already disposed - this is normal when files are closed + console.debug(`Could not set diagnostics for ${uri}:`, error); + } + } +} + +/** + * Manages pull diagnostics for a single text model + */ +class ModelDiagnosticProvider extends Disposable { + private _updateHandle: number | undefined; + private _previousResultId: string | undefined; + + constructor( + private readonly _model: monaco.editor.ITextModel, + private readonly _connection: LspConnection, + private readonly _markerOwner: string, + private readonly _capability: DiagnosticRegistrationOptions, + ) { + super(); + this._register(this._model.onDidChangeContent(() => { + this._scheduleDiagnosticUpdate(); + })); + this._scheduleDiagnosticUpdate(); + } + + private _scheduleDiagnosticUpdate(): void { + if (this._updateHandle !== undefined) { + clearTimeout(this._updateHandle); + } + + this._updateHandle = window.setTimeout(() => { + this._updateHandle = undefined; + this._requestDiagnostics(); + }, 500); + } + + private async _requestDiagnostics(): Promise { + if (this._model.isDisposed()) { + return; + } + + try { + const translated = this._connection.bridge.translate(this._model, new monaco.Position(1, 1)); + + const result = await this._connection.server.textDocumentDiagnostic({ + textDocument: translated.textDocument, + identifier: this._capability.identifier, + previousResultId: this._previousResultId, + }); + + if (this._model.isDisposed()) { + return; + } + + this._handleDiagnosticReport(result); + } catch (error) { + console.error('Error requesting diagnostics:', error); + } + } + + private _handleDiagnosticReport(report: DocumentDiagnosticReport): void { + if (report.kind === 'full') { + // Full diagnostic report + this._previousResultId = report.resultId; + + const markers = report.items.map(diagnostic => toDiagnosticMarker(diagnostic)); + monaco.editor.setModelMarkers(this._model, this._markerOwner, markers); + + // Handle related documents if present + if ('relatedDocuments' in report && report.relatedDocuments) { + this._handleRelatedDocuments(report.relatedDocuments); + } + } else if (report.kind === 'unchanged') { + // Unchanged report - diagnostics are still valid + this._previousResultId = report.resultId; + // No need to update markers + } + } + + private _handleRelatedDocuments(relatedDocuments: { [key: string]: any }): void { + for (const [uri, report] of Object.entries(relatedDocuments)) { + try { + const translated = this._connection.bridge.translateBack({ uri }, { line: 0, character: 0 }); + const model = translated.textModel; + + if (!model || model.isDisposed()) { + continue; + } + + if (report.kind === 'full') { + const markers = report.items.map((diagnostic: Diagnostic) => toDiagnosticMarker(diagnostic)); + monaco.editor.setModelMarkers(model, this._markerOwner, markers); + } + } catch (error) { + // Model not found - this is normal + console.debug(`Could not set related diagnostics for ${uri}:`, error); + } + } + } + + override dispose(): void { + if (this._updateHandle !== undefined) { + clearTimeout(this._updateHandle); + this._updateHandle = undefined; + } + super.dispose(); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts new file mode 100644 index 00000000..b07aad78 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts @@ -0,0 +1,58 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DocumentHighlightRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { toMonacoDocumentHighlightKind } from './common'; + +export class LspDocumentHighlightFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + documentHighlight: { + dynamicRegistration: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDocumentHighlight, true, capability => { + return monaco.languages.registerDocumentHighlightProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspDocumentHighlightProvider(this._connection, capability), + ); + })); + } +} + +class LspDocumentHighlightProvider implements monaco.languages.DocumentHighlightProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DocumentHighlightRegistrationOptions, + ) { } + + async provideDocumentHighlights( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentDocumentHighlight({ + textDocument: translated.textDocument, + position: translated.position, + }); + + if (!result) { + return null; + } + + return result.map(highlight => ({ + range: this._client.bridge.translateBackRange(translated.textDocument, highlight.range).range, + kind: toMonacoDocumentHighlightKind(highlight.kind), + })); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts new file mode 100644 index 00000000..8825b10f --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts @@ -0,0 +1,71 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DocumentLinkRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspDocumentLinkFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + documentLink: { + dynamicRegistration: true, + tooltipSupport: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDocumentLink, true, capability => { + return monaco.languages.registerLinkProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspDocumentLinkProvider(this._connection, capability), + ); + })); + } +} + +class LspDocumentLinkProvider implements monaco.languages.LinkProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DocumentLinkRegistrationOptions, + ) { } + + async provideLinks( + model: monaco.editor.ITextModel, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, new monaco.Position(1, 1)); + + const result = await this._client.server.textDocumentDocumentLink({ + textDocument: translated.textDocument, + }); + + if (!result) { + return null; + } + + return { + links: result.map(link => ({ + range: this._client.bridge.translateBackRange(translated.textDocument, link.range).range, + url: link.target, + tooltip: link.tooltip, + })), + }; + } + + async resolveLink( + link: monaco.languages.ILink, + token: monaco.CancellationToken + ): Promise { + if (!this._capabilities.resolveProvider) { + return link; + } + + // TODO: Implement resolve + return link; + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts new file mode 100644 index 00000000..4f3b4a35 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts @@ -0,0 +1,101 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DocumentSymbolRegistrationOptions, DocumentSymbol, SymbolInformation, SymbolTag } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { lspSymbolKindToMonacoSymbolKind, toMonacoSymbolKind, toMonacoSymbolTag } from './common'; + +export class LspDocumentSymbolFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + documentSymbol: { + dynamicRegistration: true, + hierarchicalDocumentSymbolSupport: true, + symbolKind: { + valueSet: Array.from(lspSymbolKindToMonacoSymbolKind.keys()), + }, + tagSupport: { + valueSet: [SymbolTag.Deprecated], + }, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentDocumentSymbol, true, capability => { + return monaco.languages.registerDocumentSymbolProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspDocumentSymbolProvider(this._connection, capability), + ); + })); + } +} + +class LspDocumentSymbolProvider implements monaco.languages.DocumentSymbolProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DocumentSymbolRegistrationOptions, + ) { } + + async provideDocumentSymbols( + model: monaco.editor.ITextModel, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, new monaco.Position(1, 1)); + + const result = await this._client.server.textDocumentDocumentSymbol({ + textDocument: translated.textDocument, + }); + + if (!result) { + return null; + } + + if (Array.isArray(result) && result.length > 0) { + if ('location' in result[0]) { + // SymbolInformation[] + return (result as SymbolInformation[]).map(symbol => toMonacoSymbolInformation(symbol, this._client)); + } else { + // DocumentSymbol[] + return (result as DocumentSymbol[]).map(symbol => toMonacoDocumentSymbol(symbol, this._client, translated.textDocument)); + } + } + + return []; + } +} + +function toMonacoDocumentSymbol( + symbol: DocumentSymbol, + client: LspConnection, + textDocument: { uri: string } +): monaco.languages.DocumentSymbol { + return { + name: symbol.name, + detail: symbol.detail || '', + kind: toMonacoSymbolKind(symbol.kind), + tags: symbol.tags?.map(tag => toMonacoSymbolTag(tag)).filter((t): t is monaco.languages.SymbolTag => t !== undefined) || [], + range: client.bridge.translateBackRange(textDocument, symbol.range).range, + selectionRange: client.bridge.translateBackRange(textDocument, symbol.selectionRange).range, + children: symbol.children?.map(child => toMonacoDocumentSymbol(child, client, textDocument)) || [], + }; +} + +function toMonacoSymbolInformation( + symbol: SymbolInformation, + client: LspConnection +): monaco.languages.DocumentSymbol { + return { + name: symbol.name, + detail: '', + kind: toMonacoSymbolKind(symbol.kind), + tags: symbol.tags?.map(tag => toMonacoSymbolTag(tag)).filter((t): t is monaco.languages.SymbolTag => t !== undefined) || [], + range: client.bridge.translateBackRange({ uri: symbol.location.uri }, symbol.location.range).range, + selectionRange: client.bridge.translateBackRange({ uri: symbol.location.uri }, symbol.location.range).range, + children: [], + }; +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts new file mode 100644 index 00000000..36218023 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts @@ -0,0 +1,63 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, FoldingRangeRegistrationOptions, FoldingRangeKind } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { toMonacoFoldingRangeKind } from './common'; + +export class LspFoldingRangeFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + foldingRange: { + dynamicRegistration: true, + rangeLimit: 5000, + lineFoldingOnly: false, + foldingRangeKind: { + valueSet: [FoldingRangeKind.Comment, FoldingRangeKind.Imports, FoldingRangeKind.Region], + }, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentFoldingRange, true, capability => { + return monaco.languages.registerFoldingRangeProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspFoldingRangeProvider(this._connection, capability), + ); + })); + } +} + +class LspFoldingRangeProvider implements monaco.languages.FoldingRangeProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: FoldingRangeRegistrationOptions, + ) { } + + async provideFoldingRanges( + model: monaco.editor.ITextModel, + context: monaco.languages.FoldingContext, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, new monaco.Position(1, 1)); + + const result = await this._client.server.textDocumentFoldingRange({ + textDocument: translated.textDocument, + }); + + if (!result) { + return null; + } + + return result.map(range => ({ + start: range.startLine + 1, + end: range.endLine + 1, + kind: toMonacoFoldingRangeKind(range.kind), + })); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts new file mode 100644 index 00000000..6a3bdc69 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts @@ -0,0 +1,60 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DocumentFormattingRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspFormattingFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + formatting: { + dynamicRegistration: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentFormatting, true, capability => { + return monaco.languages.registerDocumentFormattingEditProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspDocumentFormattingProvider(this._connection, capability), + ); + })); + } +} + +class LspDocumentFormattingProvider implements monaco.languages.DocumentFormattingEditProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DocumentFormattingRegistrationOptions, + ) { } + + async provideDocumentFormattingEdits( + model: monaco.editor.ITextModel, + options: monaco.languages.FormattingOptions, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, new monaco.Position(1, 1)); + + const result = await this._client.server.textDocumentFormatting({ + textDocument: translated.textDocument, + options: { + tabSize: options.tabSize, + insertSpaces: options.insertSpaces, + }, + }); + + if (!result) { + return null; + } + + return result.map(edit => ({ + range: this._client.bridge.translateBackRange(translated.textDocument, edit.range).range, + text: edit.newText, + })); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts new file mode 100644 index 00000000..6a8fda53 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts @@ -0,0 +1,79 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, HoverRegistrationOptions, MarkupContent, MarkedString, MarkupKind } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspHoverFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + hover: { + dynamicRegistration: true, + contentFormat: [MarkupKind.Markdown, MarkupKind.PlainText], + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentHover, true, capability => { + return monaco.languages.registerHoverProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspHoverProvider(this._connection, capability), + ); + })); + } +} + +class LspHoverProvider implements monaco.languages.HoverProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: HoverRegistrationOptions, + ) { } + + async provideHover( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentHover({ + textDocument: translated.textDocument, + position: translated.position, + }); + + if (!result || !result.contents) { + return null; + } + + return { + contents: toMonacoMarkdownString(result.contents), + range: result.range ? this._client.bridge.translateBackRange(translated.textDocument, result.range).range : undefined, + }; + } +} + +function toMonacoMarkdownString( + contents: MarkupContent | MarkedString | MarkedString[] +): monaco.IMarkdownString[] { + if (Array.isArray(contents)) { + return contents.map(c => toSingleMarkdownString(c)); + } + return [toSingleMarkdownString(contents)]; +} + +function toSingleMarkdownString(content: MarkupContent | MarkedString): monaco.IMarkdownString { + if (typeof content === 'string') { + return { value: content, isTrusted: true }; + } + if ('kind' in content) { + // MarkupContent + return { value: content.value, isTrusted: true }; + } + // MarkedString with language + return { value: `\`\`\`${content.language}\n${content.value}\n\`\`\``, isTrusted: true }; +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts new file mode 100644 index 00000000..9dd2d06e --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts @@ -0,0 +1,60 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, ImplementationRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { toMonacoLocation } from "./common"; + +export class LspImplementationFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + implementation: { + dynamicRegistration: true, + linkSupport: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentImplementation, true, capability => { + return monaco.languages.registerImplementationProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspImplementationProvider(this._connection, capability), + ); + })); + } +} + +class LspImplementationProvider implements monaco.languages.ImplementationProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: ImplementationRegistrationOptions, + ) { } + + async provideImplementation( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentImplementation({ + textDocument: translated.textDocument, + position: translated.position, + }); + + if (!result) { + return null; + } + + if (Array.isArray(result)) { + return result.map(loc => toMonacoLocation(loc, this._client)); + } + + return toMonacoLocation(result, this._client); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts new file mode 100644 index 00000000..2ef9e63d --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts @@ -0,0 +1,212 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, InlayHintRegistrationOptions, InlayHint, MarkupContent, api } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { assertTargetTextModel } from '../ITextModelBridge'; +import { toMonacoCommand, toMonacoInlayHintKind } from './common'; + +export class LspInlayHintsFeature extends Disposable { + private readonly _providers = new Set(); + + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + inlayHint: { + dynamicRegistration: true, + resolveSupport: { + properties: ['tooltip', 'textEdits', 'label.tooltip', 'label.location', 'label.command'], + }, + } + }, + workspace: { + inlayHint: { + refreshSupport: true, + } + } + })); + + this._register(this._connection.connection.registerRequestHandler(api.client.workspaceInlayHintRefresh, async () => { + // Fire onDidChangeInlayHints for all providers + for (const provider of this._providers) { + provider.refresh(); + } + return { ok: null }; + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentInlayHint, true, capability => { + const provider = new LspInlayHintsProvider(this._connection, capability); + this._providers.add(provider); + + const disposable = monaco.languages.registerInlayHintsProvider( + toMonacoLanguageSelector(capability.documentSelector), + provider, + ); + + return { + dispose: () => { + this._providers.delete(provider); + disposable.dispose(); + } + }; + })); + } +} + +interface ExtendedInlayHint extends monaco.languages.InlayHint { + _lspInlayHint: InlayHint; + _targetUri: string; +} + +class LspInlayHintsProvider implements monaco.languages.InlayHintsProvider { + private readonly _onDidChangeInlayHints = new monaco.Emitter(); + public readonly onDidChangeInlayHints = this._onDidChangeInlayHints.event; + + public readonly resolveInlayHint; + + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: InlayHintRegistrationOptions, + ) { + if (_capabilities.resolveProvider) { + this.resolveInlayHint = async (hint: ExtendedInlayHint, token: monaco.CancellationToken): Promise => { + + const resolved = await this._client.server.inlayHintResolve(hint._lspInlayHint); + + if (resolved.tooltip) { + hint.tooltip = toMonacoTooltip(resolved.tooltip); + } + + if (resolved.label !== hint._lspInlayHint.label) { + hint.label = toLspInlayHintLabel(resolved.label); + } + + if (resolved.textEdits) { + hint.textEdits = resolved.textEdits.map(edit => { + const translated = this._client.bridge.translateBackRange( + { uri: hint._targetUri }, + edit.range + ); + return { + range: translated.range, + text: edit.newText, + }; + }); + } + + return hint; + }; + } + } + + public refresh(): void { + this._onDidChangeInlayHints.fire(); + } + + async provideInlayHints( + model: monaco.editor.ITextModel, + range: monaco.Range, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, range.getStartPosition()); + + const result = await retryOnContentModified(async () => + await this._client.server.textDocumentInlayHint({ + textDocument: translated.textDocument, + range: this._client.bridge.translateRange(model, range), + }) + ); + + if (!result) { + return null; + } + + return { + hints: result.map(hint => { + const monacoHint: ExtendedInlayHint = { + label: toLspInlayHintLabel(hint.label), + position: assertTargetTextModel( + this._client.bridge.translateBack(translated.textDocument, hint.position), + model + ).position, + kind: toMonacoInlayHintKind(hint.kind), + tooltip: toMonacoTooltip(hint.tooltip), + paddingLeft: hint.paddingLeft, + paddingRight: hint.paddingRight, + textEdits: hint.textEdits?.map(edit => ({ + range: assertTargetTextModel( + this._client.bridge.translateBackRange(translated.textDocument, edit.range), + model + ).range, + text: edit.newText, + })), + _lspInlayHint: hint, + _targetUri: translated.textDocument.uri, + }; + return monacoHint; + }), + dispose: () => { }, + }; + } +} + +async function retryOnContentModified(cb: () => Promise): Promise { + const nRetries = 3; + for (let triesLeft = nRetries; ; triesLeft--) { + try { + return await cb(); + } catch (e: any) { + if (e.message === 'content modified' && triesLeft > 0) { + continue; + } + throw e; + } + } +} + +function toLspInlayHintLabel(label: string | any[]): string | monaco.languages.InlayHintLabelPart[] { + if (typeof label === 'string') { + return label; + } + + return label.map(part => { + const monacoLabelPart: monaco.languages.InlayHintLabelPart = { + label: part.value, + tooltip: toMonacoTooltip(part.tooltip), + command: toMonacoCommand(part.command), + }; + + if (part.location) { + monacoLabelPart.location = { + uri: monaco.Uri.parse(part.location.uri), + range: new monaco.Range( + part.location.range.start.line + 1, + part.location.range.start.character + 1, + part.location.range.end.line + 1, + part.location.range.end.character + 1 + ), + }; + } + + return monacoLabelPart; + }); +} + +function toMonacoTooltip(tooltip: string | MarkupContent | undefined): string | monaco.IMarkdownString | undefined { + if (!tooltip) { + return undefined; + } + + if (typeof tooltip === 'string') { + return tooltip; + } + + return { + value: tooltip.value, + isTrusted: true, + }; +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts new file mode 100644 index 00000000..77b50223 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts @@ -0,0 +1,71 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DocumentOnTypeFormattingRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspOnTypeFormattingFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + onTypeFormatting: { + dynamicRegistration: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentOnTypeFormatting, true, capability => { + return monaco.languages.registerOnTypeFormattingEditProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspOnTypeFormattingProvider(this._connection, capability), + ); + })); + } +} + +class LspOnTypeFormattingProvider implements monaco.languages.OnTypeFormattingEditProvider { + public readonly autoFormatTriggerCharacters: string[]; + + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DocumentOnTypeFormattingRegistrationOptions, + ) { + this.autoFormatTriggerCharacters = [ + _capabilities.firstTriggerCharacter, + ...(_capabilities.moreTriggerCharacter || []) + ]; + } + + async provideOnTypeFormattingEdits( + model: monaco.editor.ITextModel, + position: monaco.Position, + ch: string, + options: monaco.languages.FormattingOptions, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentOnTypeFormatting({ + textDocument: translated.textDocument, + position: translated.position, + ch, + options: { + tabSize: options.tabSize, + insertSpaces: options.insertSpaces, + }, + }); + + if (!result) { + return null; + } + + return result.map(edit => ({ + range: this._client.bridge.translateBackRange(translated.textDocument, edit.range).range, + text: edit.newText, + })); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts new file mode 100644 index 00000000..5cc79ec5 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts @@ -0,0 +1,62 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, DocumentRangeFormattingRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspRangeFormattingFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + rangeFormatting: { + dynamicRegistration: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentRangeFormatting, true, capability => { + return monaco.languages.registerDocumentRangeFormattingEditProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspDocumentRangeFormattingProvider(this._connection, capability), + ); + })); + } +} + +class LspDocumentRangeFormattingProvider implements monaco.languages.DocumentRangeFormattingEditProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: DocumentRangeFormattingRegistrationOptions, + ) { } + + async provideDocumentRangeFormattingEdits( + model: monaco.editor.ITextModel, + range: monaco.Range, + options: monaco.languages.FormattingOptions, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, range.getStartPosition()); + + const result = await this._client.server.textDocumentRangeFormatting({ + textDocument: translated.textDocument, + range: this._client.bridge.translateRange(model, range), + options: { + tabSize: options.tabSize, + insertSpaces: options.insertSpaces, + }, + }); + + if (!result) { + return null; + } + + return result.map(edit => ({ + range: this._client.bridge.translateBackRange(translated.textDocument, edit.range).range, + text: edit.newText, + })); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts new file mode 100644 index 00000000..2beab9b7 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts @@ -0,0 +1,64 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, ReferenceRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspReferencesFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + references: { + dynamicRegistration: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentReferences, true, capability => { + return monaco.languages.registerReferenceProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspReferenceProvider(this._connection, capability), + ); + })); + } +} + +class LspReferenceProvider implements monaco.languages.ReferenceProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: ReferenceRegistrationOptions, + ) { } + + async provideReferences( + model: monaco.editor.ITextModel, + position: monaco.Position, + context: monaco.languages.ReferenceContext, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentReferences({ + textDocument: translated.textDocument, + position: translated.position, + context: { + includeDeclaration: context.includeDeclaration, + }, + }); + + if (!result) { + return null; + } + + return result.map(loc => { + const translated = this._client.bridge.translateBackRange({ uri: loc.uri }, loc.range); + return { + uri: translated.textModel.uri, + range: translated.range, + }; + }); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts new file mode 100644 index 00000000..008abf20 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts @@ -0,0 +1,142 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, RenameRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspRenameFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + rename: { + dynamicRegistration: true, + prepareSupport: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentRename, true, capability => { + return monaco.languages.registerRenameProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspRenameProvider(this._connection, capability), + ); + })); + } +} + +class LspRenameProvider implements monaco.languages.RenameProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: RenameRegistrationOptions, + ) { } + + async provideRenameEdits( + model: monaco.editor.ITextModel, + position: monaco.Position, + newName: string, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentRename({ + textDocument: translated.textDocument, + position: translated.position, + newName, + }); + + if (!result) { + return null; + } + + return toMonacoWorkspaceEdit(result, this._client); + } + + async resolveRenameLocation( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken + ): Promise { + if (!this._capabilities.prepareProvider) { + return null; + } + + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentPrepareRename({ + textDocument: translated.textDocument, + position: translated.position, + }); + + if (!result) { + return null; + } + + if ('range' in result && 'placeholder' in result) { + return { + range: this._client.bridge.translateBackRange(translated.textDocument, result.range).range, + text: result.placeholder, + }; + } else if ('defaultBehavior' in result) { + return null; + } else if ('start' in result && 'end' in result) { + const range = this._client.bridge.translateBackRange(translated.textDocument, result).range; + return { + range, + text: model.getValueInRange(range), + }; + } + + return null; + } +} + +function toMonacoWorkspaceEdit( + edit: any, + client: LspConnection +): monaco.languages.WorkspaceEdit { + const edits: monaco.languages.IWorkspaceTextEdit[] = []; + + if (edit.changes) { + for (const uri in edit.changes) { + const textEdits = edit.changes[uri]; + for (const textEdit of textEdits) { + const translated = client.bridge.translateBackRange({ uri }, textEdit.range); + edits.push({ + resource: translated.textModel.uri, + versionId: undefined, + textEdit: { + range: translated.range, + text: textEdit.newText, + }, + }); + } + } + } + + if (edit.documentChanges) { + for (const change of edit.documentChanges) { + if ('textDocument' in change) { + // TextDocumentEdit + const uri = change.textDocument.uri; + for (const textEdit of change.edits) { + const translated = client.bridge.translateBackRange({ uri }, textEdit.range); + edits.push({ + resource: translated.textModel.uri, + versionId: change.textDocument.version, + textEdit: { + range: translated.range, + text: textEdit.newText, + }, + }); + } + } + // TODO: Handle CreateFile, RenameFile, DeleteFile + } + } + + return { edits }; +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts new file mode 100644 index 00000000..d7f0f73d --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts @@ -0,0 +1,71 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, SelectionRangeRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspSelectionRangeFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + selectionRange: { + dynamicRegistration: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentSelectionRange, true, capability => { + return monaco.languages.registerSelectionRangeProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspSelectionRangeProvider(this._connection, capability), + ); + })); + } +} + +class LspSelectionRangeProvider implements monaco.languages.SelectionRangeProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: SelectionRangeRegistrationOptions, + ) { } + + async provideSelectionRanges( + model: monaco.editor.ITextModel, + positions: monaco.Position[], + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, positions[0]); + + const result = await this._client.server.textDocumentSelectionRange({ + textDocument: translated.textDocument, + positions: positions.map(pos => this._client.bridge.translate(model, pos).position), + }); + + if (!result) { + return null; + } + + return result.map(selRange => this.convertSelectionRange(selRange, translated.textDocument)); + } + + private convertSelectionRange( + range: any, + textDocument: { uri: string } + ): monaco.languages.SelectionRange[] { + const result: monaco.languages.SelectionRange[] = []; + let current = range; + + while (current) { + result.push({ + range: this._client.bridge.translateBackRange(textDocument, current.range).range, + }); + current = current.parent; + } + + return result; + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts new file mode 100644 index 00000000..f57ccc13 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts @@ -0,0 +1,130 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, SemanticTokensRegistrationOptions, TokenFormat } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; + +export class LspSemanticTokensFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + semanticTokens: { + dynamicRegistration: true, + requests: { + range: true, + full: { + delta: true, + }, + }, + tokenTypes: [ + 'namespace', 'type', 'class', 'enum', 'interface', 'struct', + 'typeParameter', 'parameter', 'variable', 'property', 'enumMember', + 'event', 'function', 'method', 'macro', 'keyword', 'modifier', + 'comment', 'string', 'number', 'regexp', 'operator', 'decorator' + ], + tokenModifiers: [ + 'declaration', 'definition', 'readonly', 'static', 'deprecated', + 'abstract', 'async', 'modification', 'documentation', 'defaultLibrary' + ], + formats: [TokenFormat.Relative], + overlappingTokenSupport: false, + multilineTokenSupport: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentSemanticTokensFull, true, capability => { + return monaco.languages.registerDocumentSemanticTokensProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspSemanticTokensProvider(this._connection, capability), + ); + })); + } +} + +class LspSemanticTokensProvider implements monaco.languages.DocumentSemanticTokensProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: SemanticTokensRegistrationOptions, + ) { } + + getLegend(): monaco.languages.SemanticTokensLegend { + return { + tokenTypes: this._capabilities.legend.tokenTypes, + tokenModifiers: this._capabilities.legend.tokenModifiers, + }; + } + + releaseDocumentSemanticTokens(resultId: string | undefined): void { + // Monaco will call this when it's done with a result + // We can potentially notify the server if needed + } + + async provideDocumentSemanticTokens( + model: monaco.editor.ITextModel, + lastResultId: string | null, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, model.getPositionAt(0)); + + // Try delta request if we have a previous result and server supports it + const full = this._capabilities.full; + if (lastResultId && full && typeof full === 'object' && full.delta) { + const deltaResult = await this._client.server.textDocumentSemanticTokensFullDelta({ + textDocument: translated.textDocument, + previousResultId: lastResultId, + }); + + if (!deltaResult) { + return null; + } + + // Check if it's a delta or full result + if ('edits' in deltaResult) { + // It's a delta + return { + resultId: deltaResult.resultId, + edits: deltaResult.edits.map(edit => ({ + start: edit.start, + deleteCount: edit.deleteCount, + data: edit.data ? new Uint32Array(edit.data) : undefined, + })), + }; + } else { + // It's a full result + return { + resultId: deltaResult.resultId, + data: new Uint32Array(deltaResult.data), + }; + } + } + + // Full request + const result = await this._client.server.textDocumentSemanticTokensFull({ + textDocument: translated.textDocument, + }); + + if (!result) { + return null; + } + + return { + resultId: result.resultId, + data: new Uint32Array(result.data), + }; + } + + async provideDocumentSemanticTokensEdits?( + model: monaco.editor.ITextModel, + previousResultId: string, + token: monaco.CancellationToken + ): Promise { + // This method is called when Monaco wants to use delta updates + // We can delegate to provideDocumentSemanticTokens which handles both + return this.provideDocumentSemanticTokens(model, previousResultId, token); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts new file mode 100644 index 00000000..672cdc53 --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts @@ -0,0 +1,101 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, SignatureHelpRegistrationOptions, MarkupContent, MarkupKind } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { toLspSignatureHelpTriggerKind } from './common'; + +export class LspSignatureHelpFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + signatureHelp: { + dynamicRegistration: true, + contextSupport: true, + signatureInformation: { + documentationFormat: [MarkupKind.Markdown, MarkupKind.PlainText], + parameterInformation: { + labelOffsetSupport: true, + }, + activeParameterSupport: true, + } + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentSignatureHelp, true, capability => { + return monaco.languages.registerSignatureHelpProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspSignatureHelpProvider(this._connection, capability), + ); + })); + } +} + +class LspSignatureHelpProvider implements monaco.languages.SignatureHelpProvider { + public readonly signatureHelpTriggerCharacters?: readonly string[]; + public readonly signatureHelpRetriggerCharacters?: readonly string[]; + + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: SignatureHelpRegistrationOptions, + ) { + this.signatureHelpTriggerCharacters = _capabilities.triggerCharacters; + this.signatureHelpRetriggerCharacters = _capabilities.retriggerCharacters; + } + + async provideSignatureHelp( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken, + context: monaco.languages.SignatureHelpContext + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentSignatureHelp({ + textDocument: translated.textDocument, + position: translated.position, + context: { + triggerKind: toLspSignatureHelpTriggerKind(context.triggerKind), + triggerCharacter: context.triggerCharacter, + isRetrigger: context.isRetrigger, + }, + }); + + if (!result) { + return null; + } + + return { + value: { + signatures: result.signatures.map(sig => ({ + label: sig.label, + documentation: toMonacoDocumentation(sig.documentation), + parameters: sig.parameters?.map(param => ({ + label: param.label, + documentation: toMonacoDocumentation(param.documentation), + })) || [], + activeParameter: sig.activeParameter, + })), + activeSignature: result.activeSignature || 0, + activeParameter: result.activeParameter || 0, + }, + dispose: () => { }, + }; + } +} + +function toMonacoDocumentation( + doc: string | MarkupContent | undefined +): string | monaco.IMarkdownString | undefined { + if (!doc) return undefined; + if (typeof doc === 'string') return doc; + return { + value: doc.value, + isTrusted: true, + }; +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts b/monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts new file mode 100644 index 00000000..8736647f --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts @@ -0,0 +1,60 @@ +import * as monaco from 'monaco-editor-core'; +import { capabilities, TypeDefinitionRegistrationOptions } from '../../../src/types'; +import { Disposable } from '../../utils'; +import { LspConnection } from '../LspConnection'; +import { toMonacoLanguageSelector } from './common'; +import { toMonacoLocation } from "./common"; + +export class LspTypeDefinitionFeature extends Disposable { + constructor( + private readonly _connection: LspConnection, + ) { + super(); + + this._register(this._connection.capabilities.addStaticClientCapabilities({ + textDocument: { + typeDefinition: { + dynamicRegistration: true, + linkSupport: true, + } + } + })); + + this._register(this._connection.capabilities.registerCapabilityHandler(capabilities.textDocumentTypeDefinition, true, capability => { + return monaco.languages.registerTypeDefinitionProvider( + toMonacoLanguageSelector(capability.documentSelector), + new LspTypeDefinitionProvider(this._connection, capability), + ); + })); + } +} + +class LspTypeDefinitionProvider implements monaco.languages.TypeDefinitionProvider { + constructor( + private readonly _client: LspConnection, + private readonly _capabilities: TypeDefinitionRegistrationOptions, + ) { } + + async provideTypeDefinition( + model: monaco.editor.ITextModel, + position: monaco.Position, + token: monaco.CancellationToken + ): Promise { + const translated = this._client.bridge.translate(model, position); + + const result = await this._client.server.textDocumentTypeDefinition({ + textDocument: translated.textDocument, + position: translated.position, + }); + + if (!result) { + return null; + } + + if (Array.isArray(result)) { + return result.map(loc => toMonacoLocation(loc, this._client)); + } + + return toMonacoLocation(result, this._client); + } +} diff --git a/monaco-lsp-client/src/adapters/languageFeatures/common.ts b/monaco-lsp-client/src/adapters/languageFeatures/common.ts new file mode 100644 index 00000000..4d648e7d --- /dev/null +++ b/monaco-lsp-client/src/adapters/languageFeatures/common.ts @@ -0,0 +1,401 @@ +import * as monaco from 'monaco-editor-core'; +import { + CodeActionKind, + CodeActionTriggerKind, + Command, + CompletionItemKind, + CompletionItemTag, + CompletionTriggerKind, + Diagnostic, + DiagnosticSeverity, + DiagnosticTag, + DocumentHighlightKind, + DocumentSelector, + FoldingRangeKind, + InlayHintKind, + InsertTextFormat, + Location, + LocationLink, + SignatureHelpTriggerKind, + SymbolKind, + SymbolTag, +} from '../../../src/types'; +import { LspConnection } from '../LspConnection'; + +// ============================================================================ +// Code Action Kind +// ============================================================================ + +export const lspCodeActionKindToMonacoCodeActionKind = new Map([ + [CodeActionKind.Empty, ''], + [CodeActionKind.QuickFix, 'quickfix'], + [CodeActionKind.Refactor, 'refactor'], + [CodeActionKind.RefactorExtract, 'refactor.extract'], + [CodeActionKind.RefactorInline, 'refactor.inline'], + [CodeActionKind.RefactorRewrite, 'refactor.rewrite'], + [CodeActionKind.Source, 'source'], + [CodeActionKind.SourceOrganizeImports, 'source.organizeImports'], + [CodeActionKind.SourceFixAll, 'source.fixAll'], +]); + +export function toMonacoCodeActionKind(kind: CodeActionKind | undefined): string | undefined { + if (!kind) { + return undefined; + } + return lspCodeActionKindToMonacoCodeActionKind.get(kind) ?? kind; +} + +// ============================================================================ +// Code Action Trigger Kind +// ============================================================================ + +export const monacoCodeActionTriggerTypeToLspCodeActionTriggerKind = new Map([ + [monaco.languages.CodeActionTriggerType.Invoke, CodeActionTriggerKind.Invoked], + [monaco.languages.CodeActionTriggerType.Auto, CodeActionTriggerKind.Automatic], +]); + +export function toLspCodeActionTriggerKind(monacoTrigger: monaco.languages.CodeActionTriggerType): CodeActionTriggerKind { + return monacoCodeActionTriggerTypeToLspCodeActionTriggerKind.get(monacoTrigger) ?? CodeActionTriggerKind.Invoked; +} + +// ============================================================================ +// Completion Item Kind +// ============================================================================ + +export const lspCompletionItemKindToMonacoCompletionItemKind = new Map([ + [CompletionItemKind.Text, monaco.languages.CompletionItemKind.Text], + [CompletionItemKind.Method, monaco.languages.CompletionItemKind.Method], + [CompletionItemKind.Function, monaco.languages.CompletionItemKind.Function], + [CompletionItemKind.Constructor, monaco.languages.CompletionItemKind.Constructor], + [CompletionItemKind.Field, monaco.languages.CompletionItemKind.Field], + [CompletionItemKind.Variable, monaco.languages.CompletionItemKind.Variable], + [CompletionItemKind.Class, monaco.languages.CompletionItemKind.Class], + [CompletionItemKind.Interface, monaco.languages.CompletionItemKind.Interface], + [CompletionItemKind.Module, monaco.languages.CompletionItemKind.Module], + [CompletionItemKind.Property, monaco.languages.CompletionItemKind.Property], + [CompletionItemKind.Unit, monaco.languages.CompletionItemKind.Unit], + [CompletionItemKind.Value, monaco.languages.CompletionItemKind.Value], + [CompletionItemKind.Enum, monaco.languages.CompletionItemKind.Enum], + [CompletionItemKind.Keyword, monaco.languages.CompletionItemKind.Keyword], + [CompletionItemKind.Snippet, monaco.languages.CompletionItemKind.Snippet], + [CompletionItemKind.Color, monaco.languages.CompletionItemKind.Color], + [CompletionItemKind.File, monaco.languages.CompletionItemKind.File], + [CompletionItemKind.Reference, monaco.languages.CompletionItemKind.Reference], + [CompletionItemKind.Folder, monaco.languages.CompletionItemKind.Folder], + [CompletionItemKind.EnumMember, monaco.languages.CompletionItemKind.EnumMember], + [CompletionItemKind.Constant, monaco.languages.CompletionItemKind.Constant], + [CompletionItemKind.Struct, monaco.languages.CompletionItemKind.Struct], + [CompletionItemKind.Event, monaco.languages.CompletionItemKind.Event], + [CompletionItemKind.Operator, monaco.languages.CompletionItemKind.Operator], + [CompletionItemKind.TypeParameter, monaco.languages.CompletionItemKind.TypeParameter], +]); + +export function toMonacoCompletionItemKind(kind: CompletionItemKind | undefined): monaco.languages.CompletionItemKind { + if (!kind) { + return monaco.languages.CompletionItemKind.Text; + } + return lspCompletionItemKindToMonacoCompletionItemKind.get(kind) ?? monaco.languages.CompletionItemKind.Text; +} + +// ============================================================================ +// Completion Item Tag +// ============================================================================ + +export const lspCompletionItemTagToMonacoCompletionItemTag = new Map([ + [CompletionItemTag.Deprecated, monaco.languages.CompletionItemTag.Deprecated], +]); + +export function toMonacoCompletionItemTag(tag: CompletionItemTag): monaco.languages.CompletionItemTag | undefined { + return lspCompletionItemTagToMonacoCompletionItemTag.get(tag); +} + +// ============================================================================ +// Completion Trigger Kind +// ============================================================================ + +export const monacoCompletionTriggerKindToLspCompletionTriggerKind = new Map([ + [monaco.languages.CompletionTriggerKind.Invoke, CompletionTriggerKind.Invoked], + [monaco.languages.CompletionTriggerKind.TriggerCharacter, CompletionTriggerKind.TriggerCharacter], + [monaco.languages.CompletionTriggerKind.TriggerForIncompleteCompletions, CompletionTriggerKind.TriggerForIncompleteCompletions], +]); + +export function toLspCompletionTriggerKind(monacoKind: monaco.languages.CompletionTriggerKind): CompletionTriggerKind { + return monacoCompletionTriggerKindToLspCompletionTriggerKind.get(monacoKind) ?? CompletionTriggerKind.Invoked; +} + +// ============================================================================ +// Insert Text Format +// ============================================================================ + +export const lspInsertTextFormatToMonacoInsertTextRules = new Map([ + [InsertTextFormat.Snippet, monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet], +]); + +export function toMonacoInsertTextRules(format: InsertTextFormat | undefined): monaco.languages.CompletionItemInsertTextRule | undefined { + if (!format) { + return undefined; + } + return lspInsertTextFormatToMonacoInsertTextRules.get(format); +} + +// ============================================================================ +// Symbol Kind +// ============================================================================ + +export const lspSymbolKindToMonacoSymbolKind = new Map([ + [SymbolKind.File, monaco.languages.SymbolKind.File], + [SymbolKind.Module, monaco.languages.SymbolKind.Module], + [SymbolKind.Namespace, monaco.languages.SymbolKind.Namespace], + [SymbolKind.Package, monaco.languages.SymbolKind.Package], + [SymbolKind.Class, monaco.languages.SymbolKind.Class], + [SymbolKind.Method, monaco.languages.SymbolKind.Method], + [SymbolKind.Property, monaco.languages.SymbolKind.Property], + [SymbolKind.Field, monaco.languages.SymbolKind.Field], + [SymbolKind.Constructor, monaco.languages.SymbolKind.Constructor], + [SymbolKind.Enum, monaco.languages.SymbolKind.Enum], + [SymbolKind.Interface, monaco.languages.SymbolKind.Interface], + [SymbolKind.Function, monaco.languages.SymbolKind.Function], + [SymbolKind.Variable, monaco.languages.SymbolKind.Variable], + [SymbolKind.Constant, monaco.languages.SymbolKind.Constant], + [SymbolKind.String, monaco.languages.SymbolKind.String], + [SymbolKind.Number, monaco.languages.SymbolKind.Number], + [SymbolKind.Boolean, monaco.languages.SymbolKind.Boolean], + [SymbolKind.Array, monaco.languages.SymbolKind.Array], + [SymbolKind.Object, monaco.languages.SymbolKind.Object], + [SymbolKind.Key, monaco.languages.SymbolKind.Key], + [SymbolKind.Null, monaco.languages.SymbolKind.Null], + [SymbolKind.EnumMember, monaco.languages.SymbolKind.EnumMember], + [SymbolKind.Struct, monaco.languages.SymbolKind.Struct], + [SymbolKind.Event, monaco.languages.SymbolKind.Event], + [SymbolKind.Operator, monaco.languages.SymbolKind.Operator], + [SymbolKind.TypeParameter, monaco.languages.SymbolKind.TypeParameter], +]); + +export function toMonacoSymbolKind(kind: SymbolKind): monaco.languages.SymbolKind { + return lspSymbolKindToMonacoSymbolKind.get(kind) ?? monaco.languages.SymbolKind.File; +} + +// ============================================================================ +// Symbol Tag +// ============================================================================ + +export const lspSymbolTagToMonacoSymbolTag = new Map([ + [SymbolTag.Deprecated, monaco.languages.SymbolTag.Deprecated], +]); + +export function toMonacoSymbolTag(tag: SymbolTag): monaco.languages.SymbolTag | undefined { + return lspSymbolTagToMonacoSymbolTag.get(tag); +} + +// ============================================================================ +// Document Highlight Kind +// ============================================================================ + +export const lspDocumentHighlightKindToMonacoDocumentHighlightKind = new Map([ + [DocumentHighlightKind.Text, monaco.languages.DocumentHighlightKind.Text], + [DocumentHighlightKind.Read, monaco.languages.DocumentHighlightKind.Read], + [DocumentHighlightKind.Write, monaco.languages.DocumentHighlightKind.Write], +]); + +export function toMonacoDocumentHighlightKind(kind: DocumentHighlightKind | undefined): monaco.languages.DocumentHighlightKind { + if (!kind) { + return monaco.languages.DocumentHighlightKind.Text; + } + return lspDocumentHighlightKindToMonacoDocumentHighlightKind.get(kind) ?? monaco.languages.DocumentHighlightKind.Text; +} + +// ============================================================================ +// Folding Range Kind +// ============================================================================ + +export const lspFoldingRangeKindToMonacoFoldingRangeKind = new Map([ + [FoldingRangeKind.Comment, monaco.languages.FoldingRangeKind.Comment], + [FoldingRangeKind.Imports, monaco.languages.FoldingRangeKind.Imports], + [FoldingRangeKind.Region, monaco.languages.FoldingRangeKind.Region], +]); + +export function toMonacoFoldingRangeKind(kind: FoldingRangeKind | undefined): monaco.languages.FoldingRangeKind | undefined { + if (!kind) { + return undefined; + } + return lspFoldingRangeKindToMonacoFoldingRangeKind.get(kind); +} + +// ============================================================================ +// Diagnostic Severity +// ============================================================================ + +export const monacoMarkerSeverityToLspDiagnosticSeverity = new Map([ + [monaco.MarkerSeverity.Error, DiagnosticSeverity.Error], + [monaco.MarkerSeverity.Warning, DiagnosticSeverity.Warning], + [monaco.MarkerSeverity.Info, DiagnosticSeverity.Information], + [monaco.MarkerSeverity.Hint, DiagnosticSeverity.Hint], +]); + +export function toLspDiagnosticSeverity(severity: monaco.MarkerSeverity): DiagnosticSeverity { + return monacoMarkerSeverityToLspDiagnosticSeverity.get(severity) ?? DiagnosticSeverity.Error; +} + +export const lspDiagnosticSeverityToMonacoMarkerSeverity = new Map([ + [DiagnosticSeverity.Error, monaco.MarkerSeverity.Error], + [DiagnosticSeverity.Warning, monaco.MarkerSeverity.Warning], + [DiagnosticSeverity.Information, monaco.MarkerSeverity.Info], + [DiagnosticSeverity.Hint, monaco.MarkerSeverity.Hint], +]); + +export function toMonacoDiagnosticSeverity(severity: DiagnosticSeverity | undefined): monaco.MarkerSeverity { + if (!severity) { + return monaco.MarkerSeverity.Error; + } + return lspDiagnosticSeverityToMonacoMarkerSeverity.get(severity) ?? monaco.MarkerSeverity.Error; +} + +// ============================================================================ +// Diagnostic Tag +// ============================================================================ + +export const lspDiagnosticTagToMonacoMarkerTag = new Map([ + [DiagnosticTag.Unnecessary, monaco.MarkerTag.Unnecessary], + [DiagnosticTag.Deprecated, monaco.MarkerTag.Deprecated], +]); + +export function toMonacoDiagnosticTag(tag: DiagnosticTag): monaco.MarkerTag | undefined { + return lspDiagnosticTagToMonacoMarkerTag.get(tag); +} + +// ============================================================================ +// Signature Help Trigger Kind +// ============================================================================ + +export const monacoSignatureHelpTriggerKindToLspSignatureHelpTriggerKind = new Map([ + [monaco.languages.SignatureHelpTriggerKind.Invoke, SignatureHelpTriggerKind.Invoked], + [monaco.languages.SignatureHelpTriggerKind.TriggerCharacter, SignatureHelpTriggerKind.TriggerCharacter], + [monaco.languages.SignatureHelpTriggerKind.ContentChange, SignatureHelpTriggerKind.ContentChange], +]); + +export function toLspSignatureHelpTriggerKind(monacoKind: monaco.languages.SignatureHelpTriggerKind): SignatureHelpTriggerKind { + return monacoSignatureHelpTriggerKindToLspSignatureHelpTriggerKind.get(monacoKind) ?? SignatureHelpTriggerKind.Invoked; +} + +// ============================================================================ +// Command +// ============================================================================ + +export function toMonacoCommand(command: Command | undefined): monaco.languages.Command | undefined { + if (!command) { + return undefined; + } + return { + id: command.command, + title: command.title, + arguments: command.arguments, + }; +} + +// ============================================================================ +// Inlay Hint Kind +// ============================================================================ + +export const lspInlayHintKindToMonacoInlayHintKind = new Map([ + [InlayHintKind.Type, monaco.languages.InlayHintKind.Type], + [InlayHintKind.Parameter, monaco.languages.InlayHintKind.Parameter], +]); + +export function toMonacoInlayHintKind(kind: InlayHintKind | undefined): monaco.languages.InlayHintKind { + if (!kind) { + return monaco.languages.InlayHintKind.Type; + } + return lspInlayHintKindToMonacoInlayHintKind.get(kind) ?? monaco.languages.InlayHintKind.Type; +} export function toMonacoLocation( + location: Location | LocationLink, + client: LspConnection +): monaco.languages.Location | monaco.languages.LocationLink { + if ('targetUri' in location) { + // LocationLink + const translatedRange = client.bridge.translateBackRange({ uri: location.targetUri }, location.targetRange); + return { + uri: translatedRange.textModel.uri, + range: translatedRange.range, + originSelectionRange: location.originSelectionRange + ? client.bridge.translateBackRange({ uri: location.targetUri }, location.originSelectionRange).range + : undefined, + targetSelectionRange: location.targetSelectionRange + ? client.bridge.translateBackRange({ uri: location.targetUri }, location.targetSelectionRange).range + : undefined, + }; + } else { + // Location + const translatedRange = client.bridge.translateBackRange({ uri: location.uri }, location.range); + return { + uri: translatedRange.textModel.uri, + range: translatedRange.range, + }; + } +} +export function toMonacoLanguageSelector(s: DocumentSelector | null): monaco.languages.LanguageSelector { + if (!s || s.length === 0) { + return { language: '*' }; + } + return s.map(s => { + if ('notebook' in s) { + if (typeof s.notebook === 'string') { + return { notebookType: s.notebook, language: s.language }; + } else { + return { notebookType: s.notebook.notebookType, language: s.language, pattern: s.notebook.pattern, scheme: s.notebook.scheme }; + } + } else { + return { language: s.language, pattern: s.pattern, scheme: s.scheme }; + } + }); + +} +export function matchesDocumentSelector(model: monaco.editor.ITextModel, selector: DocumentSelector | null): boolean { + if (!selector) { + return true; + } + const languageId = model.getLanguageId(); + const uri = model.uri.toString(true); + + if (!selector || selector.length === 0) { + return true; + } + + for (const filter of selector) { + if (filter.language && filter.language !== '*' && filter.language !== languageId) { + continue; + } + return true; + } + + return false; +} +export function toDiagnosticMarker(diagnostic: Diagnostic): monaco.editor.IMarkerData { + const marker: monaco.editor.IMarkerData = { + severity: toMonacoDiagnosticSeverity(diagnostic.severity), + startLineNumber: diagnostic.range.start.line + 1, + startColumn: diagnostic.range.start.character + 1, + endLineNumber: diagnostic.range.end.line + 1, + endColumn: diagnostic.range.end.character + 1, + message: diagnostic.message, + source: diagnostic.source, + code: typeof diagnostic.code === 'string' ? diagnostic.code : diagnostic.code?.toString(), + }; + + if (diagnostic.tags) { + marker.tags = diagnostic.tags.map(tag => toMonacoDiagnosticTag(tag)).filter((tag): tag is monaco.MarkerTag => tag !== undefined); + } + + if (diagnostic.relatedInformation) { + marker.relatedInformation = diagnostic.relatedInformation.map(info => ({ + resource: monaco.Uri.parse(info.location.uri), + startLineNumber: info.location.range.start.line + 1, + startColumn: info.location.range.start.character + 1, + endLineNumber: info.location.range.end.line + 1, + endColumn: info.location.range.end.character + 1, + message: info.message, + })); + } + + return marker; +} + diff --git a/monaco-lsp-client/src/index.ts b/monaco-lsp-client/src/index.ts new file mode 100644 index 00000000..ade3e55f --- /dev/null +++ b/monaco-lsp-client/src/index.ts @@ -0,0 +1,5 @@ +import { MonacoLspClient } from './adapters/LspClient'; +import { WebSocketTransport } from '@hediet/json-rpc-websocket'; +import { createTransportToWorker, createTransportToIFrame } from '@hediet/json-rpc-browser'; + +export { MonacoLspClient, WebSocketTransport, createTransportToWorker, createTransportToIFrame }; diff --git a/monaco-lsp-client/src/types.ts b/monaco-lsp-client/src/types.ts new file mode 100644 index 00000000..c007b2fb --- /dev/null +++ b/monaco-lsp-client/src/types.ts @@ -0,0 +1,7514 @@ +// Generated TypeScript definitions for LSP +// Protocol version: 3.17.0 +// This file is auto-generated. Do not edit manually. + +import { + contract, unverifiedRequest, + unverifiedNotification +} from "@hediet/json-rpc"; + +/** + * A set of predefined token types. This set is not fixed + * an clients can specify additional token types via the + * corresponding client capabilities. + * + * @since 3.16.0 + */ +export enum SemanticTokenTypes { + namespace = 'namespace', + /** + * Represents a generic type. Acts as a fallback for types which can't be mapped to + * a specific type like class or enum. + */ + type = 'type', + class = 'class', + enum = 'enum', + interface = 'interface', + struct = 'struct', + typeParameter = 'typeParameter', + parameter = 'parameter', + variable = 'variable', + property = 'property', + enumMember = 'enumMember', + event = 'event', + function = 'function', + method = 'method', + macro = 'macro', + keyword = 'keyword', + modifier = 'modifier', + comment = 'comment', + string = 'string', + number = 'number', + regexp = 'regexp', + operator = 'operator', + /** + * @since 3.17.0 + */ + decorator = 'decorator' +} + +/** + * A set of predefined token modifiers. This set is not fixed + * an clients can specify additional token types via the + * corresponding client capabilities. + * + * @since 3.16.0 + */ +export enum SemanticTokenModifiers { + declaration = 'declaration', + definition = 'definition', + readonly = 'readonly', + static = 'static', + deprecated = 'deprecated', + abstract = 'abstract', + async = 'async', + modification = 'modification', + documentation = 'documentation', + defaultLibrary = 'defaultLibrary' +} + +/** + * The document diagnostic report kinds. + * + * @since 3.17.0 + */ +export enum DocumentDiagnosticReportKind { + /** + * A diagnostic report with a full + * set of problems. + */ + Full = 'full', + /** + * A report indicating that the last + * returned report is still accurate. + */ + Unchanged = 'unchanged' +} + +/** + * Predefined error codes. + */ +export enum ErrorCodes { + ParseError = -32700, + InvalidRequest = -32600, + MethodNotFound = -32601, + InvalidParams = -32602, + InternalError = -32603, + /** + * Error code indicating that a server received a notification or + * request before the server has received the `initialize` request. + */ + ServerNotInitialized = -32002, + UnknownErrorCode = -32001 +} + +export enum LSPErrorCodes { + /** + * A request failed but it was syntactically correct, e.g the + * method name was known and the parameters were valid. The error + * message should contain human readable information about why + * the request failed. + * + * @since 3.17.0 + */ + RequestFailed = -32803, + /** + * The server cancelled the request. This error code should + * only be used for requests that explicitly support being + * server cancellable. + * + * @since 3.17.0 + */ + ServerCancelled = -32802, + /** + * The server detected that the content of a document got + * modified outside normal conditions. A server should + * NOT send this error code if it detects a content change + * in it unprocessed messages. The result even computed + * on an older state might still be useful for the client. + * + * If a client decides that a result is not of any use anymore + * the client should cancel the request. + */ + ContentModified = -32801, + /** + * The client has canceled a request and a server has detected + * the cancel. + */ + RequestCancelled = -32800 +} + +/** + * A set of predefined range kinds. + */ +export enum FoldingRangeKind { + /** + * Folding range for a comment + */ + Comment = 'comment', + /** + * Folding range for an import or include + */ + Imports = 'imports', + /** + * Folding range for a region (e.g. `#region`) + */ + Region = 'region' +} + +/** + * A symbol kind. + */ +export enum SymbolKind { + File = 1, + Module = 2, + Namespace = 3, + Package = 4, + Class = 5, + Method = 6, + Property = 7, + Field = 8, + Constructor = 9, + Enum = 10, + Interface = 11, + Function = 12, + Variable = 13, + Constant = 14, + String = 15, + Number = 16, + Boolean = 17, + Array = 18, + Object = 19, + Key = 20, + Null = 21, + EnumMember = 22, + Struct = 23, + Event = 24, + Operator = 25, + TypeParameter = 26 +} + +/** + * Symbol tags are extra annotations that tweak the rendering of a symbol. + * + * @since 3.16 + */ +export enum SymbolTag { + /** + * Render a symbol as obsolete, usually using a strike-out. + */ + Deprecated = 1 +} + +/** + * Moniker uniqueness level to define scope of the moniker. + * + * @since 3.16.0 + */ +export enum UniquenessLevel { + /** + * The moniker is only unique inside a document + */ + document = 'document', + /** + * The moniker is unique inside a project for which a dump got created + */ + project = 'project', + /** + * The moniker is unique inside the group to which a project belongs + */ + group = 'group', + /** + * The moniker is unique inside the moniker scheme. + */ + scheme = 'scheme', + /** + * The moniker is globally unique + */ + global = 'global' +} + +/** + * The moniker kind. + * + * @since 3.16.0 + */ +export enum MonikerKind { + /** + * The moniker represent a symbol that is imported into a project + */ + import = 'import', + /** + * The moniker represents a symbol that is exported from a project + */ + export = 'export', + /** + * The moniker represents a symbol that is local to a project (e.g. a local + * variable of a function, a class not visible outside the project, ...) + */ + local = 'local' +} + +/** + * Inlay hint kinds. + * + * @since 3.17.0 + */ +export enum InlayHintKind { + /** + * An inlay hint that for a type annotation. + */ + Type = 1, + /** + * An inlay hint that is for a parameter. + */ + Parameter = 2 +} + +/** + * The message type + */ +export enum MessageType { + /** + * An error message. + */ + Error = 1, + /** + * A warning message. + */ + Warning = 2, + /** + * An information message. + */ + Info = 3, + /** + * A log message. + */ + Log = 4, + /** + * A debug message. + * + * @since 3.18.0 + */ + Debug = 5 +} + +/** + * Defines how the host (editor) should sync + * document changes to the language server. + */ +export enum TextDocumentSyncKind { + /** + * Documents should not be synced at all. + */ + None = 0, + /** + * Documents are synced by always sending the full content + * of the document. + */ + Full = 1, + /** + * Documents are synced by sending the full content on open. + * After that only incremental updates to the document are + * send. + */ + Incremental = 2 +} + +/** + * Represents reasons why a text document is saved. + */ +export enum TextDocumentSaveReason { + /** + * Manually triggered, e.g. by the user pressing save, by starting debugging, + * or by an API call. + */ + Manual = 1, + /** + * Automatic after a delay. + */ + AfterDelay = 2, + /** + * When the editor lost focus. + */ + FocusOut = 3 +} + +/** + * The kind of a completion entry. + */ +export enum CompletionItemKind { + Text = 1, + Method = 2, + Function = 3, + Constructor = 4, + Field = 5, + Variable = 6, + Class = 7, + Interface = 8, + Module = 9, + Property = 10, + Unit = 11, + Value = 12, + Enum = 13, + Keyword = 14, + Snippet = 15, + Color = 16, + File = 17, + Reference = 18, + Folder = 19, + EnumMember = 20, + Constant = 21, + Struct = 22, + Event = 23, + Operator = 24, + TypeParameter = 25 +} + +/** + * Completion item tags are extra annotations that tweak the rendering of a completion + * item. + * + * @since 3.15.0 + */ +export enum CompletionItemTag { + /** + * Render a completion as obsolete, usually using a strike-out. + */ + Deprecated = 1 +} + +/** + * Defines whether the insert text in a completion item should be interpreted as + * plain text or a snippet. + */ +export enum InsertTextFormat { + /** + * The primary text to be inserted is treated as a plain string. + */ + PlainText = 1, + /** + * The primary text to be inserted is treated as a snippet. + * + * A snippet can define tab stops and placeholders with `$1`, `$2` + * and `${3:foo}`. `$0` defines the final tab stop, it defaults to + * the end of the snippet. Placeholders with equal identifiers are linked, + * that is typing in one will update others too. + * + * See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax + */ + Snippet = 2 +} + +/** + * How whitespace and indentation is handled during completion + * item insertion. + * + * @since 3.16.0 + */ +export enum InsertTextMode { + /** + * The insertion or replace strings is taken as it is. If the + * value is multi line the lines below the cursor will be + * inserted using the indentation defined in the string value. + * The client will not apply any kind of adjustments to the + * string. + */ + asIs = 1, + /** + * The editor adjusts leading whitespace of new lines so that + * they match the indentation up to the cursor of the line for + * which the item is accepted. + * + * Consider a line like this: <2tabs><3tabs>foo. Accepting a + * multi line completion item is indented using 2 tabs and all + * following lines inserted will be indented using 2 tabs as well. + */ + adjustIndentation = 2 +} + +/** + * A document highlight kind. + */ +export enum DocumentHighlightKind { + /** + * A textual occurrence. + */ + Text = 1, + /** + * Read-access of a symbol, like reading a variable. + */ + Read = 2, + /** + * Write-access of a symbol, like writing to a variable. + */ + Write = 3 +} + +/** + * A set of predefined code action kinds + */ +export enum CodeActionKind { + /** + * Empty kind. + */ + Empty = '', + /** + * Base kind for quickfix actions: 'quickfix' + */ + QuickFix = 'quickfix', + /** + * Base kind for refactoring actions: 'refactor' + */ + Refactor = 'refactor', + /** + * Base kind for refactoring extraction actions: 'refactor.extract' + * + * Example extract actions: + * + * - Extract method + * - Extract function + * - Extract variable + * - Extract interface from class + * - ... + */ + RefactorExtract = 'refactor.extract', + /** + * Base kind for refactoring inline actions: 'refactor.inline' + * + * Example inline actions: + * + * - Inline function + * - Inline variable + * - Inline constant + * - ... + */ + RefactorInline = 'refactor.inline', + /** + * Base kind for refactoring rewrite actions: 'refactor.rewrite' + * + * Example rewrite actions: + * + * - Convert JavaScript function to class + * - Add or remove parameter + * - Encapsulate field + * - Make method static + * - Move method to base class + * - ... + */ + RefactorRewrite = 'refactor.rewrite', + /** + * Base kind for source actions: `source` + * + * Source code actions apply to the entire file. + */ + Source = 'source', + /** + * Base kind for an organize imports source action: `source.organizeImports` + */ + SourceOrganizeImports = 'source.organizeImports', + /** + * Base kind for auto-fix source actions: `source.fixAll`. + * + * Fix all actions automatically fix errors that have a clear fix that do not require user input. + * They should not suppress errors or perform unsafe fixes such as generating new types or classes. + * + * @since 3.15.0 + */ + SourceFixAll = 'source.fixAll' +} + +export enum TraceValues { + /** + * Turn tracing off. + */ + Off = 'off', + /** + * Trace messages only. + */ + Messages = 'messages', + /** + * Verbose message tracing. + */ + Verbose = 'verbose' +} + +/** + * Describes the content type that a client supports in various + * result literals like `Hover`, `ParameterInfo` or `CompletionItem`. + * + * Please note that `MarkupKinds` must not start with a `$`. This kinds + * are reserved for internal usage. + */ +export enum MarkupKind { + /** + * Plain text is supported as a content format + */ + PlainText = 'plaintext', + /** + * Markdown is supported as a content format + */ + Markdown = 'markdown' +} + +/** + * Describes how an {@link InlineCompletionItemProvider inline completion provider} was triggered. + * + * @since 3.18.0 + * @proposed + */ +export enum InlineCompletionTriggerKind { + /** + * Completion was triggered explicitly by a user gesture. + */ + Invoked = 0, + /** + * Completion was triggered automatically while editing. + */ + Automatic = 1 +} + +/** + * A set of predefined position encoding kinds. + * + * @since 3.17.0 + */ +export enum PositionEncodingKind { + /** + * Character offsets count UTF-8 code units (e.g. bytes). + */ + UTF8 = 'utf-8', + /** + * Character offsets count UTF-16 code units. + * + * This is the default and must always be supported + * by servers + */ + UTF16 = 'utf-16', + /** + * Character offsets count UTF-32 code units. + * + * Implementation note: these are the same as Unicode codepoints, + * so this `PositionEncodingKind` may also be used for an + * encoding-agnostic representation of character offsets. + */ + UTF32 = 'utf-32' +} + +/** + * The file event type + */ +export enum FileChangeType { + /** + * The file got created. + */ + Created = 1, + /** + * The file got changed. + */ + Changed = 2, + /** + * The file got deleted. + */ + Deleted = 3 +} + +export enum WatchKind { + /** + * Interested in create events. + */ + Create = 1, + /** + * Interested in change events + */ + Change = 2, + /** + * Interested in delete events + */ + Delete = 4 +} + +/** + * The diagnostic's severity. + */ +export enum DiagnosticSeverity { + /** + * Reports an error. + */ + Error = 1, + /** + * Reports a warning. + */ + Warning = 2, + /** + * Reports an information. + */ + Information = 3, + /** + * Reports a hint. + */ + Hint = 4 +} + +/** + * The diagnostic tags. + * + * @since 3.15.0 + */ +export enum DiagnosticTag { + /** + * Unused or unnecessary code. + * + * Clients are allowed to render diagnostics with this tag faded out instead of having + * an error squiggle. + */ + Unnecessary = 1, + /** + * Deprecated or obsolete code. + * + * Clients are allowed to rendered diagnostics with this tag strike through. + */ + Deprecated = 2 +} + +/** + * How a completion was triggered + */ +export enum CompletionTriggerKind { + /** + * Completion was triggered by typing an identifier (24x7 code + * complete), manual invocation (e.g Ctrl+Space) or via API. + */ + Invoked = 1, + /** + * Completion was triggered by a trigger character specified by + * the `triggerCharacters` properties of the `CompletionRegistrationOptions`. + */ + TriggerCharacter = 2, + /** + * Completion was re-triggered as current completion list is incomplete + */ + TriggerForIncompleteCompletions = 3 +} + +/** + * How a signature help was triggered. + * + * @since 3.15.0 + */ +export enum SignatureHelpTriggerKind { + /** + * Signature help was invoked manually by the user or by a command. + */ + Invoked = 1, + /** + * Signature help was triggered by a trigger character. + */ + TriggerCharacter = 2, + /** + * Signature help was triggered by the cursor moving or by the document content changing. + */ + ContentChange = 3 +} + +/** + * The reason why code actions were requested. + * + * @since 3.17.0 + */ +export enum CodeActionTriggerKind { + /** + * Code actions were explicitly requested by the user or by an extension. + */ + Invoked = 1, + /** + * Code actions were requested automatically. + * + * This typically happens when current selection in a file changes, but can + * also be triggered when file content changes. + */ + Automatic = 2 +} + +/** + * A pattern kind describing if a glob pattern matches a file a folder or + * both. + * + * @since 3.16.0 + */ +export enum FileOperationPatternKind { + /** + * The pattern matches a file only. + */ + file = 'file', + /** + * The pattern matches a folder only. + */ + folder = 'folder' +} + +/** + * A notebook cell kind. + * + * @since 3.17.0 + */ +export enum NotebookCellKind { + /** + * A markup-cell is formatted source that is used for display. + */ + Markup = 1, + /** + * A code-cell is source code. + */ + Code = 2 +} + +export enum ResourceOperationKind { + /** + * Supports creating new files and folders. + */ + Create = 'create', + /** + * Supports renaming existing files and folders. + */ + Rename = 'rename', + /** + * Supports deleting existing files and folders. + */ + Delete = 'delete' +} + +export enum FailureHandlingKind { + /** + * Applying the workspace change is simply aborted if one of the changes provided + * fails. All operations executed before the failing operation stay executed. + */ + Abort = 'abort', + /** + * All operations are executed transactional. That means they either all + * succeed or no changes at all are applied to the workspace. + */ + Transactional = 'transactional', + /** + * If the workspace edit contains only textual file changes they are executed transactional. + * If resource changes (create, rename or delete file) are part of the change the failure + * handling strategy is abort. + */ + TextOnlyTransactional = 'textOnlyTransactional', + /** + * The client tries to undo the operations already executed. But there is no + * guarantee that this is succeeding. + */ + Undo = 'undo' +} + +export enum PrepareSupportDefaultBehavior { + /** + * The client's default behavior is to select the identifier + * according the to language's syntax rule. + */ + Identifier = 1 +} + +export enum TokenFormat { + Relative = 'relative' +} + +/** + * The definition of a symbol represented as one or many {@link Location locations}. + * For most programming languages there is only one location at which a symbol is + * defined. + * + * Servers should prefer returning `DefinitionLink` over `Definition` if supported + * by the client. + */ +export type Definition = Location | (Location)[]; + +/** + * Information about where a symbol is defined. + * + * Provides additional metadata over normal {@link Location location} definitions, including the range of + * the defining symbol + */ +export type DefinitionLink = LocationLink; + +/** + * LSP arrays. + * @since 3.17.0 + */ +export type LSPArray = (LSPAny)[]; + +/** + * The LSP any type. + * Please note that strictly speaking a property with the value `undefined` + * can't be converted into JSON preserving the property name. However for + * convenience it is allowed and assumed that all these properties are + * optional as well. + * @since 3.17.0 + */ +export type LSPAny = LSPObject | LSPArray | string | number | number | number | boolean | null; + +/** + * The declaration of a symbol representation as one or many {@link Location locations}. + */ +export type Declaration = Location | (Location)[]; + +/** + * Information about where a symbol is declared. + * + * Provides additional metadata over normal {@link Location location} declarations, including the range of + * the declaring symbol. + * + * Servers should prefer returning `DeclarationLink` over `Declaration` if supported + * by the client. + */ +export type DeclarationLink = LocationLink; + +/** + * Inline value information can be provided by different means: + * - directly as a text value (class InlineValueText). + * - as a name to use for a variable lookup (class InlineValueVariableLookup) + * - as an evaluatable expression (class InlineValueEvaluatableExpression) + * The InlineValue types combines all inline value types into one type. + * + * @since 3.17.0 + */ +export type InlineValue = InlineValueText | InlineValueVariableLookup | InlineValueEvaluatableExpression; + +/** + * The result of a document diagnostic pull request. A report can + * either be a full report containing all diagnostics for the + * requested document or an unchanged report indicating that nothing + * has changed in terms of diagnostics in comparison to the last + * pull request. + * + * @since 3.17.0 + */ +export type DocumentDiagnosticReport = RelatedFullDocumentDiagnosticReport | RelatedUnchangedDocumentDiagnosticReport; + +export type PrepareRenameResult = Range | { + range: Range; + placeholder: string +} | { + defaultBehavior: boolean +}; + +/** + * A document selector is the combination of one or many document filters. + * + * @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language: 'json', pattern: '**∕tsconfig.json' }]`; + * + * The use of a string as a document filter is deprecated @since 3.16.0. + */ +export type DocumentSelector = (DocumentFilter)[]; + +export type ProgressToken = number | string; + +/** + * An identifier to refer to a change annotation stored with a workspace edit. + */ +export type ChangeAnnotationIdentifier = string; + +/** + * A workspace diagnostic document report. + * + * @since 3.17.0 + */ +export type WorkspaceDocumentDiagnosticReport = WorkspaceFullDocumentDiagnosticReport | WorkspaceUnchangedDocumentDiagnosticReport; + +/** + * An event describing a change to a text document. If only a text is provided + * it is considered to be the full content of the document. + */ +export type TextDocumentContentChangeEvent = { + range: Range; + rangeLength?: number; + text: string +} | { + text: string +}; + +/** + * MarkedString can be used to render human readable text. It is either a markdown string + * or a code-block that provides a language and a code snippet. The language identifier + * is semantically equal to the optional language identifier in fenced code blocks in GitHub + * issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting + * + * The pair of a language and a value is an equivalent to markdown: + * ```${language} + * ${value} + * ``` + * + * Note that markdown strings will be sanitized - that means html will be escaped. + * @deprecated use MarkupContent instead. + */ +export type MarkedString = string | { + language: string; + value: string +}; + +/** + * A document filter describes a top level text document or + * a notebook cell document. + * + * @since 3.17.0 - proposed support for NotebookCellTextDocumentFilter. + */ +export type DocumentFilter = TextDocumentFilter | NotebookCellTextDocumentFilter; + +/** + * LSP object definition. + * @since 3.17.0 + */ +export type LSPObject = { [key: string]: LSPAny }; + +/** + * The glob pattern. Either a string pattern or a relative pattern. + * + * @since 3.17.0 + */ +export type GlobPattern = Pattern | RelativePattern; + +/** + * A document filter denotes a document by different properties like + * the {@link TextDocument.languageId language}, the {@link Uri.scheme scheme} of + * its resource, or a glob-pattern that is applied to the {@link TextDocument.fileName path}. + * + * Glob patterns can have the following syntax: + * - `*` to match zero or more characters in a path segment + * - `?` to match on one character in a path segment + * - `**` to match any number of path segments, including none + * - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files) + * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) + * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) + * + * @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }` + * @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }` + * + * @since 3.17.0 + */ +export type TextDocumentFilter = { + language: string; + scheme?: string; + pattern?: string +} | { + language?: string; + scheme: string; + pattern?: string +} | { + language?: string; + scheme?: string; + pattern: string +}; + +/** + * A notebook document filter denotes a notebook document by + * different properties. The properties will be match + * against the notebook's URI (same as with documents) + * + * @since 3.17.0 + */ +export type NotebookDocumentFilter = { + notebookType: string; + scheme?: string; + pattern?: string +} | { + notebookType?: string; + scheme: string; + pattern?: string +} | { + notebookType?: string; + scheme?: string; + pattern: string +}; + +/** + * The glob pattern to watch relative to the base path. Glob patterns can have the following syntax: + * - `*` to match zero or more characters in a path segment + * - `?` to match on one character in a path segment + * - `**` to match any number of path segments, including none + * - `{}` to group conditions (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files) + * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) + * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) + * + * @since 3.17.0 + */ +export type Pattern = string; + +export interface ImplementationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { +} + +/** + * Represents a location inside a resource, such as a line + * inside a text file. + */ +export interface Location { + uri: string; + range: Range; +} + +export interface ImplementationRegistrationOptions extends TextDocumentRegistrationOptions, ImplementationOptions, StaticRegistrationOptions { +} + +export interface TypeDefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { +} + +export interface TypeDefinitionRegistrationOptions extends TextDocumentRegistrationOptions, TypeDefinitionOptions, StaticRegistrationOptions { +} + +/** + * A workspace folder inside a client. + */ +export interface WorkspaceFolder { + /** + * The associated URI for this workspace folder. + */ + uri: string; + /** + * The name of the workspace folder. Used to refer to this + * workspace folder in the user interface. + */ + name: string; +} + +/** + * The parameters of a `workspace/didChangeWorkspaceFolders` notification. + */ +export interface DidChangeWorkspaceFoldersParams { + /** + * The actual workspace folder change event. + */ + event: WorkspaceFoldersChangeEvent; +} + +/** + * The parameters of a configuration request. + */ +export interface ConfigurationParams { + items: (ConfigurationItem)[]; +} + +/** + * Parameters for a {@link DocumentColorRequest}. + */ +export interface DocumentColorParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; +} + +/** + * Represents a color range from a document. + */ +export interface ColorInformation { + /** + * The range in the document where this color appears. + */ + range: Range; + /** + * The actual color value for this color range. + */ + color: Color; +} + +export interface DocumentColorRegistrationOptions extends TextDocumentRegistrationOptions, DocumentColorOptions, StaticRegistrationOptions { +} + +/** + * Parameters for a {@link ColorPresentationRequest}. + */ +export interface ColorPresentationParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The color to request presentations for. + */ + color: Color; + /** + * The range where the color would be inserted. Serves as a context. + */ + range: Range; +} + +export interface ColorPresentation { + /** + * The label of this color presentation. It will be shown on the color + * picker header. By default this is also the text that is inserted when selecting + * this color presentation. + */ + label: string; + /** + * An {@link TextEdit edit} which is applied to a document when selecting + * this presentation for the color. When `falsy` the {@link ColorPresentation.label label} + * is used. + */ + textEdit?: TextEdit; + /** + * An optional array of additional {@link TextEdit text edits} that are applied when + * selecting this color presentation. Edits must not overlap with the main {@link ColorPresentation.textEdit edit} nor with themselves. + */ + additionalTextEdits?: (TextEdit)[]; +} + +export interface WorkDoneProgressOptions { + workDoneProgress?: boolean; +} + +/** + * General text document registration options. + */ +export interface TextDocumentRegistrationOptions { + /** + * A document selector to identify the scope of the registration. If set to null + * the document selector provided on the client side will be used. + */ + documentSelector: DocumentSelector | null; +} + +/** + * Parameters for a {@link FoldingRangeRequest}. + */ +export interface FoldingRangeParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; +} + +/** + * Represents a folding range. To be valid, start and end line must be bigger than zero and smaller + * than the number of lines in the document. Clients are free to ignore invalid ranges. + */ +export interface FoldingRange { + /** + * The zero-based start line of the range to fold. The folded area starts after the line's last character. + * To be valid, the end must be zero or larger and smaller than the number of lines in the document. + */ + startLine: number; + /** + * The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line. + */ + startCharacter?: number; + /** + * The zero-based end line of the range to fold. The folded area ends with the line's last character. + * To be valid, the end must be zero or larger and smaller than the number of lines in the document. + */ + endLine: number; + /** + * The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line. + */ + endCharacter?: number; + /** + * Describes the kind of the folding range such as `comment' or 'region'. The kind + * is used to categorize folding ranges and used by commands like 'Fold all comments'. + * See {@link FoldingRangeKind} for an enumeration of standardized kinds. + */ + kind?: FoldingRangeKind; + /** + * The text that the client should show when the specified range is + * collapsed. If not defined or not supported by the client, a default + * will be chosen by the client. + * + * @since 3.17.0 + */ + collapsedText?: string; +} + +export interface FoldingRangeRegistrationOptions extends TextDocumentRegistrationOptions, FoldingRangeOptions, StaticRegistrationOptions { +} + +export interface DeclarationParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { +} + +export interface DeclarationRegistrationOptions extends DeclarationOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions { +} + +/** + * A parameter literal used in selection range requests. + */ +export interface SelectionRangeParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The positions inside the text document. + */ + positions: (Position)[]; +} + +/** + * A selection range represents a part of a selection hierarchy. A selection range + * may have a parent selection range that contains it. + */ +export interface SelectionRange { + /** + * The {@link Range range} of this selection range. + */ + range: Range; + /** + * The parent selection range containing this range. Therefore `parent.range` must contain `this.range`. + */ + parent?: SelectionRange; +} + +export interface SelectionRangeRegistrationOptions extends SelectionRangeOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions { +} + +export interface WorkDoneProgressCreateParams { + /** + * The token to be used to report progress. + */ + token: ProgressToken; +} + +export interface WorkDoneProgressCancelParams { + /** + * The token to be used to report progress. + */ + token: ProgressToken; +} + +/** + * The parameter of a `textDocument/prepareCallHierarchy` request. + * + * @since 3.16.0 + */ +export interface CallHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams { +} + +/** + * Represents programming constructs like functions or constructors in the context + * of call hierarchy. + * + * @since 3.16.0 + */ +export interface CallHierarchyItem { + /** + * The name of this item. + */ + name: string; + /** + * The kind of this item. + */ + kind: SymbolKind; + /** + * Tags for this item. + */ + tags?: (SymbolTag)[]; + /** + * More detail for this item, e.g. the signature of a function. + */ + detail?: string; + /** + * The resource identifier of this item. + */ + uri: string; + /** + * The range enclosing this symbol not including leading/trailing whitespace but everything else, e.g. comments and code. + */ + range: Range; + /** + * The range that should be selected and revealed when this symbol is being picked, e.g. the name of a function. + * Must be contained by the {@link CallHierarchyItem.range `range`}. + */ + selectionRange: Range; + /** + * A data entry field that is preserved between a call hierarchy prepare and + * incoming calls or outgoing calls requests. + */ + data?: LSPAny; +} + +/** + * Call hierarchy options used during static or dynamic registration. + * + * @since 3.16.0 + */ +export interface CallHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, CallHierarchyOptions, StaticRegistrationOptions { +} + +/** + * The parameter of a `callHierarchy/incomingCalls` request. + * + * @since 3.16.0 + */ +export interface CallHierarchyIncomingCallsParams extends WorkDoneProgressParams, PartialResultParams { + item: CallHierarchyItem; +} + +/** + * Represents an incoming call, e.g. a caller of a method or constructor. + * + * @since 3.16.0 + */ +export interface CallHierarchyIncomingCall { + /** + * The item that makes the call. + */ + from: CallHierarchyItem; + /** + * The ranges at which the calls appear. This is relative to the caller + * denoted by {@link CallHierarchyIncomingCall.from `this.from`}. + */ + fromRanges: (Range)[]; +} + +/** + * The parameter of a `callHierarchy/outgoingCalls` request. + * + * @since 3.16.0 + */ +export interface CallHierarchyOutgoingCallsParams extends WorkDoneProgressParams, PartialResultParams { + item: CallHierarchyItem; +} + +/** + * Represents an outgoing call, e.g. calling a getter from a method or a method from a constructor etc. + * + * @since 3.16.0 + */ +export interface CallHierarchyOutgoingCall { + /** + * The item that is called. + */ + to: CallHierarchyItem; + /** + * The range at which this item is called. This is the range relative to the caller, e.g the item + * passed to {@link CallHierarchyItemProvider.provideCallHierarchyOutgoingCalls `provideCallHierarchyOutgoingCalls`} + * and not {@link CallHierarchyOutgoingCall.to `this.to`}. + */ + fromRanges: (Range)[]; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokens { + /** + * An optional result id. If provided and clients support delta updating + * the client will include the result id in the next semantic token request. + * A server can then instead of computing all semantic tokens again simply + * send a delta. + */ + resultId?: string; + /** + * The actual tokens. + */ + data: (number)[]; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensPartialResult { + data: (number)[]; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensRegistrationOptions extends TextDocumentRegistrationOptions, SemanticTokensOptions, StaticRegistrationOptions { +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensDeltaParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The result id of a previous response. The result Id can either point to a full response + * or a delta response depending on what was received last. + */ + previousResultId: string; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensDelta { + resultId?: string; + /** + * The semantic token edits to transform a previous result into a new result. + */ + edits: (SemanticTokensEdit)[]; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensDeltaPartialResult { + edits: (SemanticTokensEdit)[]; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensRangeParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The range the semantic tokens are requested for. + */ + range: Range; +} + +/** + * Params to show a resource in the UI. + * + * @since 3.16.0 + */ +export interface ShowDocumentParams { + /** + * The uri to show. + */ + uri: string; + /** + * Indicates to show the resource in an external program. + * To show, for example, `https://code.visualstudio.com/` + * in the default WEB browser set `external` to `true`. + */ + external?: boolean; + /** + * An optional property to indicate whether the editor + * showing the document should take focus or not. + * Clients might ignore this property if an external + * program is started. + */ + takeFocus?: boolean; + /** + * An optional selection range if the document is a text + * document. Clients might ignore the property if an + * external program is started or the file is not a text + * file. + */ + selection?: Range; +} + +/** + * The result of a showDocument request. + * + * @since 3.16.0 + */ +export interface ShowDocumentResult { + /** + * A boolean indicating if the show was successful. + */ + success: boolean; +} + +export interface LinkedEditingRangeParams extends TextDocumentPositionParams, WorkDoneProgressParams { +} + +/** + * The result of a linked editing range request. + * + * @since 3.16.0 + */ +export interface LinkedEditingRanges { + /** + * A list of ranges that can be edited together. The ranges must have + * identical length and contain identical text content. The ranges cannot overlap. + */ + ranges: (Range)[]; + /** + * An optional word pattern (regular expression) that describes valid contents for + * the given ranges. If no pattern is provided, the client configuration's word + * pattern will be used. + */ + wordPattern?: string; +} + +export interface LinkedEditingRangeRegistrationOptions extends TextDocumentRegistrationOptions, LinkedEditingRangeOptions, StaticRegistrationOptions { +} + +/** + * The parameters sent in notifications/requests for user-initiated creation of + * files. + * + * @since 3.16.0 + */ +export interface CreateFilesParams { + /** + * An array of all files/folders created in this operation. + */ + files: (FileCreate)[]; +} + +/** + * A workspace edit represents changes to many resources managed in the workspace. The edit + * should either provide `changes` or `documentChanges`. If documentChanges are present + * they are preferred over `changes` if the client can handle versioned document edits. + * + * Since version 3.13.0 a workspace edit can contain resource operations as well. If resource + * operations are present clients need to execute the operations in the order in which they + * are provided. So a workspace edit for example can consist of the following two changes: + * (1) a create file a.txt and (2) a text document edit which insert text into file a.txt. + * + * An invalid sequence (e.g. (1) delete file a.txt and (2) insert text into file a.txt) will + * cause failure of the operation. How the client recovers from the failure is described by + * the client capability: `workspace.workspaceEdit.failureHandling` + */ +export interface WorkspaceEdit { + /** + * Holds changes to existing resources. + */ + changes?: { [key: string]: (TextEdit)[] }; + /** + * Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes + * are either an array of `TextDocumentEdit`s to express changes to n different text documents + * where each text document edit addresses a specific version of a text document. Or it can contain + * above `TextDocumentEdit`s mixed with create, rename and delete file / folder operations. + * + * Whether a client supports versioned document edits is expressed via + * `workspace.workspaceEdit.documentChanges` client capability. + * + * If a client neither supports `documentChanges` nor `workspace.workspaceEdit.resourceOperations` then + * only plain `TextEdit`s using the `changes` property are supported. + */ + documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[]; + /** + * A map of change annotations that can be referenced in `AnnotatedTextEdit`s or create, rename and + * delete file / folder operations. + * + * Whether clients honor this property depends on the client capability `workspace.changeAnnotationSupport`. + * + * @since 3.16.0 + */ + changeAnnotations?: { [key: ChangeAnnotationIdentifier]: ChangeAnnotation }; +} + +/** + * The options to register for file operations. + * + * @since 3.16.0 + */ +export interface FileOperationRegistrationOptions { + /** + * The actual filters. + */ + filters: (FileOperationFilter)[]; +} + +/** + * The parameters sent in notifications/requests for user-initiated renames of + * files. + * + * @since 3.16.0 + */ +export interface RenameFilesParams { + /** + * An array of all files/folders renamed in this operation. When a folder is renamed, only + * the folder will be included, and not its children. + */ + files: (FileRename)[]; +} + +/** + * The parameters sent in notifications/requests for user-initiated deletes of + * files. + * + * @since 3.16.0 + */ +export interface DeleteFilesParams { + /** + * An array of all files/folders deleted in this operation. + */ + files: (FileDelete)[]; +} + +export interface MonikerParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { +} + +/** + * Moniker definition to match LSIF 0.5 moniker definition. + * + * @since 3.16.0 + */ +export interface Moniker { + /** + * The scheme of the moniker. For example tsc or .Net + */ + scheme: string; + /** + * The identifier of the moniker. The value is opaque in LSIF however + * schema owners are allowed to define the structure if they want. + */ + identifier: string; + /** + * The scope in which the moniker is unique + */ + unique: UniquenessLevel; + /** + * The moniker kind if known. + */ + kind?: MonikerKind; +} + +export interface MonikerRegistrationOptions extends TextDocumentRegistrationOptions, MonikerOptions { +} + +/** + * The parameter of a `textDocument/prepareTypeHierarchy` request. + * + * @since 3.17.0 + */ +export interface TypeHierarchyPrepareParams extends TextDocumentPositionParams, WorkDoneProgressParams { +} + +/** + * @since 3.17.0 + */ +export interface TypeHierarchyItem { + /** + * The name of this item. + */ + name: string; + /** + * The kind of this item. + */ + kind: SymbolKind; + /** + * Tags for this item. + */ + tags?: (SymbolTag)[]; + /** + * More detail for this item, e.g. the signature of a function. + */ + detail?: string; + /** + * The resource identifier of this item. + */ + uri: string; + /** + * The range enclosing this symbol not including leading/trailing whitespace + * but everything else, e.g. comments and code. + */ + range: Range; + /** + * The range that should be selected and revealed when this symbol is being + * picked, e.g. the name of a function. Must be contained by the + * {@link TypeHierarchyItem.range `range`}. + */ + selectionRange: Range; + /** + * A data entry field that is preserved between a type hierarchy prepare and + * supertypes or subtypes requests. It could also be used to identify the + * type hierarchy in the server, helping improve the performance on + * resolving supertypes and subtypes. + */ + data?: LSPAny; +} + +/** + * Type hierarchy options used during static or dynamic registration. + * + * @since 3.17.0 + */ +export interface TypeHierarchyRegistrationOptions extends TextDocumentRegistrationOptions, TypeHierarchyOptions, StaticRegistrationOptions { +} + +/** + * The parameter of a `typeHierarchy/supertypes` request. + * + * @since 3.17.0 + */ +export interface TypeHierarchySupertypesParams extends WorkDoneProgressParams, PartialResultParams { + item: TypeHierarchyItem; +} + +/** + * The parameter of a `typeHierarchy/subtypes` request. + * + * @since 3.17.0 + */ +export interface TypeHierarchySubtypesParams extends WorkDoneProgressParams, PartialResultParams { + item: TypeHierarchyItem; +} + +/** + * A parameter literal used in inline value requests. + * + * @since 3.17.0 + */ +export interface InlineValueParams extends WorkDoneProgressParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The document range for which inline values should be computed. + */ + range: Range; + /** + * Additional information about the context in which inline values were + * requested. + */ + context: InlineValueContext; +} + +/** + * Inline value options used during static or dynamic registration. + * + * @since 3.17.0 + */ +export interface InlineValueRegistrationOptions extends InlineValueOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions { +} + +/** + * A parameter literal used in inlay hint requests. + * + * @since 3.17.0 + */ +export interface InlayHintParams extends WorkDoneProgressParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The document range for which inlay hints should be computed. + */ + range: Range; +} + +/** + * Inlay hint information. + * + * @since 3.17.0 + */ +export interface InlayHint { + /** + * The position of this hint. + * + * If multiple hints have the same position, they will be shown in the order + * they appear in the response. + */ + position: Position; + /** + * The label of this hint. A human readable string or an array of + * InlayHintLabelPart label parts. + * + * *Note* that neither the string nor the label part can be empty. + */ + label: string | (InlayHintLabelPart)[]; + /** + * The kind of this hint. Can be omitted in which case the client + * should fall back to a reasonable default. + */ + kind?: InlayHintKind; + /** + * Optional text edits that are performed when accepting this inlay hint. + * + * *Note* that edits are expected to change the document so that the inlay + * hint (or its nearest variant) is now part of the document and the inlay + * hint itself is now obsolete. + */ + textEdits?: (TextEdit)[]; + /** + * The tooltip text when you hover over this item. + */ + tooltip?: string | MarkupContent; + /** + * Render padding before the hint. + * + * Note: Padding should use the editor's background color, not the + * background color of the hint itself. That means padding can be used + * to visually align/separate an inlay hint. + */ + paddingLeft?: boolean; + /** + * Render padding after the hint. + * + * Note: Padding should use the editor's background color, not the + * background color of the hint itself. That means padding can be used + * to visually align/separate an inlay hint. + */ + paddingRight?: boolean; + /** + * A data entry field that is preserved on an inlay hint between + * a `textDocument/inlayHint` and a `inlayHint/resolve` request. + */ + data?: LSPAny; +} + +/** + * Inlay hint options used during static or dynamic registration. + * + * @since 3.17.0 + */ +export interface InlayHintRegistrationOptions extends InlayHintOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions { +} + +/** + * Parameters of the document diagnostic request. + * + * @since 3.17.0 + */ +export interface DocumentDiagnosticParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The additional identifier provided during registration. + */ + identifier?: string; + /** + * The result id of a previous response if provided. + */ + previousResultId?: string; +} + +/** + * A partial result for a document diagnostic report. + * + * @since 3.17.0 + */ +export interface DocumentDiagnosticReportPartialResult { + relatedDocuments: { [key: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport }; +} + +/** + * Cancellation data returned from a diagnostic request. + * + * @since 3.17.0 + */ +export interface DiagnosticServerCancellationData { + retriggerRequest: boolean; +} + +/** + * Diagnostic registration options. + * + * @since 3.17.0 + */ +export interface DiagnosticRegistrationOptions extends TextDocumentRegistrationOptions, DiagnosticOptions, StaticRegistrationOptions { +} + +/** + * Parameters of the workspace diagnostic request. + * + * @since 3.17.0 + */ +export interface WorkspaceDiagnosticParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The additional identifier provided during registration. + */ + identifier?: string; + /** + * The currently known diagnostic reports with their + * previous result ids. + */ + previousResultIds: (PreviousResultId)[]; +} + +/** + * A workspace diagnostic report. + * + * @since 3.17.0 + */ +export interface WorkspaceDiagnosticReport { + items: (WorkspaceDocumentDiagnosticReport)[]; +} + +/** + * A partial result for a workspace diagnostic report. + * + * @since 3.17.0 + */ +export interface WorkspaceDiagnosticReportPartialResult { + items: (WorkspaceDocumentDiagnosticReport)[]; +} + +/** + * The params sent in an open notebook document notification. + * + * @since 3.17.0 + */ +export interface DidOpenNotebookDocumentParams { + /** + * The notebook document that got opened. + */ + notebookDocument: NotebookDocument; + /** + * The text documents that represent the content + * of a notebook cell. + */ + cellTextDocuments: (TextDocumentItem)[]; +} + +/** + * The params sent in a change notebook document notification. + * + * @since 3.17.0 + */ +export interface DidChangeNotebookDocumentParams { + /** + * The notebook document that did change. The version number points + * to the version after all provided changes have been applied. If + * only the text document content of a cell changes the notebook version + * doesn't necessarily have to change. + */ + notebookDocument: VersionedNotebookDocumentIdentifier; + /** + * The actual changes to the notebook document. + * + * The changes describe single state changes to the notebook document. + * So if there are two changes c1 (at array index 0) and c2 (at array + * index 1) for a notebook in state S then c1 moves the notebook from + * S to S' and c2 from S' to S''. So c1 is computed on the state S and + * c2 is computed on the state S'. + * + * To mirror the content of a notebook using change events use the following approach: + * - start with the same initial content + * - apply the 'notebookDocument/didChange' notifications in the order you receive them. + * - apply the `NotebookChangeEvent`s in a single notification in the order + * you receive them. + */ + change: NotebookDocumentChangeEvent; +} + +/** + * The params sent in a save notebook document notification. + * + * @since 3.17.0 + */ +export interface DidSaveNotebookDocumentParams { + /** + * The notebook document that got saved. + */ + notebookDocument: NotebookDocumentIdentifier; +} + +/** + * The params sent in a close notebook document notification. + * + * @since 3.17.0 + */ +export interface DidCloseNotebookDocumentParams { + /** + * The notebook document that got closed. + */ + notebookDocument: NotebookDocumentIdentifier; + /** + * The text documents that represent the content + * of a notebook cell that got closed. + */ + cellTextDocuments: (TextDocumentIdentifier)[]; +} + +/** + * A parameter literal used in inline completion requests. + * + * @since 3.18.0 + * @proposed + */ +export interface InlineCompletionParams extends TextDocumentPositionParams, WorkDoneProgressParams { + /** + * Additional information about the context in which inline completions were + * requested. + */ + context: InlineCompletionContext; +} + +/** + * Represents a collection of {@link InlineCompletionItem inline completion items} to be presented in the editor. + * + * @since 3.18.0 + * @proposed + */ +export interface InlineCompletionList { + /** + * The inline completion items + */ + items: (InlineCompletionItem)[]; +} + +/** + * An inline completion item represents a text snippet that is proposed inline to complete text that is being typed. + * + * @since 3.18.0 + * @proposed + */ +export interface InlineCompletionItem { + /** + * The text to replace the range with. Must be set. + */ + insertText: string | StringValue; + /** + * A text that is used to decide if this inline completion should be shown. When `falsy` the {@link InlineCompletionItem.insertText} is used. + */ + filterText?: string; + /** + * The range to replace. Must begin and end on the same line. + */ + range?: Range; + /** + * An optional {@link Command} that is executed *after* inserting this completion. + */ + command?: Command; +} + +/** + * Inline completion options used during static or dynamic registration. + * + * @since 3.18.0 + * @proposed + */ +export interface InlineCompletionRegistrationOptions extends InlineCompletionOptions, TextDocumentRegistrationOptions, StaticRegistrationOptions { +} + +export interface RegistrationParams { + registrations: (Registration)[]; +} + +export interface UnregistrationParams { + unregisterations: (Unregistration)[]; +} + +export interface InitializeParams extends _InitializeParams, WorkspaceFoldersInitializeParams { +} + +/** + * The result returned from an initialize request. + */ +export interface InitializeResult { + /** + * The capabilities the language server provides. + */ + capabilities: ServerCapabilities; + /** + * Information about the server. + * + * @since 3.15.0 + */ + serverInfo?: { + name: string; + version?: string + }; +} + +/** + * The data type of the ResponseError if the + * initialize request fails. + */ +export interface InitializeError { + /** + * Indicates whether the client execute the following retry logic: + * (1) show the message provided by the ResponseError to the user + * (2) user selects retry or cancel + * (3) if user selected retry the initialize method is sent again. + */ + retry: boolean; +} + +export interface InitializedParams { +} + +/** + * The parameters of a change configuration notification. + */ +export interface DidChangeConfigurationParams { + /** + * The actual changed settings + */ + settings: LSPAny; +} + +export interface DidChangeConfigurationRegistrationOptions { + section?: string | (string)[]; +} + +/** + * The parameters of a notification message. + */ +export interface ShowMessageParams { + /** + * The message type. See {@link MessageType} + */ + type: MessageType; + /** + * The actual message. + */ + message: string; +} + +export interface ShowMessageRequestParams { + /** + * The message type. See {@link MessageType} + */ + type: MessageType; + /** + * The actual message. + */ + message: string; + /** + * The message action items to present. + */ + actions?: (MessageActionItem)[]; +} + +export interface MessageActionItem { + /** + * A short title like 'Retry', 'Open Log' etc. + */ + title: string; +} + +/** + * The log message parameters. + */ +export interface LogMessageParams { + /** + * The message type. See {@link MessageType} + */ + type: MessageType; + /** + * The actual message. + */ + message: string; +} + +/** + * The parameters sent in an open text document notification + */ +export interface DidOpenTextDocumentParams { + /** + * The document that was opened. + */ + textDocument: TextDocumentItem; +} + +/** + * The change text document notification's parameters. + */ +export interface DidChangeTextDocumentParams { + /** + * The document that did change. The version number points + * to the version after all provided content changes have + * been applied. + */ + textDocument: VersionedTextDocumentIdentifier; + /** + * The actual content changes. The content changes describe single state changes + * to the document. So if there are two content changes c1 (at array index 0) and + * c2 (at array index 1) for a document in state S then c1 moves the document from + * S to S' and c2 from S' to S''. So c1 is computed on the state S and c2 is computed + * on the state S'. + * + * To mirror the content of a document using change events use the following approach: + * - start with the same initial content + * - apply the 'textDocument/didChange' notifications in the order you receive them. + * - apply the `TextDocumentContentChangeEvent`s in a single notification in the order + * you receive them. + */ + contentChanges: (TextDocumentContentChangeEvent)[]; +} + +/** + * Describe options to be used when registered for text document change events. + */ +export interface TextDocumentChangeRegistrationOptions extends TextDocumentRegistrationOptions { + /** + * How documents are synced to the server. + */ + syncKind: TextDocumentSyncKind; +} + +/** + * The parameters sent in a close text document notification + */ +export interface DidCloseTextDocumentParams { + /** + * The document that was closed. + */ + textDocument: TextDocumentIdentifier; +} + +/** + * The parameters sent in a save text document notification + */ +export interface DidSaveTextDocumentParams { + /** + * The document that was saved. + */ + textDocument: TextDocumentIdentifier; + /** + * Optional the content when saved. Depends on the includeText value + * when the save notification was requested. + */ + text?: string; +} + +/** + * Save registration options. + */ +export interface TextDocumentSaveRegistrationOptions extends TextDocumentRegistrationOptions, SaveOptions { +} + +/** + * The parameters sent in a will save text document notification. + */ +export interface WillSaveTextDocumentParams { + /** + * The document that will be saved. + */ + textDocument: TextDocumentIdentifier; + /** + * The 'TextDocumentSaveReason'. + */ + reason: TextDocumentSaveReason; +} + +/** + * A text edit applicable to a text document. + */ +export interface TextEdit { + /** + * The range of the text document to be manipulated. To insert + * text into a document create a range where start === end. + */ + range: Range; + /** + * The string to be inserted. For delete operations use an + * empty string. + */ + newText: string; +} + +/** + * The watched files change notification's parameters. + */ +export interface DidChangeWatchedFilesParams { + /** + * The actual file events. + */ + changes: (FileEvent)[]; +} + +/** + * Describe options to be used when registered for text document change events. + */ +export interface DidChangeWatchedFilesRegistrationOptions { + /** + * The watchers to register. + */ + watchers: (FileSystemWatcher)[]; +} + +/** + * The publish diagnostic notification's parameters. + */ +export interface PublishDiagnosticsParams { + /** + * The URI for which diagnostic information is reported. + */ + uri: string; + /** + * Optional the version number of the document the diagnostics are published for. + * + * @since 3.15.0 + */ + version?: number; + /** + * An array of diagnostic information items. + */ + diagnostics: (Diagnostic)[]; +} + +/** + * Completion parameters + */ +export interface CompletionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { + /** + * The completion context. This is only available if the client specifies + * to send this using the client capability `textDocument.completion.contextSupport === true` + */ + context?: CompletionContext; +} + +/** + * A completion item represents a text snippet that is + * proposed to complete text that is being typed. + */ +export interface CompletionItem { + /** + * The label of this completion item. + * + * The label property is also by default the text that + * is inserted when selecting this completion. + * + * If label details are provided the label itself should + * be an unqualified name of the completion item. + */ + label: string; + /** + * Additional details for the label + * + * @since 3.17.0 + */ + labelDetails?: CompletionItemLabelDetails; + /** + * The kind of this completion item. Based of the kind + * an icon is chosen by the editor. + */ + kind?: CompletionItemKind; + /** + * Tags for this completion item. + * + * @since 3.15.0 + */ + tags?: (CompletionItemTag)[]; + /** + * A human-readable string with additional information + * about this item, like type or symbol information. + */ + detail?: string; + /** + * A human-readable string that represents a doc-comment. + */ + documentation?: string | MarkupContent; + /** + * Indicates if this item is deprecated. + * @deprecated Use `tags` instead. + */ + deprecated?: boolean; + /** + * Select this item when showing. + * + * *Note* that only one completion item can be selected and that the + * tool / client decides which item that is. The rule is that the *first* + * item of those that match best is selected. + */ + preselect?: boolean; + /** + * A string that should be used when comparing this item + * with other items. When `falsy` the {@link CompletionItem.label label} + * is used. + */ + sortText?: string; + /** + * A string that should be used when filtering a set of + * completion items. When `falsy` the {@link CompletionItem.label label} + * is used. + */ + filterText?: string; + /** + * A string that should be inserted into a document when selecting + * this completion. When `falsy` the {@link CompletionItem.label label} + * is used. + * + * The `insertText` is subject to interpretation by the client side. + * Some tools might not take the string literally. For example + * VS Code when code complete is requested in this example + * `con` and a completion item with an `insertText` of + * `console` is provided it will only insert `sole`. Therefore it is + * recommended to use `textEdit` instead since it avoids additional client + * side interpretation. + */ + insertText?: string; + /** + * The format of the insert text. The format applies to both the + * `insertText` property and the `newText` property of a provided + * `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`. + * + * Please note that the insertTextFormat doesn't apply to + * `additionalTextEdits`. + */ + insertTextFormat?: InsertTextFormat; + /** + * How whitespace and indentation is handled during completion + * item insertion. If not provided the clients default value depends on + * the `textDocument.completion.insertTextMode` client capability. + * + * @since 3.16.0 + */ + insertTextMode?: InsertTextMode; + /** + * An {@link TextEdit edit} which is applied to a document when selecting + * this completion. When an edit is provided the value of + * {@link CompletionItem.insertText insertText} is ignored. + * + * Most editors support two different operations when accepting a completion + * item. One is to insert a completion text and the other is to replace an + * existing text with a completion text. Since this can usually not be + * predetermined by a server it can report both ranges. Clients need to + * signal support for `InsertReplaceEdits` via the + * `textDocument.completion.insertReplaceSupport` client capability + * property. + * + * *Note 1:* The text edit's range as well as both ranges from an insert + * replace edit must be a [single line] and they must contain the position + * at which completion has been requested. + * *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range + * must be a prefix of the edit's replace range, that means it must be + * contained and starting at the same position. + * + * @since 3.16.0 additional type `InsertReplaceEdit` + */ + textEdit?: TextEdit | InsertReplaceEdit; + /** + * The edit text used if the completion item is part of a CompletionList and + * CompletionList defines an item default for the text edit range. + * + * Clients will only honor this property if they opt into completion list + * item defaults using the capability `completionList.itemDefaults`. + * + * If not provided and a list's default range is provided the label + * property is used as a text. + * + * @since 3.17.0 + */ + textEditText?: string; + /** + * An optional array of additional {@link TextEdit text edits} that are applied when + * selecting this completion. Edits must not overlap (including the same insert position) + * with the main {@link CompletionItem.textEdit edit} nor with themselves. + * + * Additional text edits should be used to change text unrelated to the current cursor position + * (for example adding an import statement at the top of the file if the completion item will + * insert an unqualified type). + */ + additionalTextEdits?: (TextEdit)[]; + /** + * An optional set of characters that when pressed while this completion is active will accept it first and + * then type that character. *Note* that all commit characters should have `length=1` and that superfluous + * characters will be ignored. + */ + commitCharacters?: (string)[]; + /** + * An optional {@link Command command} that is executed *after* inserting this completion. *Note* that + * additional modifications to the current document should be described with the + * {@link CompletionItem.additionalTextEdits additionalTextEdits}-property. + */ + command?: Command; + /** + * A data entry field that is preserved on a completion item between a + * {@link CompletionRequest} and a {@link CompletionResolveRequest}. + */ + data?: LSPAny; +} + +/** + * Represents a collection of {@link CompletionItem completion items} to be presented + * in the editor. + */ +export interface CompletionList { + /** + * This list it not complete. Further typing results in recomputing this list. + * + * Recomputed lists have all their items replaced (not appended) in the + * incomplete completion sessions. + */ + isIncomplete: boolean; + /** + * In many cases the items of an actual completion result share the same + * value for properties like `commitCharacters` or the range of a text + * edit. A completion list can therefore define item defaults which will + * be used if a completion item itself doesn't specify the value. + * + * If a completion list specifies a default value and a completion item + * also specifies a corresponding value the one from the item is used. + * + * Servers are only allowed to return default values if the client + * signals support for this via the `completionList.itemDefaults` + * capability. + * + * @since 3.17.0 + */ + itemDefaults?: { + commitCharacters?: (string)[]; + editRange?: Range | { + insert: Range; + replace: Range + }; + insertTextFormat?: InsertTextFormat; + insertTextMode?: InsertTextMode; + data?: LSPAny + }; + /** + * The completion items. + */ + items: (CompletionItem)[]; +} + +/** + * Registration options for a {@link CompletionRequest}. + */ +export interface CompletionRegistrationOptions extends TextDocumentRegistrationOptions, CompletionOptions { +} + +/** + * Parameters for a {@link HoverRequest}. + */ +export interface HoverParams extends TextDocumentPositionParams, WorkDoneProgressParams { +} + +/** + * The result of a hover request. + */ +export interface Hover { + /** + * The hover's content + */ + contents: MarkupContent | MarkedString | (MarkedString)[]; + /** + * An optional range inside the text document that is used to + * visualize the hover, e.g. by changing the background color. + */ + range?: Range; +} + +/** + * Registration options for a {@link HoverRequest}. + */ +export interface HoverRegistrationOptions extends TextDocumentRegistrationOptions, HoverOptions { +} + +/** + * Parameters for a {@link SignatureHelpRequest}. + */ +export interface SignatureHelpParams extends TextDocumentPositionParams, WorkDoneProgressParams { + /** + * The signature help context. This is only available if the client specifies + * to send this using the client capability `textDocument.signatureHelp.contextSupport === true` + * + * @since 3.15.0 + */ + context?: SignatureHelpContext; +} + +/** + * Signature help represents the signature of something + * callable. There can be multiple signature but only one + * active and only one active parameter. + */ +export interface SignatureHelp { + /** + * One or more signatures. + */ + signatures: (SignatureInformation)[]; + /** + * The active signature. If omitted or the value lies outside the + * range of `signatures` the value defaults to zero or is ignored if + * the `SignatureHelp` has no signatures. + * + * Whenever possible implementors should make an active decision about + * the active signature and shouldn't rely on a default value. + * + * In future version of the protocol this property might become + * mandatory to better express this. + */ + activeSignature?: number; + /** + * The active parameter of the active signature. If omitted or the value + * lies outside the range of `signatures[activeSignature].parameters` + * defaults to 0 if the active signature has parameters. If + * the active signature has no parameters it is ignored. + * In future version of the protocol this property might become + * mandatory to better express the active parameter if the + * active signature does have any. + */ + activeParameter?: number; +} + +/** + * Registration options for a {@link SignatureHelpRequest}. + */ +export interface SignatureHelpRegistrationOptions extends TextDocumentRegistrationOptions, SignatureHelpOptions { +} + +/** + * Parameters for a {@link DefinitionRequest}. + */ +export interface DefinitionParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { +} + +/** + * Registration options for a {@link DefinitionRequest}. + */ +export interface DefinitionRegistrationOptions extends TextDocumentRegistrationOptions, DefinitionOptions { +} + +/** + * Parameters for a {@link ReferencesRequest}. + */ +export interface ReferenceParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { + context: ReferenceContext; +} + +/** + * Registration options for a {@link ReferencesRequest}. + */ +export interface ReferenceRegistrationOptions extends TextDocumentRegistrationOptions, ReferenceOptions { +} + +/** + * Parameters for a {@link DocumentHighlightRequest}. + */ +export interface DocumentHighlightParams extends TextDocumentPositionParams, WorkDoneProgressParams, PartialResultParams { +} + +/** + * A document highlight is a range inside a text document which deserves + * special attention. Usually a document highlight is visualized by changing + * the background color of its range. + */ +export interface DocumentHighlight { + /** + * The range this highlight applies to. + */ + range: Range; + /** + * The highlight kind, default is {@link DocumentHighlightKind.Text text}. + */ + kind?: DocumentHighlightKind; +} + +/** + * Registration options for a {@link DocumentHighlightRequest}. + */ +export interface DocumentHighlightRegistrationOptions extends TextDocumentRegistrationOptions, DocumentHighlightOptions { +} + +/** + * Parameters for a {@link DocumentSymbolRequest}. + */ +export interface DocumentSymbolParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; +} + +/** + * Represents information about programming constructs like variables, classes, + * interfaces etc. + */ +export interface SymbolInformation extends BaseSymbolInformation { + /** + * Indicates if this symbol is deprecated. + * + * @deprecated Use tags instead + */ + deprecated?: boolean; + /** + * The location of this symbol. The location's range is used by a tool + * to reveal the location in the editor. If the symbol is selected in the + * tool the range's start information is used to position the cursor. So + * the range usually spans more than the actual symbol's name and does + * normally include things like visibility modifiers. + * + * The range doesn't have to denote a node range in the sense of an abstract + * syntax tree. It can therefore not be used to re-construct a hierarchy of + * the symbols. + */ + location: Location; +} + +/** + * Represents programming constructs like variables, classes, interfaces etc. + * that appear in a document. Document symbols can be hierarchical and they + * have two ranges: one that encloses its definition and one that points to + * its most interesting range, e.g. the range of an identifier. + */ +export interface DocumentSymbol { + /** + * The name of this symbol. Will be displayed in the user interface and therefore must not be + * an empty string or a string only consisting of white spaces. + */ + name: string; + /** + * More detail for this symbol, e.g the signature of a function. + */ + detail?: string; + /** + * The kind of this symbol. + */ + kind: SymbolKind; + /** + * Tags for this document symbol. + * + * @since 3.16.0 + */ + tags?: (SymbolTag)[]; + /** + * Indicates if this symbol is deprecated. + * + * @deprecated Use tags instead + */ + deprecated?: boolean; + /** + * The range enclosing this symbol not including leading/trailing whitespace but everything else + * like comments. This information is typically used to determine if the clients cursor is + * inside the symbol to reveal in the symbol in the UI. + */ + range: Range; + /** + * The range that should be selected and revealed when this symbol is being picked, e.g the name of a function. + * Must be contained by the `range`. + */ + selectionRange: Range; + /** + * Children of this symbol, e.g. properties of a class. + */ + children?: (DocumentSymbol)[]; +} + +/** + * Registration options for a {@link DocumentSymbolRequest}. + */ +export interface DocumentSymbolRegistrationOptions extends TextDocumentRegistrationOptions, DocumentSymbolOptions { +} + +/** + * The parameters of a {@link CodeActionRequest}. + */ +export interface CodeActionParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The document in which the command was invoked. + */ + textDocument: TextDocumentIdentifier; + /** + * The range for which the command was invoked. + */ + range: Range; + /** + * Context carrying additional information. + */ + context: CodeActionContext; +} + +/** + * Represents a reference to a command. Provides a title which + * will be used to represent a command in the UI and, optionally, + * an array of arguments which will be passed to the command handler + * function when invoked. + */ +export interface Command { + /** + * Title of the command, like `save`. + */ + title: string; + /** + * The identifier of the actual command handler. + */ + command: string; + /** + * Arguments that the command handler should be + * invoked with. + */ + arguments?: (LSPAny)[]; +} + +/** + * A code action represents a change that can be performed in code, e.g. to fix a problem or + * to refactor code. + * + * A CodeAction must set either `edit` and/or a `command`. If both are supplied, the `edit` is applied first, then the `command` is executed. + */ +export interface CodeAction { + /** + * A short, human-readable, title for this code action. + */ + title: string; + /** + * The kind of the code action. + * + * Used to filter code actions. + */ + kind?: CodeActionKind; + /** + * The diagnostics that this code action resolves. + */ + diagnostics?: (Diagnostic)[]; + /** + * Marks this as a preferred action. Preferred actions are used by the `auto fix` command and can be targeted + * by keybindings. + * + * A quick fix should be marked preferred if it properly addresses the underlying error. + * A refactoring should be marked preferred if it is the most reasonable choice of actions to take. + * + * @since 3.15.0 + */ + isPreferred?: boolean; + /** + * Marks that the code action cannot currently be applied. + * + * Clients should follow the following guidelines regarding disabled code actions: + * + * - Disabled code actions are not shown in automatic [lightbulbs](https://code.visualstudio.com/docs/editor/editingevolved#_code-action) + * code action menus. + * + * - Disabled actions are shown as faded out in the code action menu when the user requests a more specific type + * of code action, such as refactorings. + * + * - If the user has a [keybinding](https://code.visualstudio.com/docs/editor/refactoring#_keybindings-for-code-actions) + * that auto applies a code action and only disabled code actions are returned, the client should show the user an + * error message with `reason` in the editor. + * + * @since 3.16.0 + */ + disabled?: { + reason: string + }; + /** + * The workspace edit this code action performs. + */ + edit?: WorkspaceEdit; + /** + * A command this code action executes. If a code action + * provides an edit and a command, first the edit is + * executed and then the command. + */ + command?: Command; + /** + * A data entry field that is preserved on a code action between + * a `textDocument/codeAction` and a `codeAction/resolve` request. + * + * @since 3.16.0 + */ + data?: LSPAny; +} + +/** + * Registration options for a {@link CodeActionRequest}. + */ +export interface CodeActionRegistrationOptions extends TextDocumentRegistrationOptions, CodeActionOptions { +} + +/** + * The parameters of a {@link WorkspaceSymbolRequest}. + */ +export interface WorkspaceSymbolParams extends WorkDoneProgressParams, PartialResultParams { + /** + * A query string to filter symbols by. Clients may send an empty + * string here to request all symbols. + */ + query: string; +} + +/** + * A special workspace symbol that supports locations without a range. + * + * See also SymbolInformation. + * + * @since 3.17.0 + */ +export interface WorkspaceSymbol extends BaseSymbolInformation { + /** + * The location of the symbol. Whether a server is allowed to + * return a location without a range depends on the client + * capability `workspace.symbol.resolveSupport`. + * + * See SymbolInformation#location for more details. + */ + location: Location | { + uri: string + }; + /** + * A data entry field that is preserved on a workspace symbol between a + * workspace symbol request and a workspace symbol resolve request. + */ + data?: LSPAny; +} + +/** + * Registration options for a {@link WorkspaceSymbolRequest}. + */ +export interface WorkspaceSymbolRegistrationOptions extends WorkspaceSymbolOptions { +} + +/** + * The parameters of a {@link CodeLensRequest}. + */ +export interface CodeLensParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The document to request code lens for. + */ + textDocument: TextDocumentIdentifier; +} + +/** + * A code lens represents a {@link Command command} that should be shown along with + * source text, like the number of references, a way to run tests, etc. + * + * A code lens is _unresolved_ when no command is associated to it. For performance + * reasons the creation of a code lens and resolving should be done in two stages. + */ +export interface CodeLens { + /** + * The range in which this code lens is valid. Should only span a single line. + */ + range: Range; + /** + * The command this code lens represents. + */ + command?: Command; + /** + * A data entry field that is preserved on a code lens item between + * a {@link CodeLensRequest} and a {@link CodeLensResolveRequest} + */ + data?: LSPAny; +} + +/** + * Registration options for a {@link CodeLensRequest}. + */ +export interface CodeLensRegistrationOptions extends TextDocumentRegistrationOptions, CodeLensOptions { +} + +/** + * The parameters of a {@link DocumentLinkRequest}. + */ +export interface DocumentLinkParams extends WorkDoneProgressParams, PartialResultParams { + /** + * The document to provide document links for. + */ + textDocument: TextDocumentIdentifier; +} + +/** + * A document link is a range in a text document that links to an internal or external resource, like another + * text document or a web site. + */ +export interface DocumentLink { + /** + * The range this link applies to. + */ + range: Range; + /** + * The uri this link points to. If missing a resolve request is sent later. + */ + target?: string; + /** + * The tooltip text when you hover over this link. + * + * If a tooltip is provided, is will be displayed in a string that includes instructions on how to + * trigger the link, such as `{0} (ctrl + click)`. The specific instructions vary depending on OS, + * user settings, and localization. + * + * @since 3.15.0 + */ + tooltip?: string; + /** + * A data entry field that is preserved on a document link between a + * DocumentLinkRequest and a DocumentLinkResolveRequest. + */ + data?: LSPAny; +} + +/** + * Registration options for a {@link DocumentLinkRequest}. + */ +export interface DocumentLinkRegistrationOptions extends TextDocumentRegistrationOptions, DocumentLinkOptions { +} + +/** + * The parameters of a {@link DocumentFormattingRequest}. + */ +export interface DocumentFormattingParams extends WorkDoneProgressParams { + /** + * The document to format. + */ + textDocument: TextDocumentIdentifier; + /** + * The format options. + */ + options: FormattingOptions; +} + +/** + * Registration options for a {@link DocumentFormattingRequest}. + */ +export interface DocumentFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentFormattingOptions { +} + +/** + * The parameters of a {@link DocumentRangeFormattingRequest}. + */ +export interface DocumentRangeFormattingParams extends WorkDoneProgressParams { + /** + * The document to format. + */ + textDocument: TextDocumentIdentifier; + /** + * The range to format + */ + range: Range; + /** + * The format options + */ + options: FormattingOptions; +} + +/** + * Registration options for a {@link DocumentRangeFormattingRequest}. + */ +export interface DocumentRangeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentRangeFormattingOptions { +} + +/** + * The parameters of a {@link DocumentRangesFormattingRequest}. + * + * @since 3.18.0 + * @proposed + */ +export interface DocumentRangesFormattingParams extends WorkDoneProgressParams { + /** + * The document to format. + */ + textDocument: TextDocumentIdentifier; + /** + * The ranges to format + */ + ranges: (Range)[]; + /** + * The format options + */ + options: FormattingOptions; +} + +/** + * The parameters of a {@link DocumentOnTypeFormattingRequest}. + */ +export interface DocumentOnTypeFormattingParams { + /** + * The document to format. + */ + textDocument: TextDocumentIdentifier; + /** + * The position around which the on type formatting should happen. + * This is not necessarily the exact position where the character denoted + * by the property `ch` got typed. + */ + position: Position; + /** + * The character that has been typed that triggered the formatting + * on type request. That is not necessarily the last character that + * got inserted into the document since the client could auto insert + * characters as well (e.g. like automatic brace completion). + */ + ch: string; + /** + * The formatting options. + */ + options: FormattingOptions; +} + +/** + * Registration options for a {@link DocumentOnTypeFormattingRequest}. + */ +export interface DocumentOnTypeFormattingRegistrationOptions extends TextDocumentRegistrationOptions, DocumentOnTypeFormattingOptions { +} + +/** + * The parameters of a {@link RenameRequest}. + */ +export interface RenameParams extends WorkDoneProgressParams { + /** + * The document to rename. + */ + textDocument: TextDocumentIdentifier; + /** + * The position at which this request was sent. + */ + position: Position; + /** + * The new name of the symbol. If the given name is not valid the + * request must return a {@link ResponseError} with an + * appropriate message set. + */ + newName: string; +} + +/** + * Registration options for a {@link RenameRequest}. + */ +export interface RenameRegistrationOptions extends TextDocumentRegistrationOptions, RenameOptions { +} + +export interface PrepareRenameParams extends TextDocumentPositionParams, WorkDoneProgressParams { +} + +/** + * The parameters of a {@link ExecuteCommandRequest}. + */ +export interface ExecuteCommandParams extends WorkDoneProgressParams { + /** + * The identifier of the actual command handler. + */ + command: string; + /** + * Arguments that the command should be invoked with. + */ + arguments?: (LSPAny)[]; +} + +/** + * Registration options for a {@link ExecuteCommandRequest}. + */ +export interface ExecuteCommandRegistrationOptions extends ExecuteCommandOptions { +} + +/** + * The parameters passed via an apply workspace edit request. + */ +export interface ApplyWorkspaceEditParams { + /** + * An optional label of the workspace edit. This label is + * presented in the user interface for example on an undo + * stack to undo the workspace edit. + */ + label?: string; + /** + * The edits to apply. + */ + edit: WorkspaceEdit; +} + +/** + * The result returned from the apply workspace edit request. + * + * @since 3.17 renamed from ApplyWorkspaceEditResponse + */ +export interface ApplyWorkspaceEditResult { + /** + * Indicates whether the edit was applied or not. + */ + applied: boolean; + /** + * An optional textual description for why the edit was not applied. + * This may be used by the server for diagnostic logging or to provide + * a suitable error for a request that triggered the edit. + */ + failureReason?: string; + /** + * Depending on the client's failure handling strategy `failedChange` might + * contain the index of the change that failed. This property is only available + * if the client signals a `failureHandlingStrategy` in its client capabilities. + */ + failedChange?: number; +} + +export interface WorkDoneProgressBegin { + kind: 'begin'; + /** + * Mandatory title of the progress operation. Used to briefly inform about + * the kind of operation being performed. + * + * Examples: "Indexing" or "Linking dependencies". + */ + title: string; + /** + * Controls if a cancel button should show to allow the user to cancel the + * long running operation. Clients that don't support cancellation are allowed + * to ignore the setting. + */ + cancellable?: boolean; + /** + * Optional, more detailed associated progress message. Contains + * complementary information to the `title`. + * + * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep". + * If unset, the previous progress message (if any) is still valid. + */ + message?: string; + /** + * Optional progress percentage to display (value 100 is considered 100%). + * If not provided infinite progress is assumed and clients are allowed + * to ignore the `percentage` value in subsequent report notifications. + * + * The value should be steadily rising. Clients are free to ignore values + * that are not following this rule. The value range is [0, 100]. + */ + percentage?: number; +} + +export interface WorkDoneProgressReport { + kind: 'report'; + /** + * Controls enablement state of a cancel button. + * + * Clients that don't support cancellation or don't support controlling the button's + * enablement state are allowed to ignore the property. + */ + cancellable?: boolean; + /** + * Optional, more detailed associated progress message. Contains + * complementary information to the `title`. + * + * Examples: "3/25 files", "project/src/module2", "node_modules/some_dep". + * If unset, the previous progress message (if any) is still valid. + */ + message?: string; + /** + * Optional progress percentage to display (value 100 is considered 100%). + * If not provided infinite progress is assumed and clients are allowed + * to ignore the `percentage` value in subsequent report notifications. + * + * The value should be steadily rising. Clients are free to ignore values + * that are not following this rule. The value range is [0, 100]. + */ + percentage?: number; +} + +export interface WorkDoneProgressEnd { + kind: 'end'; + /** + * Optional, a final message indicating to for example indicate the outcome + * of the operation. + */ + message?: string; +} + +export interface SetTraceParams { + value: TraceValues; +} + +export interface LogTraceParams { + message: string; + verbose?: string; +} + +export interface CancelParams { + /** + * The request id to cancel. + */ + id: number | string; +} + +export interface ProgressParams { + /** + * The progress token provided by the client or server. + */ + token: ProgressToken; + /** + * The progress data. + */ + value: LSPAny; +} + +/** + * A parameter literal used in requests to pass a text document and a position inside that + * document. + */ +export interface TextDocumentPositionParams { + /** + * The text document. + */ + textDocument: TextDocumentIdentifier; + /** + * The position inside the text document. + */ + position: Position; +} + +export interface WorkDoneProgressParams { + /** + * An optional token that a server can use to report work done progress. + */ + workDoneToken?: ProgressToken; +} + +export interface PartialResultParams { + /** + * An optional token that a server can use to report partial results (e.g. streaming) to + * the client. + */ + partialResultToken?: ProgressToken; +} + +/** + * Represents the connection of two locations. Provides additional metadata over normal {@link Location locations}, + * including an origin range. + */ +export interface LocationLink { + /** + * Span of the origin of this link. + * + * Used as the underlined span for mouse interaction. Defaults to the word range at + * the definition position. + */ + originSelectionRange?: Range; + /** + * The target resource identifier of this link. + */ + targetUri: string; + /** + * The full target range of this link. If the target for example is a symbol then target range is the + * range enclosing this symbol not including leading/trailing whitespace but everything else + * like comments. This information is typically used to highlight the range in the editor. + */ + targetRange: Range; + /** + * The range that should be selected and revealed when this link is being followed, e.g the name of a function. + * Must be contained by the `targetRange`. See also `DocumentSymbol#range` + */ + targetSelectionRange: Range; +} + +/** + * A range in a text document expressed as (zero-based) start and end positions. + * + * If you want to specify a range that contains a line including the line ending + * character(s) then use an end position denoting the start of the next line. + * For example: + * ```ts + * { + * start: { line: 5, character: 23 } + * end : { line 6, character : 0 } + * } + * ``` + */ +export interface Range { + /** + * The range's start position. + */ + start: Position; + /** + * The range's end position. + */ + end: Position; +} + +export interface ImplementationOptions extends WorkDoneProgressOptions { +} + +/** + * Static registration options to be returned in the initialize + * request. + */ +export interface StaticRegistrationOptions { + /** + * The id used to register the request. The id can be used to deregister + * the request again. See also Registration#id. + */ + id?: string; +} + +export interface TypeDefinitionOptions extends WorkDoneProgressOptions { +} + +/** + * The workspace folder change event. + */ +export interface WorkspaceFoldersChangeEvent { + /** + * The array of added workspace folders + */ + added: (WorkspaceFolder)[]; + /** + * The array of the removed workspace folders + */ + removed: (WorkspaceFolder)[]; +} + +export interface ConfigurationItem { + /** + * The scope to get the configuration section for. + */ + scopeUri?: string; + /** + * The configuration section asked for. + */ + section?: string; +} + +/** + * A literal to identify a text document in the client. + */ +export interface TextDocumentIdentifier { + /** + * The text document's uri. + */ + uri: string; +} + +/** + * Represents a color in RGBA space. + */ +export interface Color { + /** + * The red component of this color in the range [0-1]. + */ + red: number; + /** + * The green component of this color in the range [0-1]. + */ + green: number; + /** + * The blue component of this color in the range [0-1]. + */ + blue: number; + /** + * The alpha component of this color in the range [0-1]. + */ + alpha: number; +} + +export interface DocumentColorOptions extends WorkDoneProgressOptions { +} + +export interface FoldingRangeOptions extends WorkDoneProgressOptions { +} + +export interface DeclarationOptions extends WorkDoneProgressOptions { +} + +/** + * Position in a text document expressed as zero-based line and character + * offset. Prior to 3.17 the offsets were always based on a UTF-16 string + * representation. So a string of the form `a𐐀b` the character offset of the + * character `a` is 0, the character offset of `𐐀` is 1 and the character + * offset of b is 3 since `𐐀` is represented using two code units in UTF-16. + * Since 3.17 clients and servers can agree on a different string encoding + * representation (e.g. UTF-8). The client announces it's supported encoding + * via the client capability [`general.positionEncodings`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#clientCapabilities). + * The value is an array of position encodings the client supports, with + * decreasing preference (e.g. the encoding at index `0` is the most preferred + * one). To stay backwards compatible the only mandatory encoding is UTF-16 + * represented via the string `utf-16`. The server can pick one of the + * encodings offered by the client and signals that encoding back to the + * client via the initialize result's property + * [`capabilities.positionEncoding`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#serverCapabilities). If the string value + * `utf-16` is missing from the client's capability `general.positionEncodings` + * servers can safely assume that the client supports UTF-16. If the server + * omits the position encoding in its initialize result the encoding defaults + * to the string value `utf-16`. Implementation considerations: since the + * conversion from one encoding into another requires the content of the + * file / line the conversion is best done where the file is read which is + * usually on the server side. + * + * Positions are line end character agnostic. So you can not specify a position + * that denotes `\r|\n` or `\n|` where `|` represents the character offset. + * + * @since 3.17.0 - support for negotiated position encoding. + */ +export interface Position { + /** + * Line position in a document (zero-based). + * + * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document. + * If a line number is negative, it defaults to 0. + */ + line: number; + /** + * Character offset on a line in a document (zero-based). + * + * The meaning of this offset is determined by the negotiated + * `PositionEncodingKind`. + * + * If the character value is greater than the line length it defaults back to the + * line length. + */ + character: number; +} + +export interface SelectionRangeOptions extends WorkDoneProgressOptions { +} + +/** + * Call hierarchy options used during static registration. + * + * @since 3.16.0 + */ +export interface CallHierarchyOptions extends WorkDoneProgressOptions { +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensOptions extends WorkDoneProgressOptions { + /** + * The legend used by the server + */ + legend: SemanticTokensLegend; + /** + * Server supports providing semantic tokens for a specific range + * of a document. + */ + range?: boolean | { + + }; + /** + * Server supports providing semantic tokens for a full document. + */ + full?: boolean | { + delta?: boolean + }; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensEdit { + /** + * The start offset of the edit. + */ + start: number; + /** + * The count of elements to remove. + */ + deleteCount: number; + /** + * The elements to insert. + */ + data?: (number)[]; +} + +export interface LinkedEditingRangeOptions extends WorkDoneProgressOptions { +} + +/** + * Represents information on a file/folder create. + * + * @since 3.16.0 + */ +export interface FileCreate { + /** + * A file:// URI for the location of the file/folder being created. + */ + uri: string; +} + +/** + * Describes textual changes on a text document. A TextDocumentEdit describes all changes + * on a document version Si and after they are applied move the document to version Si+1. + * So the creator of a TextDocumentEdit doesn't need to sort the array of edits or do any + * kind of ordering. However the edits must be non overlapping. + */ +export interface TextDocumentEdit { + /** + * The text document to change. + */ + textDocument: OptionalVersionedTextDocumentIdentifier; + /** + * The edits to be applied. + * + * @since 3.16.0 - support for AnnotatedTextEdit. This is guarded using a + * client capability. + */ + edits: (TextEdit | AnnotatedTextEdit)[]; +} + +/** + * Create file operation. + */ +export interface CreateFile extends ResourceOperation { + /** + * A create + */ + kind: 'create'; + /** + * The resource to create. + */ + uri: string; + /** + * Additional options + */ + options?: CreateFileOptions; +} + +/** + * Rename file operation + */ +export interface RenameFile extends ResourceOperation { + /** + * A rename + */ + kind: 'rename'; + /** + * The old (existing) location. + */ + oldUri: string; + /** + * The new location. + */ + newUri: string; + /** + * Rename options. + */ + options?: RenameFileOptions; +} + +/** + * Delete file operation + */ +export interface DeleteFile extends ResourceOperation { + /** + * A delete + */ + kind: 'delete'; + /** + * The file to delete. + */ + uri: string; + /** + * Delete options. + */ + options?: DeleteFileOptions; +} + +/** + * Additional information that describes document changes. + * + * @since 3.16.0 + */ +export interface ChangeAnnotation { + /** + * A human-readable string describing the actual change. The string + * is rendered prominent in the user interface. + */ + label: string; + /** + * A flag which indicates that user confirmation is needed + * before applying the change. + */ + needsConfirmation?: boolean; + /** + * A human-readable string which is rendered less prominent in + * the user interface. + */ + description?: string; +} + +/** + * A filter to describe in which file operation requests or notifications + * the server is interested in receiving. + * + * @since 3.16.0 + */ +export interface FileOperationFilter { + /** + * A Uri scheme like `file` or `untitled`. + */ + scheme?: string; + /** + * The actual file operation pattern. + */ + pattern: FileOperationPattern; +} + +/** + * Represents information on a file/folder rename. + * + * @since 3.16.0 + */ +export interface FileRename { + /** + * A file:// URI for the original location of the file/folder being renamed. + */ + oldUri: string; + /** + * A file:// URI for the new location of the file/folder being renamed. + */ + newUri: string; +} + +/** + * Represents information on a file/folder delete. + * + * @since 3.16.0 + */ +export interface FileDelete { + /** + * A file:// URI for the location of the file/folder being deleted. + */ + uri: string; +} + +export interface MonikerOptions extends WorkDoneProgressOptions { +} + +/** + * Type hierarchy options used during static registration. + * + * @since 3.17.0 + */ +export interface TypeHierarchyOptions extends WorkDoneProgressOptions { +} + +/** + * @since 3.17.0 + */ +export interface InlineValueContext { + /** + * The stack frame (as a DAP Id) where the execution has stopped. + */ + frameId: number; + /** + * The document range where execution has stopped. + * Typically the end position of the range denotes the line where the inline values are shown. + */ + stoppedLocation: Range; +} + +/** + * Provide inline value as text. + * + * @since 3.17.0 + */ +export interface InlineValueText { + /** + * The document range for which the inline value applies. + */ + range: Range; + /** + * The text of the inline value. + */ + text: string; +} + +/** + * Provide inline value through a variable lookup. + * If only a range is specified, the variable name will be extracted from the underlying document. + * An optional variable name can be used to override the extracted name. + * + * @since 3.17.0 + */ +export interface InlineValueVariableLookup { + /** + * The document range for which the inline value applies. + * The range is used to extract the variable name from the underlying document. + */ + range: Range; + /** + * If specified the name of the variable to look up. + */ + variableName?: string; + /** + * How to perform the lookup. + */ + caseSensitiveLookup: boolean; +} + +/** + * Provide an inline value through an expression evaluation. + * If only a range is specified, the expression will be extracted from the underlying document. + * An optional expression can be used to override the extracted expression. + * + * @since 3.17.0 + */ +export interface InlineValueEvaluatableExpression { + /** + * The document range for which the inline value applies. + * The range is used to extract the evaluatable expression from the underlying document. + */ + range: Range; + /** + * If specified the expression overrides the extracted expression. + */ + expression?: string; +} + +/** + * Inline value options used during static registration. + * + * @since 3.17.0 + */ +export interface InlineValueOptions extends WorkDoneProgressOptions { +} + +/** + * An inlay hint label part allows for interactive and composite labels + * of inlay hints. + * + * @since 3.17.0 + */ +export interface InlayHintLabelPart { + /** + * The value of this label part. + */ + value: string; + /** + * The tooltip text when you hover over this label part. Depending on + * the client capability `inlayHint.resolveSupport` clients might resolve + * this property late using the resolve request. + */ + tooltip?: string | MarkupContent; + /** + * An optional source code location that represents this + * label part. + * + * The editor will use this location for the hover and for code navigation + * features: This part will become a clickable link that resolves to the + * definition of the symbol at the given location (not necessarily the + * location itself), it shows the hover that shows at the given location, + * and it shows a context menu with further code navigation commands. + * + * Depending on the client capability `inlayHint.resolveSupport` clients + * might resolve this property late using the resolve request. + */ + location?: Location; + /** + * An optional command for this label part. + * + * Depending on the client capability `inlayHint.resolveSupport` clients + * might resolve this property late using the resolve request. + */ + command?: Command; +} + +/** + * A `MarkupContent` literal represents a string value which content is interpreted base on its + * kind flag. Currently the protocol supports `plaintext` and `markdown` as markup kinds. + * + * If the kind is `markdown` then the value can contain fenced code blocks like in GitHub issues. + * See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting + * + * Here is an example how such a string can be constructed using JavaScript / TypeScript: + * ```ts + * let markdown: MarkdownContent = { + * kind: MarkupKind.Markdown, + * value: [ + * '# Header', + * 'Some text', + * '```typescript', + * 'someCode();', + * '```' + * ].join('\n') + * }; + * ``` + * + * *Please Note* that clients might sanitize the return markdown. A client could decide to + * remove HTML from the markdown to avoid script execution. + */ +export interface MarkupContent { + /** + * The type of the Markup + */ + kind: MarkupKind; + /** + * The content itself + */ + value: string; +} + +/** + * Inlay hint options used during static registration. + * + * @since 3.17.0 + */ +export interface InlayHintOptions extends WorkDoneProgressOptions { + /** + * The server provides support to resolve additional + * information for an inlay hint item. + */ + resolveProvider?: boolean; +} + +/** + * A full diagnostic report with a set of related documents. + * + * @since 3.17.0 + */ +export interface RelatedFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport { + /** + * Diagnostics of related documents. This information is useful + * in programming languages where code in a file A can generate + * diagnostics in a file B which A depends on. An example of + * such a language is C/C++ where marco definitions in a file + * a.cpp and result in errors in a header file b.hpp. + * + * @since 3.17.0 + */ + relatedDocuments?: { [key: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport }; +} + +/** + * An unchanged diagnostic report with a set of related documents. + * + * @since 3.17.0 + */ +export interface RelatedUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport { + /** + * Diagnostics of related documents. This information is useful + * in programming languages where code in a file A can generate + * diagnostics in a file B which A depends on. An example of + * such a language is C/C++ where marco definitions in a file + * a.cpp and result in errors in a header file b.hpp. + * + * @since 3.17.0 + */ + relatedDocuments?: { [key: string]: FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport }; +} + +/** + * A diagnostic report with a full set of problems. + * + * @since 3.17.0 + */ +export interface FullDocumentDiagnosticReport { + /** + * A full document diagnostic report. + */ + kind: 'full'; + /** + * An optional result id. If provided it will + * be sent on the next diagnostic request for the + * same document. + */ + resultId?: string; + /** + * The actual items. + */ + items: (Diagnostic)[]; +} + +/** + * A diagnostic report indicating that the last returned + * report is still accurate. + * + * @since 3.17.0 + */ +export interface UnchangedDocumentDiagnosticReport { + /** + * A document diagnostic report indicating + * no changes to the last result. A server can + * only return `unchanged` if result ids are + * provided. + */ + kind: 'unchanged'; + /** + * A result id which will be sent on the next + * diagnostic request for the same document. + */ + resultId: string; +} + +/** + * Diagnostic options. + * + * @since 3.17.0 + */ +export interface DiagnosticOptions extends WorkDoneProgressOptions { + /** + * An optional identifier under which the diagnostics are + * managed by the client. + */ + identifier?: string; + /** + * Whether the language has inter file dependencies meaning that + * editing code in one file can result in a different diagnostic + * set in another file. Inter file dependencies are common for + * most programming languages and typically uncommon for linters. + */ + interFileDependencies: boolean; + /** + * The server provides support for workspace diagnostics as well. + */ + workspaceDiagnostics: boolean; +} + +/** + * A previous result id in a workspace pull request. + * + * @since 3.17.0 + */ +export interface PreviousResultId { + /** + * The URI for which the client knowns a + * result id. + */ + uri: string; + /** + * The value of the previous result id. + */ + value: string; +} + +/** + * A notebook document. + * + * @since 3.17.0 + */ +export interface NotebookDocument { + /** + * The notebook document's uri. + */ + uri: string; + /** + * The type of the notebook. + */ + notebookType: string; + /** + * The version number of this document (it will increase after each + * change, including undo/redo). + */ + version: number; + /** + * Additional metadata stored with the notebook + * document. + * + * Note: should always be an object literal (e.g. LSPObject) + */ + metadata?: LSPObject; + /** + * The cells of a notebook. + */ + cells: (NotebookCell)[]; +} + +/** + * An item to transfer a text document from the client to the + * server. + */ +export interface TextDocumentItem { + /** + * The text document's uri. + */ + uri: string; + /** + * The text document's language identifier. + */ + languageId: string; + /** + * The version number of this document (it will increase after each + * change, including undo/redo). + */ + version: number; + /** + * The content of the opened text document. + */ + text: string; +} + +/** + * A versioned notebook document identifier. + * + * @since 3.17.0 + */ +export interface VersionedNotebookDocumentIdentifier { + /** + * The version number of this notebook document. + */ + version: number; + /** + * The notebook document's uri. + */ + uri: string; +} + +/** + * A change event for a notebook document. + * + * @since 3.17.0 + */ +export interface NotebookDocumentChangeEvent { + /** + * The changed meta data if any. + * + * Note: should always be an object literal (e.g. LSPObject) + */ + metadata?: LSPObject; + /** + * Changes to cells + */ + cells?: { + structure?: { + array: NotebookCellArrayChange; + didOpen?: (TextDocumentItem)[]; + didClose?: (TextDocumentIdentifier)[] + }; + data?: (NotebookCell)[]; + textContent?: ({ + document: VersionedTextDocumentIdentifier; + changes: (TextDocumentContentChangeEvent)[] + })[] + }; +} + +/** + * A literal to identify a notebook document in the client. + * + * @since 3.17.0 + */ +export interface NotebookDocumentIdentifier { + /** + * The notebook document's uri. + */ + uri: string; +} + +/** + * Provides information about the context in which an inline completion was requested. + * + * @since 3.18.0 + * @proposed + */ +export interface InlineCompletionContext { + /** + * Describes how the inline completion was triggered. + */ + triggerKind: InlineCompletionTriggerKind; + /** + * Provides information about the currently selected item in the autocomplete widget if it is visible. + */ + selectedCompletionInfo?: SelectedCompletionInfo; +} + +/** + * A string value used as a snippet is a template which allows to insert text + * and to control the editor cursor when insertion happens. + * + * A snippet can define tab stops and placeholders with `$1`, `$2` + * and `${3:foo}`. `$0` defines the final tab stop, it defaults to + * the end of the snippet. Variables are defined with `$name` and + * `${name:default value}`. + * + * @since 3.18.0 + * @proposed + */ +export interface StringValue { + /** + * The kind of string value. + */ + kind: 'snippet'; + /** + * The snippet string. + */ + value: string; +} + +/** + * Inline completion options used during static registration. + * + * @since 3.18.0 + * @proposed + */ +export interface InlineCompletionOptions extends WorkDoneProgressOptions { +} + +/** + * General parameters to register for a notification or to register a provider. + */ +export interface Registration { + /** + * The id used to register the request. The id can be used to deregister + * the request again. + */ + id: string; + /** + * The method / capability to register for. + */ + method: string; + /** + * Options necessary for the registration. + */ + registerOptions?: LSPAny; +} + +/** + * General parameters to unregister a request or notification. + */ +export interface Unregistration { + /** + * The id used to unregister the request or notification. Usually an id + * provided during the register request. + */ + id: string; + /** + * The method to unregister for. + */ + method: string; +} + +/** + * The initialize parameters + */ +export interface _InitializeParams extends WorkDoneProgressParams { + /** + * The process Id of the parent process that started + * the server. + * + * Is `null` if the process has not been started by another process. + * If the parent process is not alive then the server should exit. + */ + processId: number | null; + /** + * Information about the client + * + * @since 3.15.0 + */ + clientInfo?: { + name: string; + version?: string + }; + /** + * The locale the client is currently showing the user interface + * in. This must not necessarily be the locale of the operating + * system. + * + * Uses IETF language tags as the value's syntax + * (See https://en.wikipedia.org/wiki/IETF_language_tag) + * + * @since 3.16.0 + */ + locale?: string; + /** + * The rootPath of the workspace. Is null + * if no folder is open. + * + * @deprecated in favour of rootUri. + */ + rootPath?: string | null; + /** + * The rootUri of the workspace. Is null if no + * folder is open. If both `rootPath` and `rootUri` are set + * `rootUri` wins. + * + * @deprecated in favour of workspaceFolders. + */ + rootUri: string | null; + /** + * The capabilities provided by the client (editor or tool) + */ + capabilities: ClientCapabilities; + /** + * User provided initialization options. + */ + initializationOptions?: LSPAny; + /** + * The initial trace setting. If omitted trace is disabled ('off'). + */ + trace?: TraceValues; +} + +export interface WorkspaceFoldersInitializeParams { + /** + * The workspace folders configured in the client when the server starts. + * + * This property is only available if the client supports workspace folders. + * It can be `null` if the client supports workspace folders but none are + * configured. + * + * @since 3.6.0 + */ + workspaceFolders?: (WorkspaceFolder)[] | null; +} + +/** + * Defines the capabilities provided by a language + * server. + */ +export interface ServerCapabilities { + /** + * The position encoding the server picked from the encodings offered + * by the client via the client capability `general.positionEncodings`. + * + * If the client didn't provide any position encodings the only valid + * value that a server can return is 'utf-16'. + * + * If omitted it defaults to 'utf-16'. + * + * @since 3.17.0 + */ + positionEncoding?: PositionEncodingKind; + /** + * Defines how text documents are synced. Is either a detailed structure + * defining each notification or for backwards compatibility the + * TextDocumentSyncKind number. + */ + textDocumentSync?: TextDocumentSyncOptions | TextDocumentSyncKind; + /** + * Defines how notebook documents are synced. + * + * @since 3.17.0 + */ + notebookDocumentSync?: NotebookDocumentSyncOptions | NotebookDocumentSyncRegistrationOptions; + /** + * The server provides completion support. + */ + completionProvider?: CompletionOptions; + /** + * The server provides hover support. + */ + hoverProvider?: boolean | HoverOptions; + /** + * The server provides signature help support. + */ + signatureHelpProvider?: SignatureHelpOptions; + /** + * The server provides Goto Declaration support. + */ + declarationProvider?: boolean | DeclarationOptions | DeclarationRegistrationOptions; + /** + * The server provides goto definition support. + */ + definitionProvider?: boolean | DefinitionOptions; + /** + * The server provides Goto Type Definition support. + */ + typeDefinitionProvider?: boolean | TypeDefinitionOptions | TypeDefinitionRegistrationOptions; + /** + * The server provides Goto Implementation support. + */ + implementationProvider?: boolean | ImplementationOptions | ImplementationRegistrationOptions; + /** + * The server provides find references support. + */ + referencesProvider?: boolean | ReferenceOptions; + /** + * The server provides document highlight support. + */ + documentHighlightProvider?: boolean | DocumentHighlightOptions; + /** + * The server provides document symbol support. + */ + documentSymbolProvider?: boolean | DocumentSymbolOptions; + /** + * The server provides code actions. CodeActionOptions may only be + * specified if the client states that it supports + * `codeActionLiteralSupport` in its initial `initialize` request. + */ + codeActionProvider?: boolean | CodeActionOptions; + /** + * The server provides code lens. + */ + codeLensProvider?: CodeLensOptions; + /** + * The server provides document link support. + */ + documentLinkProvider?: DocumentLinkOptions; + /** + * The server provides color provider support. + */ + colorProvider?: boolean | DocumentColorOptions | DocumentColorRegistrationOptions; + /** + * The server provides workspace symbol support. + */ + workspaceSymbolProvider?: boolean | WorkspaceSymbolOptions; + /** + * The server provides document formatting. + */ + documentFormattingProvider?: boolean | DocumentFormattingOptions; + /** + * The server provides document range formatting. + */ + documentRangeFormattingProvider?: boolean | DocumentRangeFormattingOptions; + /** + * The server provides document formatting on typing. + */ + documentOnTypeFormattingProvider?: DocumentOnTypeFormattingOptions; + /** + * The server provides rename support. RenameOptions may only be + * specified if the client states that it supports + * `prepareSupport` in its initial `initialize` request. + */ + renameProvider?: boolean | RenameOptions; + /** + * The server provides folding provider support. + */ + foldingRangeProvider?: boolean | FoldingRangeOptions | FoldingRangeRegistrationOptions; + /** + * The server provides selection range support. + */ + selectionRangeProvider?: boolean | SelectionRangeOptions | SelectionRangeRegistrationOptions; + /** + * The server provides execute command support. + */ + executeCommandProvider?: ExecuteCommandOptions; + /** + * The server provides call hierarchy support. + * + * @since 3.16.0 + */ + callHierarchyProvider?: boolean | CallHierarchyOptions | CallHierarchyRegistrationOptions; + /** + * The server provides linked editing range support. + * + * @since 3.16.0 + */ + linkedEditingRangeProvider?: boolean | LinkedEditingRangeOptions | LinkedEditingRangeRegistrationOptions; + /** + * The server provides semantic tokens support. + * + * @since 3.16.0 + */ + semanticTokensProvider?: SemanticTokensOptions | SemanticTokensRegistrationOptions; + /** + * The server provides moniker support. + * + * @since 3.16.0 + */ + monikerProvider?: boolean | MonikerOptions | MonikerRegistrationOptions; + /** + * The server provides type hierarchy support. + * + * @since 3.17.0 + */ + typeHierarchyProvider?: boolean | TypeHierarchyOptions | TypeHierarchyRegistrationOptions; + /** + * The server provides inline values. + * + * @since 3.17.0 + */ + inlineValueProvider?: boolean | InlineValueOptions | InlineValueRegistrationOptions; + /** + * The server provides inlay hints. + * + * @since 3.17.0 + */ + inlayHintProvider?: boolean | InlayHintOptions | InlayHintRegistrationOptions; + /** + * The server has support for pull model diagnostics. + * + * @since 3.17.0 + */ + diagnosticProvider?: DiagnosticOptions | DiagnosticRegistrationOptions; + /** + * Inline completion options used during static registration. + * + * @since 3.18.0 + * @proposed + */ + inlineCompletionProvider?: boolean | InlineCompletionOptions; + /** + * Workspace specific server capabilities. + */ + workspace?: { + workspaceFolders?: WorkspaceFoldersServerCapabilities; + fileOperations?: FileOperationOptions + }; + /** + * Experimental server capabilities. + */ + experimental?: LSPAny; +} + +/** + * A text document identifier to denote a specific version of a text document. + */ +export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier { + /** + * The version number of this document. + */ + version: number; +} + +/** + * Save options. + */ +export interface SaveOptions { + /** + * The client is supposed to include the content on save. + */ + includeText?: boolean; +} + +/** + * An event describing a file change. + */ +export interface FileEvent { + /** + * The file's uri. + */ + uri: string; + /** + * The change type. + */ + type: FileChangeType; +} + +export interface FileSystemWatcher { + /** + * The glob pattern to watch. See {@link GlobPattern glob pattern} for more detail. + * + * @since 3.17.0 support for relative patterns. + */ + globPattern: GlobPattern; + /** + * The kind of events of interest. If omitted it defaults + * to WatchKind.Create | WatchKind.Change | WatchKind.Delete + * which is 7. + */ + kind?: WatchKind; +} + +/** + * Represents a diagnostic, such as a compiler error or warning. Diagnostic objects + * are only valid in the scope of a resource. + */ +export interface Diagnostic { + /** + * The range at which the message applies + */ + range: Range; + /** + * The diagnostic's severity. Can be omitted. If omitted it is up to the + * client to interpret diagnostics as error, warning, info or hint. + */ + severity?: DiagnosticSeverity; + /** + * The diagnostic's code, which usually appear in the user interface. + */ + code?: number | string; + /** + * An optional property to describe the error code. + * Requires the code field (above) to be present/not null. + * + * @since 3.16.0 + */ + codeDescription?: CodeDescription; + /** + * A human-readable string describing the source of this + * diagnostic, e.g. 'typescript' or 'super lint'. It usually + * appears in the user interface. + */ + source?: string; + /** + * The diagnostic's message. It usually appears in the user interface + */ + message: string; + /** + * Additional metadata about the diagnostic. + * + * @since 3.15.0 + */ + tags?: (DiagnosticTag)[]; + /** + * An array of related diagnostic information, e.g. when symbol-names within + * a scope collide all definitions can be marked via this property. + */ + relatedInformation?: (DiagnosticRelatedInformation)[]; + /** + * A data entry field that is preserved between a `textDocument/publishDiagnostics` + * notification and `textDocument/codeAction` request. + * + * @since 3.16.0 + */ + data?: LSPAny; +} + +/** + * Contains additional information about the context in which a completion request is triggered. + */ +export interface CompletionContext { + /** + * How the completion was triggered. + */ + triggerKind: CompletionTriggerKind; + /** + * The trigger character (a single character) that has trigger code complete. + * Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter` + */ + triggerCharacter?: string; +} + +/** + * Additional details for a completion item label. + * + * @since 3.17.0 + */ +export interface CompletionItemLabelDetails { + /** + * An optional string which is rendered less prominently directly after {@link CompletionItem.label label}, + * without any spacing. Should be used for function signatures and type annotations. + */ + detail?: string; + /** + * An optional string which is rendered less prominently after {@link CompletionItem.detail}. Should be used + * for fully qualified names and file paths. + */ + description?: string; +} + +/** + * A special text edit to provide an insert and a replace operation. + * + * @since 3.16.0 + */ +export interface InsertReplaceEdit { + /** + * The string to be inserted. + */ + newText: string; + /** + * The range if the insert is requested + */ + insert: Range; + /** + * The range if the replace is requested. + */ + replace: Range; +} + +/** + * Completion options. + */ +export interface CompletionOptions extends WorkDoneProgressOptions { + /** + * Most tools trigger completion request automatically without explicitly requesting + * it using a keyboard shortcut (e.g. Ctrl+Space). Typically they do so when the user + * starts to type an identifier. For example if the user types `c` in a JavaScript file + * code complete will automatically pop up present `console` besides others as a + * completion item. Characters that make up identifiers don't need to be listed here. + * + * If code complete should automatically be trigger on characters not being valid inside + * an identifier (for example `.` in JavaScript) list them in `triggerCharacters`. + */ + triggerCharacters?: (string)[]; + /** + * The list of all possible characters that commit a completion. This field can be used + * if clients don't support individual commit characters per completion item. See + * `ClientCapabilities.textDocument.completion.completionItem.commitCharactersSupport` + * + * If a server provides both `allCommitCharacters` and commit characters on an individual + * completion item the ones on the completion item win. + * + * @since 3.2.0 + */ + allCommitCharacters?: (string)[]; + /** + * The server provides support to resolve additional + * information for a completion item. + */ + resolveProvider?: boolean; + /** + * The server supports the following `CompletionItem` specific + * capabilities. + * + * @since 3.17.0 + */ + completionItem?: { + labelDetailsSupport?: boolean + }; +} + +/** + * Hover options. + */ +export interface HoverOptions extends WorkDoneProgressOptions { +} + +/** + * Additional information about the context in which a signature help request was triggered. + * + * @since 3.15.0 + */ +export interface SignatureHelpContext { + /** + * Action that caused signature help to be triggered. + */ + triggerKind: SignatureHelpTriggerKind; + /** + * Character that caused signature help to be triggered. + * + * This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter` + */ + triggerCharacter?: string; + /** + * `true` if signature help was already showing when it was triggered. + * + * Retriggers occurs when the signature help is already active and can be caused by actions such as + * typing a trigger character, a cursor move, or document content changes. + */ + isRetrigger: boolean; + /** + * The currently active `SignatureHelp`. + * + * The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on + * the user navigating through available signatures. + */ + activeSignatureHelp?: SignatureHelp; +} + +/** + * Represents the signature of something callable. A signature + * can have a label, like a function-name, a doc-comment, and + * a set of parameters. + */ +export interface SignatureInformation { + /** + * The label of this signature. Will be shown in + * the UI. + */ + label: string; + /** + * The human-readable doc-comment of this signature. Will be shown + * in the UI but can be omitted. + */ + documentation?: string | MarkupContent; + /** + * The parameters of this signature. + */ + parameters?: (ParameterInformation)[]; + /** + * The index of the active parameter. + * + * If provided, this is used in place of `SignatureHelp.activeParameter`. + * + * @since 3.16.0 + */ + activeParameter?: number; +} + +/** + * Server Capabilities for a {@link SignatureHelpRequest}. + */ +export interface SignatureHelpOptions extends WorkDoneProgressOptions { + /** + * List of characters that trigger signature help automatically. + */ + triggerCharacters?: (string)[]; + /** + * List of characters that re-trigger signature help. + * + * These trigger characters are only active when signature help is already showing. All trigger characters + * are also counted as re-trigger characters. + * + * @since 3.15.0 + */ + retriggerCharacters?: (string)[]; +} + +/** + * Server Capabilities for a {@link DefinitionRequest}. + */ +export interface DefinitionOptions extends WorkDoneProgressOptions { +} + +/** + * Value-object that contains additional information when + * requesting references. + */ +export interface ReferenceContext { + /** + * Include the declaration of the current symbol. + */ + includeDeclaration: boolean; +} + +/** + * Reference options. + */ +export interface ReferenceOptions extends WorkDoneProgressOptions { +} + +/** + * Provider options for a {@link DocumentHighlightRequest}. + */ +export interface DocumentHighlightOptions extends WorkDoneProgressOptions { +} + +/** + * A base for all symbol information. + */ +export interface BaseSymbolInformation { + /** + * The name of this symbol. + */ + name: string; + /** + * The kind of this symbol. + */ + kind: SymbolKind; + /** + * Tags for this symbol. + * + * @since 3.16.0 + */ + tags?: (SymbolTag)[]; + /** + * The name of the symbol containing this symbol. This information is for + * user interface purposes (e.g. to render a qualifier in the user interface + * if necessary). It can't be used to re-infer a hierarchy for the document + * symbols. + */ + containerName?: string; +} + +/** + * Provider options for a {@link DocumentSymbolRequest}. + */ +export interface DocumentSymbolOptions extends WorkDoneProgressOptions { + /** + * A human-readable string that is shown when multiple outlines trees + * are shown for the same document. + * + * @since 3.16.0 + */ + label?: string; +} + +/** + * Contains additional diagnostic information about the context in which + * a {@link CodeActionProvider.provideCodeActions code action} is run. + */ +export interface CodeActionContext { + /** + * An array of diagnostics known on the client side overlapping the range provided to the + * `textDocument/codeAction` request. They are provided so that the server knows which + * errors are currently presented to the user for the given range. There is no guarantee + * that these accurately reflect the error state of the resource. The primary parameter + * to compute code actions is the provided range. + */ + diagnostics: (Diagnostic)[]; + /** + * Requested kind of actions to return. + * + * Actions not of this kind are filtered out by the client before being shown. So servers + * can omit computing them. + */ + only?: (CodeActionKind)[]; + /** + * The reason why code actions were requested. + * + * @since 3.17.0 + */ + triggerKind?: CodeActionTriggerKind; +} + +/** + * Provider options for a {@link CodeActionRequest}. + */ +export interface CodeActionOptions extends WorkDoneProgressOptions { + /** + * CodeActionKinds that this server may return. + * + * The list of kinds may be generic, such as `CodeActionKind.Refactor`, or the server + * may list out every specific kind they provide. + */ + codeActionKinds?: (CodeActionKind)[]; + /** + * The server provides support to resolve additional + * information for a code action. + * + * @since 3.16.0 + */ + resolveProvider?: boolean; +} + +/** + * Server capabilities for a {@link WorkspaceSymbolRequest}. + */ +export interface WorkspaceSymbolOptions extends WorkDoneProgressOptions { + /** + * The server provides support to resolve additional + * information for a workspace symbol. + * + * @since 3.17.0 + */ + resolveProvider?: boolean; +} + +/** + * Code Lens provider options of a {@link CodeLensRequest}. + */ +export interface CodeLensOptions extends WorkDoneProgressOptions { + /** + * Code lens has a resolve provider as well. + */ + resolveProvider?: boolean; +} + +/** + * Provider options for a {@link DocumentLinkRequest}. + */ +export interface DocumentLinkOptions extends WorkDoneProgressOptions { + /** + * Document links have a resolve provider as well. + */ + resolveProvider?: boolean; +} + +/** + * Value-object describing what options formatting should use. + */ +export interface FormattingOptions { + /** + * Size of a tab in spaces. + */ + tabSize: number; + /** + * Prefer spaces over tabs. + */ + insertSpaces: boolean; + /** + * Trim trailing whitespace on a line. + * + * @since 3.15.0 + */ + trimTrailingWhitespace?: boolean; + /** + * Insert a newline character at the end of the file if one does not exist. + * + * @since 3.15.0 + */ + insertFinalNewline?: boolean; + /** + * Trim all newlines after the final newline at the end of the file. + * + * @since 3.15.0 + */ + trimFinalNewlines?: boolean; +} + +/** + * Provider options for a {@link DocumentFormattingRequest}. + */ +export interface DocumentFormattingOptions extends WorkDoneProgressOptions { +} + +/** + * Provider options for a {@link DocumentRangeFormattingRequest}. + */ +export interface DocumentRangeFormattingOptions extends WorkDoneProgressOptions { + /** + * Whether the server supports formatting multiple ranges at once. + * + * @since 3.18.0 + * @proposed + */ + rangesSupport?: boolean; +} + +/** + * Provider options for a {@link DocumentOnTypeFormattingRequest}. + */ +export interface DocumentOnTypeFormattingOptions { + /** + * A character on which formatting should be triggered, like `{`. + */ + firstTriggerCharacter: string; + /** + * More trigger characters. + */ + moreTriggerCharacter?: (string)[]; +} + +/** + * Provider options for a {@link RenameRequest}. + */ +export interface RenameOptions extends WorkDoneProgressOptions { + /** + * Renames should be checked and tested before being executed. + * + * @since version 3.12.0 + */ + prepareProvider?: boolean; +} + +/** + * The server capabilities of a {@link ExecuteCommandRequest}. + */ +export interface ExecuteCommandOptions extends WorkDoneProgressOptions { + /** + * The commands to be executed on the server + */ + commands: (string)[]; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensLegend { + /** + * The token types a server uses. + */ + tokenTypes: (string)[]; + /** + * The token modifiers a server uses. + */ + tokenModifiers: (string)[]; +} + +/** + * A text document identifier to optionally denote a specific version of a text document. + */ +export interface OptionalVersionedTextDocumentIdentifier extends TextDocumentIdentifier { + /** + * The version number of this document. If a versioned text document identifier + * is sent from the server to the client and the file is not open in the editor + * (the server has not received an open notification before) the server can send + * `null` to indicate that the version is unknown and the content on disk is the + * truth (as specified with document content ownership). + */ + version: number | null; +} + +/** + * A special text edit with an additional change annotation. + * + * @since 3.16.0. + */ +export interface AnnotatedTextEdit extends TextEdit { + /** + * The actual identifier of the change annotation + */ + annotationId: ChangeAnnotationIdentifier; +} + +/** + * A generic resource operation. + */ +export interface ResourceOperation { + /** + * The resource operation kind. + */ + kind: string; + /** + * An optional annotation identifier describing the operation. + * + * @since 3.16.0 + */ + annotationId?: ChangeAnnotationIdentifier; +} + +/** + * Options to create a file. + */ +export interface CreateFileOptions { + /** + * Overwrite existing file. Overwrite wins over `ignoreIfExists` + */ + overwrite?: boolean; + /** + * Ignore if exists. + */ + ignoreIfExists?: boolean; +} + +/** + * Rename file options + */ +export interface RenameFileOptions { + /** + * Overwrite target if existing. Overwrite wins over `ignoreIfExists` + */ + overwrite?: boolean; + /** + * Ignores if target exists. + */ + ignoreIfExists?: boolean; +} + +/** + * Delete file options + */ +export interface DeleteFileOptions { + /** + * Delete the content recursively if a folder is denoted. + */ + recursive?: boolean; + /** + * Ignore the operation if the file doesn't exist. + */ + ignoreIfNotExists?: boolean; +} + +/** + * A pattern to describe in which file operation requests or notifications + * the server is interested in receiving. + * + * @since 3.16.0 + */ +export interface FileOperationPattern { + /** + * The glob pattern to match. Glob patterns can have the following syntax: + * - `*` to match zero or more characters in a path segment + * - `?` to match on one character in a path segment + * - `**` to match any number of path segments, including none + * - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}` matches all TypeScript and JavaScript files) + * - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …) + * - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`) + */ + glob: string; + /** + * Whether to match files or folders with this pattern. + * + * Matches both if undefined. + */ + matches?: FileOperationPatternKind; + /** + * Additional options used during matching. + */ + options?: FileOperationPatternOptions; +} + +/** + * A full document diagnostic report for a workspace diagnostic result. + * + * @since 3.17.0 + */ +export interface WorkspaceFullDocumentDiagnosticReport extends FullDocumentDiagnosticReport { + /** + * The URI for which diagnostic information is reported. + */ + uri: string; + /** + * The version number for which the diagnostics are reported. + * If the document is not marked as open `null` can be provided. + */ + version: number | null; +} + +/** + * An unchanged document diagnostic report for a workspace diagnostic result. + * + * @since 3.17.0 + */ +export interface WorkspaceUnchangedDocumentDiagnosticReport extends UnchangedDocumentDiagnosticReport { + /** + * The URI for which diagnostic information is reported. + */ + uri: string; + /** + * The version number for which the diagnostics are reported. + * If the document is not marked as open `null` can be provided. + */ + version: number | null; +} + +/** + * A notebook cell. + * + * A cell's document URI must be unique across ALL notebook + * cells and can therefore be used to uniquely identify a + * notebook cell or the cell's text document. + * + * @since 3.17.0 + */ +export interface NotebookCell { + /** + * The cell's kind + */ + kind: NotebookCellKind; + /** + * The URI of the cell's text document + * content. + */ + document: string; + /** + * Additional metadata stored with the cell. + * + * Note: should always be an object literal (e.g. LSPObject) + */ + metadata?: LSPObject; + /** + * Additional execution summary information + * if supported by the client. + */ + executionSummary?: ExecutionSummary; +} + +/** + * A change describing how to move a `NotebookCell` + * array from state S to S'. + * + * @since 3.17.0 + */ +export interface NotebookCellArrayChange { + /** + * The start oftest of the cell that changed. + */ + start: number; + /** + * The deleted cells + */ + deleteCount: number; + /** + * The new cells, if any + */ + cells?: (NotebookCell)[]; +} + +/** + * Describes the currently selected completion item. + * + * @since 3.18.0 + * @proposed + */ +export interface SelectedCompletionInfo { + /** + * The range that will be replaced if this completion item is accepted. + */ + range: Range; + /** + * The text the range will be replaced with if this completion is accepted. + */ + text: string; +} + +/** + * Defines the capabilities provided by the client. + */ +export interface ClientCapabilities { + /** + * Workspace specific client capabilities. + */ + workspace?: WorkspaceClientCapabilities; + /** + * Text document specific client capabilities. + */ + textDocument?: TextDocumentClientCapabilities; + /** + * Capabilities specific to the notebook document support. + * + * @since 3.17.0 + */ + notebookDocument?: NotebookDocumentClientCapabilities; + /** + * Window specific client capabilities. + */ + window?: WindowClientCapabilities; + /** + * General client capabilities. + * + * @since 3.16.0 + */ + general?: GeneralClientCapabilities; + /** + * Experimental client capabilities. + */ + experimental?: LSPAny; +} + +export interface TextDocumentSyncOptions { + /** + * Open and close notifications are sent to the server. If omitted open close notification should not + * be sent. + */ + openClose?: boolean; + /** + * Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full + * and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None. + */ + change?: TextDocumentSyncKind; + /** + * If present will save notifications are sent to the server. If omitted the notification should not be + * sent. + */ + willSave?: boolean; + /** + * If present will save wait until requests are sent to the server. If omitted the request should not be + * sent. + */ + willSaveWaitUntil?: boolean; + /** + * If present save notifications are sent to the server. If omitted the notification should not be + * sent. + */ + save?: boolean | SaveOptions; +} + +/** + * Options specific to a notebook plus its cells + * to be synced to the server. + * + * If a selector provides a notebook document + * filter but no cell selector all cells of a + * matching notebook document will be synced. + * + * If a selector provides no notebook document + * filter but only a cell selector all notebook + * document that contain at least one matching + * cell will be synced. + * + * @since 3.17.0 + */ +export interface NotebookDocumentSyncOptions { + /** + * The notebooks to be synced + */ + notebookSelector: ({ + notebook: string | NotebookDocumentFilter; + cells?: ({ + language: string + })[] + } | { + notebook?: string | NotebookDocumentFilter; + cells: ({ + language: string + })[] + })[]; + /** + * Whether save notification should be forwarded to + * the server. Will only be honored if mode === `notebook`. + */ + save?: boolean; +} + +/** + * Registration options specific to a notebook. + * + * @since 3.17.0 + */ +export interface NotebookDocumentSyncRegistrationOptions extends NotebookDocumentSyncOptions, StaticRegistrationOptions { +} + +export interface WorkspaceFoldersServerCapabilities { + /** + * The server has support for workspace folders + */ + supported?: boolean; + /** + * Whether the server wants to receive workspace folder + * change notifications. + * + * If a string is provided the string is treated as an ID + * under which the notification is registered on the client + * side. The ID can be used to unregister for these events + * using the `client/unregisterCapability` request. + */ + changeNotifications?: string | boolean; +} + +/** + * Options for notifications/requests for user operations on files. + * + * @since 3.16.0 + */ +export interface FileOperationOptions { + /** + * The server is interested in receiving didCreateFiles notifications. + */ + didCreate?: FileOperationRegistrationOptions; + /** + * The server is interested in receiving willCreateFiles requests. + */ + willCreate?: FileOperationRegistrationOptions; + /** + * The server is interested in receiving didRenameFiles notifications. + */ + didRename?: FileOperationRegistrationOptions; + /** + * The server is interested in receiving willRenameFiles requests. + */ + willRename?: FileOperationRegistrationOptions; + /** + * The server is interested in receiving didDeleteFiles file notifications. + */ + didDelete?: FileOperationRegistrationOptions; + /** + * The server is interested in receiving willDeleteFiles file requests. + */ + willDelete?: FileOperationRegistrationOptions; +} + +/** + * Structure to capture a description for an error code. + * + * @since 3.16.0 + */ +export interface CodeDescription { + /** + * An URI to open with more information about the diagnostic error. + */ + href: string; +} + +/** + * Represents a related message and source code location for a diagnostic. This should be + * used to point to code locations that cause or related to a diagnostics, e.g when duplicating + * a symbol in a scope. + */ +export interface DiagnosticRelatedInformation { + /** + * The location of this related diagnostic information. + */ + location: Location; + /** + * The message of this related diagnostic information. + */ + message: string; +} + +/** + * Represents a parameter of a callable-signature. A parameter can + * have a label and a doc-comment. + */ +export interface ParameterInformation { + /** + * The label of this parameter information. + * + * Either a string or an inclusive start and exclusive end offsets within its containing + * signature label. (see SignatureInformation.label). The offsets are based on a UTF-16 + * string representation as `Position` and `Range` does. + * + * *Note*: a label of type string should be a substring of its containing signature label. + * Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`. + */ + label: string | [number, number]; + /** + * The human-readable doc-comment of this parameter. Will be shown + * in the UI but can be omitted. + */ + documentation?: string | MarkupContent; +} + +/** + * A notebook cell text document filter denotes a cell text + * document by different properties. + * + * @since 3.17.0 + */ +export interface NotebookCellTextDocumentFilter { + /** + * A filter that matches against the notebook + * containing the notebook cell. If a string + * value is provided it matches against the + * notebook type. '*' matches every notebook. + */ + notebook: string | NotebookDocumentFilter; + /** + * A language id like `python`. + * + * Will be matched against the language id of the + * notebook cell document. '*' matches every language. + */ + language?: string; +} + +/** + * Matching options for the file operation pattern. + * + * @since 3.16.0 + */ +export interface FileOperationPatternOptions { + /** + * The pattern should be matched ignoring casing. + */ + ignoreCase?: boolean; +} + +export interface ExecutionSummary { + /** + * A strict monotonically increasing value + * indicating the execution order of a cell + * inside a notebook. + */ + executionOrder: number; + /** + * Whether the execution was successful or + * not if known by the client. + */ + success?: boolean; +} + +/** + * Workspace specific client capabilities. + */ +export interface WorkspaceClientCapabilities { + /** + * The client supports applying batch edits + * to the workspace by supporting the request + * 'workspace/applyEdit' + */ + applyEdit?: boolean; + /** + * Capabilities specific to `WorkspaceEdit`s. + */ + workspaceEdit?: WorkspaceEditClientCapabilities; + /** + * Capabilities specific to the `workspace/didChangeConfiguration` notification. + */ + didChangeConfiguration?: DidChangeConfigurationClientCapabilities; + /** + * Capabilities specific to the `workspace/didChangeWatchedFiles` notification. + */ + didChangeWatchedFiles?: DidChangeWatchedFilesClientCapabilities; + /** + * Capabilities specific to the `workspace/symbol` request. + */ + symbol?: WorkspaceSymbolClientCapabilities; + /** + * Capabilities specific to the `workspace/executeCommand` request. + */ + executeCommand?: ExecuteCommandClientCapabilities; + /** + * The client has support for workspace folders. + * + * @since 3.6.0 + */ + workspaceFolders?: boolean; + /** + * The client supports `workspace/configuration` requests. + * + * @since 3.6.0 + */ + configuration?: boolean; + /** + * Capabilities specific to the semantic token requests scoped to the + * workspace. + * + * @since 3.16.0. + */ + semanticTokens?: SemanticTokensWorkspaceClientCapabilities; + /** + * Capabilities specific to the code lens requests scoped to the + * workspace. + * + * @since 3.16.0. + */ + codeLens?: CodeLensWorkspaceClientCapabilities; + /** + * The client has support for file notifications/requests for user operations on files. + * + * Since 3.16.0 + */ + fileOperations?: FileOperationClientCapabilities; + /** + * Capabilities specific to the inline values requests scoped to the + * workspace. + * + * @since 3.17.0. + */ + inlineValue?: InlineValueWorkspaceClientCapabilities; + /** + * Capabilities specific to the inlay hint requests scoped to the + * workspace. + * + * @since 3.17.0. + */ + inlayHint?: InlayHintWorkspaceClientCapabilities; + /** + * Capabilities specific to the diagnostic requests scoped to the + * workspace. + * + * @since 3.17.0. + */ + diagnostics?: DiagnosticWorkspaceClientCapabilities; + /** + * Capabilities specific to the folding range requests scoped to the workspace. + * + * @since 3.18.0 + * @proposed + */ + foldingRange?: FoldingRangeWorkspaceClientCapabilities; +} + +/** + * Text document specific client capabilities. + */ +export interface TextDocumentClientCapabilities { + /** + * Defines which synchronization capabilities the client supports. + */ + synchronization?: TextDocumentSyncClientCapabilities; + /** + * Capabilities specific to the `textDocument/completion` request. + */ + completion?: CompletionClientCapabilities; + /** + * Capabilities specific to the `textDocument/hover` request. + */ + hover?: HoverClientCapabilities; + /** + * Capabilities specific to the `textDocument/signatureHelp` request. + */ + signatureHelp?: SignatureHelpClientCapabilities; + /** + * Capabilities specific to the `textDocument/declaration` request. + * + * @since 3.14.0 + */ + declaration?: DeclarationClientCapabilities; + /** + * Capabilities specific to the `textDocument/definition` request. + */ + definition?: DefinitionClientCapabilities; + /** + * Capabilities specific to the `textDocument/typeDefinition` request. + * + * @since 3.6.0 + */ + typeDefinition?: TypeDefinitionClientCapabilities; + /** + * Capabilities specific to the `textDocument/implementation` request. + * + * @since 3.6.0 + */ + implementation?: ImplementationClientCapabilities; + /** + * Capabilities specific to the `textDocument/references` request. + */ + references?: ReferenceClientCapabilities; + /** + * Capabilities specific to the `textDocument/documentHighlight` request. + */ + documentHighlight?: DocumentHighlightClientCapabilities; + /** + * Capabilities specific to the `textDocument/documentSymbol` request. + */ + documentSymbol?: DocumentSymbolClientCapabilities; + /** + * Capabilities specific to the `textDocument/codeAction` request. + */ + codeAction?: CodeActionClientCapabilities; + /** + * Capabilities specific to the `textDocument/codeLens` request. + */ + codeLens?: CodeLensClientCapabilities; + /** + * Capabilities specific to the `textDocument/documentLink` request. + */ + documentLink?: DocumentLinkClientCapabilities; + /** + * Capabilities specific to the `textDocument/documentColor` and the + * `textDocument/colorPresentation` request. + * + * @since 3.6.0 + */ + colorProvider?: DocumentColorClientCapabilities; + /** + * Capabilities specific to the `textDocument/formatting` request. + */ + formatting?: DocumentFormattingClientCapabilities; + /** + * Capabilities specific to the `textDocument/rangeFormatting` request. + */ + rangeFormatting?: DocumentRangeFormattingClientCapabilities; + /** + * Capabilities specific to the `textDocument/onTypeFormatting` request. + */ + onTypeFormatting?: DocumentOnTypeFormattingClientCapabilities; + /** + * Capabilities specific to the `textDocument/rename` request. + */ + rename?: RenameClientCapabilities; + /** + * Capabilities specific to the `textDocument/foldingRange` request. + * + * @since 3.10.0 + */ + foldingRange?: FoldingRangeClientCapabilities; + /** + * Capabilities specific to the `textDocument/selectionRange` request. + * + * @since 3.15.0 + */ + selectionRange?: SelectionRangeClientCapabilities; + /** + * Capabilities specific to the `textDocument/publishDiagnostics` notification. + */ + publishDiagnostics?: PublishDiagnosticsClientCapabilities; + /** + * Capabilities specific to the various call hierarchy requests. + * + * @since 3.16.0 + */ + callHierarchy?: CallHierarchyClientCapabilities; + /** + * Capabilities specific to the various semantic token request. + * + * @since 3.16.0 + */ + semanticTokens?: SemanticTokensClientCapabilities; + /** + * Capabilities specific to the `textDocument/linkedEditingRange` request. + * + * @since 3.16.0 + */ + linkedEditingRange?: LinkedEditingRangeClientCapabilities; + /** + * Client capabilities specific to the `textDocument/moniker` request. + * + * @since 3.16.0 + */ + moniker?: MonikerClientCapabilities; + /** + * Capabilities specific to the various type hierarchy requests. + * + * @since 3.17.0 + */ + typeHierarchy?: TypeHierarchyClientCapabilities; + /** + * Capabilities specific to the `textDocument/inlineValue` request. + * + * @since 3.17.0 + */ + inlineValue?: InlineValueClientCapabilities; + /** + * Capabilities specific to the `textDocument/inlayHint` request. + * + * @since 3.17.0 + */ + inlayHint?: InlayHintClientCapabilities; + /** + * Capabilities specific to the diagnostic pull model. + * + * @since 3.17.0 + */ + diagnostic?: DiagnosticClientCapabilities; + /** + * Client capabilities specific to inline completions. + * + * @since 3.18.0 + * @proposed + */ + inlineCompletion?: InlineCompletionClientCapabilities; +} + +/** + * Capabilities specific to the notebook document support. + * + * @since 3.17.0 + */ +export interface NotebookDocumentClientCapabilities { + /** + * Capabilities specific to notebook document synchronization + * + * @since 3.17.0 + */ + synchronization: NotebookDocumentSyncClientCapabilities; +} + +export interface WindowClientCapabilities { + /** + * It indicates whether the client supports server initiated + * progress using the `window/workDoneProgress/create` request. + * + * The capability also controls Whether client supports handling + * of progress notifications. If set servers are allowed to report a + * `workDoneProgress` property in the request specific server + * capabilities. + * + * @since 3.15.0 + */ + workDoneProgress?: boolean; + /** + * Capabilities specific to the showMessage request. + * + * @since 3.16.0 + */ + showMessage?: ShowMessageRequestClientCapabilities; + /** + * Capabilities specific to the showDocument request. + * + * @since 3.16.0 + */ + showDocument?: ShowDocumentClientCapabilities; +} + +/** + * General client capabilities. + * + * @since 3.16.0 + */ +export interface GeneralClientCapabilities { + /** + * Client capability that signals how the client + * handles stale requests (e.g. a request + * for which the client will not process the response + * anymore since the information is outdated). + * + * @since 3.17.0 + */ + staleRequestSupport?: { + cancel: boolean; + retryOnContentModified: (string)[] + }; + /** + * Client capabilities specific to regular expressions. + * + * @since 3.16.0 + */ + regularExpressions?: RegularExpressionsClientCapabilities; + /** + * Client capabilities specific to the client's markdown parser. + * + * @since 3.16.0 + */ + markdown?: MarkdownClientCapabilities; + /** + * The position encodings supported by the client. Client and server + * have to agree on the same position encoding to ensure that offsets + * (e.g. character position in a line) are interpreted the same on both + * sides. + * + * To keep the protocol backwards compatible the following applies: if + * the value 'utf-16' is missing from the array of position encodings + * servers can assume that the client supports UTF-16. UTF-16 is + * therefore a mandatory encoding. + * + * If omitted it defaults to ['utf-16']. + * + * Implementation considerations: since the conversion from one encoding + * into another requires the content of the file / line the conversion + * is best done where the file is read which is usually on the server + * side. + * + * @since 3.17.0 + */ + positionEncodings?: (PositionEncodingKind)[]; +} + +/** + * A relative pattern is a helper to construct glob patterns that are matched + * relatively to a base URI. The common value for a `baseUri` is a workspace + * folder root, but it can be another absolute URI as well. + * + * @since 3.17.0 + */ +export interface RelativePattern { + /** + * A workspace folder or a base URI to which this pattern will be matched + * against relatively. + */ + baseUri: WorkspaceFolder | string; + /** + * The actual glob pattern; + */ + pattern: Pattern; +} + +export interface WorkspaceEditClientCapabilities { + /** + * The client supports versioned document changes in `WorkspaceEdit`s + */ + documentChanges?: boolean; + /** + * The resource operations the client supports. Clients should at least + * support 'create', 'rename' and 'delete' files and folders. + * + * @since 3.13.0 + */ + resourceOperations?: (ResourceOperationKind)[]; + /** + * The failure handling strategy of a client if applying the workspace edit + * fails. + * + * @since 3.13.0 + */ + failureHandling?: FailureHandlingKind; + /** + * Whether the client normalizes line endings to the client specific + * setting. + * If set to `true` the client will normalize line ending characters + * in a workspace edit to the client-specified new line + * character. + * + * @since 3.16.0 + */ + normalizesLineEndings?: boolean; + /** + * Whether the client in general supports change annotations on text edits, + * create file, rename file and delete file changes. + * + * @since 3.16.0 + */ + changeAnnotationSupport?: { + groupsOnLabel?: boolean + }; +} + +export interface DidChangeConfigurationClientCapabilities { + /** + * Did change configuration notification supports dynamic registration. + */ + dynamicRegistration?: boolean; +} + +export interface DidChangeWatchedFilesClientCapabilities { + /** + * Did change watched files notification supports dynamic registration. Please note + * that the current protocol doesn't support static configuration for file changes + * from the server side. + */ + dynamicRegistration?: boolean; + /** + * Whether the client has support for {@link RelativePattern relative pattern} + * or not. + * + * @since 3.17.0 + */ + relativePatternSupport?: boolean; +} + +/** + * Client capabilities for a {@link WorkspaceSymbolRequest}. + */ +export interface WorkspaceSymbolClientCapabilities { + /** + * Symbol request supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * Specific capabilities for the `SymbolKind` in the `workspace/symbol` request. + */ + symbolKind?: { + valueSet?: (SymbolKind)[] + }; + /** + * The client supports tags on `SymbolInformation`. + * Clients supporting tags have to handle unknown tags gracefully. + * + * @since 3.16.0 + */ + tagSupport?: { + valueSet: (SymbolTag)[] + }; + /** + * The client support partial workspace symbols. The client will send the + * request `workspaceSymbol/resolve` to the server to resolve additional + * properties. + * + * @since 3.17.0 + */ + resolveSupport?: { + properties: (string)[] + }; +} + +/** + * The client capabilities of a {@link ExecuteCommandRequest}. + */ +export interface ExecuteCommandClientCapabilities { + /** + * Execute command supports dynamic registration. + */ + dynamicRegistration?: boolean; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensWorkspaceClientCapabilities { + /** + * Whether the client implementation supports a refresh request sent from + * the server to the client. + * + * Note that this event is global and will force the client to refresh all + * semantic tokens currently shown. It should be used with absolute care + * and is useful for situation where a server for example detects a project + * wide change that requires such a calculation. + */ + refreshSupport?: boolean; +} + +/** + * @since 3.16.0 + */ +export interface CodeLensWorkspaceClientCapabilities { + /** + * Whether the client implementation supports a refresh request sent from the + * server to the client. + * + * Note that this event is global and will force the client to refresh all + * code lenses currently shown. It should be used with absolute care and is + * useful for situation where a server for example detect a project wide + * change that requires such a calculation. + */ + refreshSupport?: boolean; +} + +/** + * Capabilities relating to events from file operations by the user in the client. + * + * These events do not come from the file system, they come from user operations + * like renaming a file in the UI. + * + * @since 3.16.0 + */ +export interface FileOperationClientCapabilities { + /** + * Whether the client supports dynamic registration for file requests/notifications. + */ + dynamicRegistration?: boolean; + /** + * The client has support for sending didCreateFiles notifications. + */ + didCreate?: boolean; + /** + * The client has support for sending willCreateFiles requests. + */ + willCreate?: boolean; + /** + * The client has support for sending didRenameFiles notifications. + */ + didRename?: boolean; + /** + * The client has support for sending willRenameFiles requests. + */ + willRename?: boolean; + /** + * The client has support for sending didDeleteFiles notifications. + */ + didDelete?: boolean; + /** + * The client has support for sending willDeleteFiles requests. + */ + willDelete?: boolean; +} + +/** + * Client workspace capabilities specific to inline values. + * + * @since 3.17.0 + */ +export interface InlineValueWorkspaceClientCapabilities { + /** + * Whether the client implementation supports a refresh request sent from the + * server to the client. + * + * Note that this event is global and will force the client to refresh all + * inline values currently shown. It should be used with absolute care and is + * useful for situation where a server for example detects a project wide + * change that requires such a calculation. + */ + refreshSupport?: boolean; +} + +/** + * Client workspace capabilities specific to inlay hints. + * + * @since 3.17.0 + */ +export interface InlayHintWorkspaceClientCapabilities { + /** + * Whether the client implementation supports a refresh request sent from + * the server to the client. + * + * Note that this event is global and will force the client to refresh all + * inlay hints currently shown. It should be used with absolute care and + * is useful for situation where a server for example detects a project wide + * change that requires such a calculation. + */ + refreshSupport?: boolean; +} + +/** + * Workspace client capabilities specific to diagnostic pull requests. + * + * @since 3.17.0 + */ +export interface DiagnosticWorkspaceClientCapabilities { + /** + * Whether the client implementation supports a refresh request sent from + * the server to the client. + * + * Note that this event is global and will force the client to refresh all + * pulled diagnostics currently shown. It should be used with absolute care and + * is useful for situation where a server for example detects a project wide + * change that requires such a calculation. + */ + refreshSupport?: boolean; +} + +/** + * Client workspace capabilities specific to folding ranges + * + * @since 3.18.0 + * @proposed + */ +export interface FoldingRangeWorkspaceClientCapabilities { + /** + * Whether the client implementation supports a refresh request sent from the + * server to the client. + * + * Note that this event is global and will force the client to refresh all + * folding ranges currently shown. It should be used with absolute care and is + * useful for situation where a server for example detects a project wide + * change that requires such a calculation. + * + * @since 3.18.0 + * @proposed + */ + refreshSupport?: boolean; +} + +export interface TextDocumentSyncClientCapabilities { + /** + * Whether text document synchronization supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * The client supports sending will save notifications. + */ + willSave?: boolean; + /** + * The client supports sending a will save request and + * waits for a response providing text edits which will + * be applied to the document before it is saved. + */ + willSaveWaitUntil?: boolean; + /** + * The client supports did save notifications. + */ + didSave?: boolean; +} + +/** + * Completion client capabilities + */ +export interface CompletionClientCapabilities { + /** + * Whether completion supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * The client supports the following `CompletionItem` specific + * capabilities. + */ + completionItem?: { + snippetSupport?: boolean; + commitCharactersSupport?: boolean; + documentationFormat?: (MarkupKind)[]; + deprecatedSupport?: boolean; + preselectSupport?: boolean; + tagSupport?: { + valueSet: (CompletionItemTag)[] + }; + insertReplaceSupport?: boolean; + resolveSupport?: { + properties: (string)[] + }; + insertTextModeSupport?: { + valueSet: (InsertTextMode)[] + }; + labelDetailsSupport?: boolean + }; + completionItemKind?: { + valueSet?: (CompletionItemKind)[] + }; + /** + * Defines how the client handles whitespace and indentation + * when accepting a completion item that uses multi line + * text in either `insertText` or `textEdit`. + * + * @since 3.17.0 + */ + insertTextMode?: InsertTextMode; + /** + * The client supports to send additional context information for a + * `textDocument/completion` request. + */ + contextSupport?: boolean; + /** + * The client supports the following `CompletionList` specific + * capabilities. + * + * @since 3.17.0 + */ + completionList?: { + itemDefaults?: (string)[] + }; +} + +export interface HoverClientCapabilities { + /** + * Whether hover supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * Client supports the following content formats for the content + * property. The order describes the preferred format of the client. + */ + contentFormat?: (MarkupKind)[]; +} + +/** + * Client Capabilities for a {@link SignatureHelpRequest}. + */ +export interface SignatureHelpClientCapabilities { + /** + * Whether signature help supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * The client supports the following `SignatureInformation` + * specific properties. + */ + signatureInformation?: { + documentationFormat?: (MarkupKind)[]; + parameterInformation?: { + labelOffsetSupport?: boolean + }; + activeParameterSupport?: boolean + }; + /** + * The client supports to send additional context information for a + * `textDocument/signatureHelp` request. A client that opts into + * contextSupport will also support the `retriggerCharacters` on + * `SignatureHelpOptions`. + * + * @since 3.15.0 + */ + contextSupport?: boolean; +} + +/** + * @since 3.14.0 + */ +export interface DeclarationClientCapabilities { + /** + * Whether declaration supports dynamic registration. If this is set to `true` + * the client supports the new `DeclarationRegistrationOptions` return value + * for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; + /** + * The client supports additional metadata in the form of declaration links. + */ + linkSupport?: boolean; +} + +/** + * Client Capabilities for a {@link DefinitionRequest}. + */ +export interface DefinitionClientCapabilities { + /** + * Whether definition supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * The client supports additional metadata in the form of definition links. + * + * @since 3.14.0 + */ + linkSupport?: boolean; +} + +/** + * Since 3.6.0 + */ +export interface TypeDefinitionClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `TypeDefinitionRegistrationOptions` return value + * for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; + /** + * The client supports additional metadata in the form of definition links. + * + * Since 3.14.0 + */ + linkSupport?: boolean; +} + +/** + * @since 3.6.0 + */ +export interface ImplementationClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `ImplementationRegistrationOptions` return value + * for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; + /** + * The client supports additional metadata in the form of definition links. + * + * @since 3.14.0 + */ + linkSupport?: boolean; +} + +/** + * Client Capabilities for a {@link ReferencesRequest}. + */ +export interface ReferenceClientCapabilities { + /** + * Whether references supports dynamic registration. + */ + dynamicRegistration?: boolean; +} + +/** + * Client Capabilities for a {@link DocumentHighlightRequest}. + */ +export interface DocumentHighlightClientCapabilities { + /** + * Whether document highlight supports dynamic registration. + */ + dynamicRegistration?: boolean; +} + +/** + * Client Capabilities for a {@link DocumentSymbolRequest}. + */ +export interface DocumentSymbolClientCapabilities { + /** + * Whether document symbol supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * Specific capabilities for the `SymbolKind` in the + * `textDocument/documentSymbol` request. + */ + symbolKind?: { + valueSet?: (SymbolKind)[] + }; + /** + * The client supports hierarchical document symbols. + */ + hierarchicalDocumentSymbolSupport?: boolean; + /** + * The client supports tags on `SymbolInformation`. Tags are supported on + * `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true. + * Clients supporting tags have to handle unknown tags gracefully. + * + * @since 3.16.0 + */ + tagSupport?: { + valueSet: (SymbolTag)[] + }; + /** + * The client supports an additional label presented in the UI when + * registering a document symbol provider. + * + * @since 3.16.0 + */ + labelSupport?: boolean; +} + +/** + * The Client Capabilities of a {@link CodeActionRequest}. + */ +export interface CodeActionClientCapabilities { + /** + * Whether code action supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * The client support code action literals of type `CodeAction` as a valid + * response of the `textDocument/codeAction` request. If the property is not + * set the request can only return `Command` literals. + * + * @since 3.8.0 + */ + codeActionLiteralSupport?: { + codeActionKind: { + valueSet: (CodeActionKind)[] + } + }; + /** + * Whether code action supports the `isPreferred` property. + * + * @since 3.15.0 + */ + isPreferredSupport?: boolean; + /** + * Whether code action supports the `disabled` property. + * + * @since 3.16.0 + */ + disabledSupport?: boolean; + /** + * Whether code action supports the `data` property which is + * preserved between a `textDocument/codeAction` and a + * `codeAction/resolve` request. + * + * @since 3.16.0 + */ + dataSupport?: boolean; + /** + * Whether the client supports resolving additional code action + * properties via a separate `codeAction/resolve` request. + * + * @since 3.16.0 + */ + resolveSupport?: { + properties: (string)[] + }; + /** + * Whether the client honors the change annotations in + * text edits and resource operations returned via the + * `CodeAction#edit` property by for example presenting + * the workspace edit in the user interface and asking + * for confirmation. + * + * @since 3.16.0 + */ + honorsChangeAnnotations?: boolean; +} + +/** + * The client capabilities of a {@link CodeLensRequest}. + */ +export interface CodeLensClientCapabilities { + /** + * Whether code lens supports dynamic registration. + */ + dynamicRegistration?: boolean; +} + +/** + * The client capabilities of a {@link DocumentLinkRequest}. + */ +export interface DocumentLinkClientCapabilities { + /** + * Whether document link supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * Whether the client supports the `tooltip` property on `DocumentLink`. + * + * @since 3.15.0 + */ + tooltipSupport?: boolean; +} + +export interface DocumentColorClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `DocumentColorRegistrationOptions` return value + * for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; +} + +/** + * Client capabilities of a {@link DocumentFormattingRequest}. + */ +export interface DocumentFormattingClientCapabilities { + /** + * Whether formatting supports dynamic registration. + */ + dynamicRegistration?: boolean; +} + +/** + * Client capabilities of a {@link DocumentRangeFormattingRequest}. + */ +export interface DocumentRangeFormattingClientCapabilities { + /** + * Whether range formatting supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * Whether the client supports formatting multiple ranges at once. + * + * @since 3.18.0 + * @proposed + */ + rangesSupport?: boolean; +} + +/** + * Client capabilities of a {@link DocumentOnTypeFormattingRequest}. + */ +export interface DocumentOnTypeFormattingClientCapabilities { + /** + * Whether on type formatting supports dynamic registration. + */ + dynamicRegistration?: boolean; +} + +export interface RenameClientCapabilities { + /** + * Whether rename supports dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * Client supports testing for validity of rename operations + * before execution. + * + * @since 3.12.0 + */ + prepareSupport?: boolean; + /** + * Client supports the default behavior result. + * + * The value indicates the default behavior used by the + * client. + * + * @since 3.16.0 + */ + prepareSupportDefaultBehavior?: PrepareSupportDefaultBehavior; + /** + * Whether the client honors the change annotations in + * text edits and resource operations returned via the + * rename request's workspace edit by for example presenting + * the workspace edit in the user interface and asking + * for confirmation. + * + * @since 3.16.0 + */ + honorsChangeAnnotations?: boolean; +} + +export interface FoldingRangeClientCapabilities { + /** + * Whether implementation supports dynamic registration for folding range + * providers. If this is set to `true` the client supports the new + * `FoldingRangeRegistrationOptions` return value for the corresponding + * server capability as well. + */ + dynamicRegistration?: boolean; + /** + * The maximum number of folding ranges that the client prefers to receive + * per document. The value serves as a hint, servers are free to follow the + * limit. + */ + rangeLimit?: number; + /** + * If set, the client signals that it only supports folding complete lines. + * If set, client will ignore specified `startCharacter` and `endCharacter` + * properties in a FoldingRange. + */ + lineFoldingOnly?: boolean; + /** + * Specific options for the folding range kind. + * + * @since 3.17.0 + */ + foldingRangeKind?: { + valueSet?: (FoldingRangeKind)[] + }; + /** + * Specific options for the folding range. + * + * @since 3.17.0 + */ + foldingRange?: { + collapsedText?: boolean + }; +} + +export interface SelectionRangeClientCapabilities { + /** + * Whether implementation supports dynamic registration for selection range providers. If this is set to `true` + * the client supports the new `SelectionRangeRegistrationOptions` return value for the corresponding server + * capability as well. + */ + dynamicRegistration?: boolean; +} + +/** + * The publish diagnostic client capabilities. + */ +export interface PublishDiagnosticsClientCapabilities { + /** + * Whether the clients accepts diagnostics with related information. + */ + relatedInformation?: boolean; + /** + * Client supports the tag property to provide meta data about a diagnostic. + * Clients supporting tags have to handle unknown tags gracefully. + * + * @since 3.15.0 + */ + tagSupport?: { + valueSet: (DiagnosticTag)[] + }; + /** + * Whether the client interprets the version property of the + * `textDocument/publishDiagnostics` notification's parameter. + * + * @since 3.15.0 + */ + versionSupport?: boolean; + /** + * Client supports a codeDescription property + * + * @since 3.16.0 + */ + codeDescriptionSupport?: boolean; + /** + * Whether code action supports the `data` property which is + * preserved between a `textDocument/publishDiagnostics` and + * `textDocument/codeAction` request. + * + * @since 3.16.0 + */ + dataSupport?: boolean; +} + +/** + * @since 3.16.0 + */ +export interface CallHierarchyClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + * return value for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; +} + +/** + * @since 3.16.0 + */ +export interface SemanticTokensClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + * return value for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; + /** + * Which requests the client supports and might send to the server + * depending on the server's capability. Please note that clients might not + * show semantic tokens or degrade some of the user experience if a range + * or full request is advertised by the client but not provided by the + * server. If for example the client capability `requests.full` and + * `request.range` are both set to true but the server only provides a + * range provider the client might not render a minimap correctly or might + * even decide to not show any semantic tokens at all. + */ + requests: { + range?: boolean | { + + }; + full?: boolean | { + delta?: boolean + } + }; + /** + * The token types that the client supports. + */ + tokenTypes: (string)[]; + /** + * The token modifiers that the client supports. + */ + tokenModifiers: (string)[]; + /** + * The token formats the clients supports. + */ + formats: (TokenFormat)[]; + /** + * Whether the client supports tokens that can overlap each other. + */ + overlappingTokenSupport?: boolean; + /** + * Whether the client supports tokens that can span multiple lines. + */ + multilineTokenSupport?: boolean; + /** + * Whether the client allows the server to actively cancel a + * semantic token request, e.g. supports returning + * LSPErrorCodes.ServerCancelled. If a server does the client + * needs to retrigger the request. + * + * @since 3.17.0 + */ + serverCancelSupport?: boolean; + /** + * Whether the client uses semantic tokens to augment existing + * syntax tokens. If set to `true` client side created syntax + * tokens and semantic tokens are both used for colorization. If + * set to `false` the client only uses the returned semantic tokens + * for colorization. + * + * If the value is `undefined` then the client behavior is not + * specified. + * + * @since 3.17.0 + */ + augmentsSyntaxTokens?: boolean; +} + +/** + * Client capabilities for the linked editing range request. + * + * @since 3.16.0 + */ +export interface LinkedEditingRangeClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + * return value for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; +} + +/** + * Client capabilities specific to the moniker request. + * + * @since 3.16.0 + */ +export interface MonikerClientCapabilities { + /** + * Whether moniker supports dynamic registration. If this is set to `true` + * the client supports the new `MonikerRegistrationOptions` return value + * for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; +} + +/** + * @since 3.17.0 + */ +export interface TypeHierarchyClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + * return value for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; +} + +/** + * Client capabilities specific to inline values. + * + * @since 3.17.0 + */ +export interface InlineValueClientCapabilities { + /** + * Whether implementation supports dynamic registration for inline value providers. + */ + dynamicRegistration?: boolean; +} + +/** + * Inlay hint client capabilities. + * + * @since 3.17.0 + */ +export interface InlayHintClientCapabilities { + /** + * Whether inlay hints support dynamic registration. + */ + dynamicRegistration?: boolean; + /** + * Indicates which properties a client can resolve lazily on an inlay + * hint. + */ + resolveSupport?: { + properties: (string)[] + }; +} + +/** + * Client capabilities specific to diagnostic pull requests. + * + * @since 3.17.0 + */ +export interface DiagnosticClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is set to `true` + * the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + * return value for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; + /** + * Whether the clients supports related documents for document diagnostic pulls. + */ + relatedDocumentSupport?: boolean; +} + +/** + * Client capabilities specific to inline completions. + * + * @since 3.18.0 + * @proposed + */ +export interface InlineCompletionClientCapabilities { + /** + * Whether implementation supports dynamic registration for inline completion providers. + */ + dynamicRegistration?: boolean; +} + +/** + * Notebook specific client capabilities. + * + * @since 3.17.0 + */ +export interface NotebookDocumentSyncClientCapabilities { + /** + * Whether implementation supports dynamic registration. If this is + * set to `true` the client supports the new + * `(TextDocumentRegistrationOptions & StaticRegistrationOptions)` + * return value for the corresponding server capability as well. + */ + dynamicRegistration?: boolean; + /** + * The client supports sending execution summary data per cell. + */ + executionSummarySupport?: boolean; +} + +/** + * Show message request client capabilities + */ +export interface ShowMessageRequestClientCapabilities { + /** + * Capabilities specific to the `MessageActionItem` type. + */ + messageActionItem?: { + additionalPropertiesSupport?: boolean + }; +} + +/** + * Client capabilities for the showDocument request. + * + * @since 3.16.0 + */ +export interface ShowDocumentClientCapabilities { + /** + * The client has support for the showDocument + * request. + */ + support: boolean; +} + +/** + * Client capabilities specific to regular expressions. + * + * @since 3.16.0 + */ +export interface RegularExpressionsClientCapabilities { + /** + * The engine's name. + */ + engine: string; + /** + * The engine's version. + */ + version?: string; +} + +/** + * Client capabilities specific to the used markdown parser. + * + * @since 3.16.0 + */ +export interface MarkdownClientCapabilities { + /** + * The name of the parser. + */ + parser: string; + /** + * The version of the parser. + */ + version?: string; + /** + * A list of HTML tags that the client allows / supports in + * Markdown. + * + * @since 3.17.0 + */ + allowedTags?: (string)[]; +} + +/** + * Represents a capability with its associated method and registration options type + */ +export class Capability { + constructor(public readonly method: string) { } +} + +/** + * Map of all LSP capabilities with their registration options + */ +export const capabilities = { + textDocumentImplementation: new Capability('textDocument/implementation'), + textDocumentTypeDefinition: new Capability('textDocument/typeDefinition'), + textDocumentDocumentColor: new Capability('textDocument/documentColor'), + textDocumentColorPresentation: new Capability('textDocument/colorPresentation'), + textDocumentFoldingRange: new Capability('textDocument/foldingRange'), + textDocumentDeclaration: new Capability('textDocument/declaration'), + textDocumentSelectionRange: new Capability('textDocument/selectionRange'), + textDocumentPrepareCallHierarchy: new Capability('textDocument/prepareCallHierarchy'), + textDocumentSemanticTokensFull: new Capability('textDocument/semanticTokens/full'), + textDocumentSemanticTokensFullDelta: new Capability('textDocument/semanticTokens/full/delta'), + textDocumentLinkedEditingRange: new Capability('textDocument/linkedEditingRange'), + workspaceWillCreateFiles: new Capability('workspace/willCreateFiles'), + workspaceWillRenameFiles: new Capability('workspace/willRenameFiles'), + workspaceWillDeleteFiles: new Capability('workspace/willDeleteFiles'), + textDocumentMoniker: new Capability('textDocument/moniker'), + textDocumentPrepareTypeHierarchy: new Capability('textDocument/prepareTypeHierarchy'), + textDocumentInlineValue: new Capability('textDocument/inlineValue'), + textDocumentInlayHint: new Capability('textDocument/inlayHint'), + textDocumentDiagnostic: new Capability('textDocument/diagnostic'), + textDocumentInlineCompletion: new Capability('textDocument/inlineCompletion'), + textDocumentWillSaveWaitUntil: new Capability('textDocument/willSaveWaitUntil'), + textDocumentCompletion: new Capability('textDocument/completion'), + textDocumentHover: new Capability('textDocument/hover'), + textDocumentSignatureHelp: new Capability('textDocument/signatureHelp'), + textDocumentDefinition: new Capability('textDocument/definition'), + textDocumentReferences: new Capability('textDocument/references'), + textDocumentDocumentHighlight: new Capability('textDocument/documentHighlight'), + textDocumentDocumentSymbol: new Capability('textDocument/documentSymbol'), + textDocumentCodeAction: new Capability('textDocument/codeAction'), + workspaceSymbol: new Capability('workspace/symbol'), + textDocumentCodeLens: new Capability('textDocument/codeLens'), + textDocumentDocumentLink: new Capability('textDocument/documentLink'), + textDocumentFormatting: new Capability('textDocument/formatting'), + textDocumentRangeFormatting: new Capability('textDocument/rangeFormatting'), + textDocumentRangesFormatting: new Capability('textDocument/rangesFormatting'), + textDocumentOnTypeFormatting: new Capability('textDocument/onTypeFormatting'), + textDocumentRename: new Capability('textDocument/rename'), + workspaceExecuteCommand: new Capability('workspace/executeCommand'), + workspaceDidCreateFiles: new Capability('workspace/didCreateFiles'), + workspaceDidRenameFiles: new Capability('workspace/didRenameFiles'), + workspaceDidDeleteFiles: new Capability('workspace/didDeleteFiles'), + workspaceDidChangeConfiguration: new Capability('workspace/didChangeConfiguration'), + textDocumentDidOpen: new Capability('textDocument/didOpen'), + textDocumentDidChange: new Capability('textDocument/didChange'), + textDocumentDidClose: new Capability('textDocument/didClose'), + textDocumentDidSave: new Capability('textDocument/didSave'), + textDocumentWillSave: new Capability('textDocument/willSave'), + workspaceDidChangeWatchedFiles: new Capability('workspace/didChangeWatchedFiles'), +}; + +/** + * LSP API Contract + */ +export const api = contract({ + name: "LSP", + server: { + /** + * A request to resolve the implementation locations of a symbol at a given text + * document position. The request's parameter is of type {@link TextDocumentPositionParams} + * the response is of type {@link Definition} or a Thenable that resolves to such. + */ + textDocumentImplementation: unverifiedRequest({ method: "textDocument/implementation" }), + /** + * A request to resolve the type definition locations of a symbol at a given text + * document position. The request's parameter is of type {@link TextDocumentPositionParams} + * the response is of type {@link Definition} or a Thenable that resolves to such. + */ + textDocumentTypeDefinition: unverifiedRequest({ method: "textDocument/typeDefinition" }), + /** + * A request to list all color symbols found in a given text document. The request's + * parameter is of type {@link DocumentColorParams} the + * response is of type {@link ColorInformation ColorInformation[]} or a Thenable + * that resolves to such. + */ + textDocumentDocumentColor: unverifiedRequest({ method: "textDocument/documentColor" }), + /** + * A request to list all presentation for a color. The request's + * parameter is of type {@link ColorPresentationParams} the + * response is of type {@link ColorInformation ColorInformation[]} or a Thenable + * that resolves to such. + */ + textDocumentColorPresentation: unverifiedRequest({ method: "textDocument/colorPresentation" }), + /** + * A request to provide folding ranges in a document. The request's + * parameter is of type {@link FoldingRangeParams}, the + * response is of type {@link FoldingRangeList} or a Thenable + * that resolves to such. + */ + textDocumentFoldingRange: unverifiedRequest({ method: "textDocument/foldingRange" }), + /** + * A request to resolve the type definition locations of a symbol at a given text + * document position. The request's parameter is of type {@link TextDocumentPositionParams} + * the response is of type {@link Declaration} or a typed array of {@link DeclarationLink} + * or a Thenable that resolves to such. + */ + textDocumentDeclaration: unverifiedRequest({ method: "textDocument/declaration" }), + /** + * A request to provide selection ranges in a document. The request's + * parameter is of type {@link SelectionRangeParams}, the + * response is of type {@link SelectionRange SelectionRange[]} or a Thenable + * that resolves to such. + */ + textDocumentSelectionRange: unverifiedRequest({ method: "textDocument/selectionRange" }), + /** + * A request to result a `CallHierarchyItem` in a document at a given position. + * Can be used as an input to an incoming or outgoing call hierarchy. + * + * @since 3.16.0 + */ + textDocumentPrepareCallHierarchy: unverifiedRequest({ method: "textDocument/prepareCallHierarchy" }), + /** + * A request to resolve the incoming calls for a given `CallHierarchyItem`. + * + * @since 3.16.0 + */ + callHierarchyIncomingCalls: unverifiedRequest({ method: "callHierarchy/incomingCalls" }), + /** + * A request to resolve the outgoing calls for a given `CallHierarchyItem`. + * + * @since 3.16.0 + */ + callHierarchyOutgoingCalls: unverifiedRequest({ method: "callHierarchy/outgoingCalls" }), + /** + * @since 3.16.0 + */ + textDocumentSemanticTokensFull: unverifiedRequest({ method: "textDocument/semanticTokens/full" }), + /** + * @since 3.16.0 + */ + textDocumentSemanticTokensFullDelta: unverifiedRequest({ method: "textDocument/semanticTokens/full/delta" }), + /** + * @since 3.16.0 + */ + textDocumentSemanticTokensRange: unverifiedRequest({ method: "textDocument/semanticTokens/range" }), + /** + * A request to provide ranges that can be edited together. + * + * @since 3.16.0 + */ + textDocumentLinkedEditingRange: unverifiedRequest({ method: "textDocument/linkedEditingRange" }), + /** + * The will create files request is sent from the client to the server before files are actually + * created as long as the creation is triggered from within the client. + * + * The request can return a `WorkspaceEdit` which will be applied to workspace before the + * files are created. Hence the `WorkspaceEdit` can not manipulate the content of the file + * to be created. + * + * @since 3.16.0 + */ + workspaceWillCreateFiles: unverifiedRequest({ method: "workspace/willCreateFiles" }), + /** + * The will rename files request is sent from the client to the server before files are actually + * renamed as long as the rename is triggered from within the client. + * + * @since 3.16.0 + */ + workspaceWillRenameFiles: unverifiedRequest({ method: "workspace/willRenameFiles" }), + /** + * The did delete files notification is sent from the client to the server when + * files were deleted from within the client. + * + * @since 3.16.0 + */ + workspaceWillDeleteFiles: unverifiedRequest({ method: "workspace/willDeleteFiles" }), + /** + * A request to get the moniker of a symbol at a given text document position. + * The request parameter is of type {@link TextDocumentPositionParams}. + * The response is of type {@link Moniker Moniker[]} or `null`. + */ + textDocumentMoniker: unverifiedRequest({ method: "textDocument/moniker" }), + /** + * A request to result a `TypeHierarchyItem` in a document at a given position. + * Can be used as an input to a subtypes or supertypes type hierarchy. + * + * @since 3.17.0 + */ + textDocumentPrepareTypeHierarchy: unverifiedRequest({ method: "textDocument/prepareTypeHierarchy" }), + /** + * A request to resolve the supertypes for a given `TypeHierarchyItem`. + * + * @since 3.17.0 + */ + typeHierarchySupertypes: unverifiedRequest({ method: "typeHierarchy/supertypes" }), + /** + * A request to resolve the subtypes for a given `TypeHierarchyItem`. + * + * @since 3.17.0 + */ + typeHierarchySubtypes: unverifiedRequest({ method: "typeHierarchy/subtypes" }), + /** + * A request to provide inline values in a document. The request's parameter is of + * type {@link InlineValueParams}, the response is of type + * {@link InlineValue InlineValue[]} or a Thenable that resolves to such. + * + * @since 3.17.0 + */ + textDocumentInlineValue: unverifiedRequest({ method: "textDocument/inlineValue" }), + /** + * A request to provide inlay hints in a document. The request's parameter is of + * type {@link InlayHintsParams}, the response is of type + * {@link InlayHint InlayHint[]} or a Thenable that resolves to such. + * + * @since 3.17.0 + */ + textDocumentInlayHint: unverifiedRequest({ method: "textDocument/inlayHint" }), + /** + * A request to resolve additional properties for an inlay hint. + * The request's parameter is of type {@link InlayHint}, the response is + * of type {@link InlayHint} or a Thenable that resolves to such. + * + * @since 3.17.0 + */ + inlayHintResolve: unverifiedRequest({ method: "inlayHint/resolve" }), + /** + * The document diagnostic request definition. + * + * @since 3.17.0 + */ + textDocumentDiagnostic: unverifiedRequest({ method: "textDocument/diagnostic" }), + /** + * The workspace diagnostic request definition. + * + * @since 3.17.0 + */ + workspaceDiagnostic: unverifiedRequest({ method: "workspace/diagnostic" }), + /** + * A request to provide inline completions in a document. The request's parameter is of + * type {@link InlineCompletionParams}, the response is of type + * {@link InlineCompletion InlineCompletion[]} or a Thenable that resolves to such. + * + * @since 3.18.0 + * @proposed + */ + textDocumentInlineCompletion: unverifiedRequest({ method: "textDocument/inlineCompletion" }), + /** + * The initialize request is sent from the client to the server. + * It is sent once as the request after starting up the server. + * The requests parameter is of type {@link InitializeParams} + * the response if of type {@link InitializeResult} of a Thenable that + * resolves to such. + */ + initialize: unverifiedRequest({ method: "initialize" }), + /** + * A shutdown request is sent from the client to the server. + * It is sent once when the client decides to shutdown the + * server. The only notification that is sent after a shutdown request + * is the exit event. + */ + shutdown: unverifiedRequest({ method: "shutdown" }), + /** + * A document will save request is sent from the client to the server before + * the document is actually saved. The request can return an array of TextEdits + * which will be applied to the text document before it is saved. Please note that + * clients might drop results if computing the text edits took too long or if a + * server constantly fails on this request. This is done to keep the save fast and + * reliable. + */ + textDocumentWillSaveWaitUntil: unverifiedRequest({ method: "textDocument/willSaveWaitUntil" }), + /** + * Request to request completion at a given text document position. The request's + * parameter is of type {@link TextDocumentPosition} the response + * is of type {@link CompletionItem CompletionItem[]} or {@link CompletionList} + * or a Thenable that resolves to such. + * + * The request can delay the computation of the {@link CompletionItem.detail `detail`} + * and {@link CompletionItem.documentation `documentation`} properties to the `completionItem/resolve` + * request. However, properties that are needed for the initial sorting and filtering, like `sortText`, + * `filterText`, `insertText`, and `textEdit`, must not be changed during resolve. + */ + textDocumentCompletion: unverifiedRequest({ method: "textDocument/completion" }), + /** + * Request to resolve additional information for a given completion item.The request's + * parameter is of type {@link CompletionItem} the response + * is of type {@link CompletionItem} or a Thenable that resolves to such. + */ + completionItemResolve: unverifiedRequest({ method: "completionItem/resolve" }), + /** + * Request to request hover information at a given text document position. The request's + * parameter is of type {@link TextDocumentPosition} the response is of + * type {@link Hover} or a Thenable that resolves to such. + */ + textDocumentHover: unverifiedRequest({ method: "textDocument/hover" }), + textDocumentSignatureHelp: unverifiedRequest({ method: "textDocument/signatureHelp" }), + /** + * A request to resolve the definition location of a symbol at a given text + * document position. The request's parameter is of type {@link TextDocumentPosition} + * the response is of either type {@link Definition} or a typed array of + * {@link DefinitionLink} or a Thenable that resolves to such. + */ + textDocumentDefinition: unverifiedRequest({ method: "textDocument/definition" }), + /** + * A request to resolve project-wide references for the symbol denoted + * by the given text document position. The request's parameter is of + * type {@link ReferenceParams} the response is of type + * {@link Location Location[]} or a Thenable that resolves to such. + */ + textDocumentReferences: unverifiedRequest({ method: "textDocument/references" }), + /** + * Request to resolve a {@link DocumentHighlight} for a given + * text document position. The request's parameter is of type {@link TextDocumentPosition} + * the request response is an array of type {@link DocumentHighlight} + * or a Thenable that resolves to such. + */ + textDocumentDocumentHighlight: unverifiedRequest({ method: "textDocument/documentHighlight" }), + /** + * A request to list all symbols found in a given text document. The request's + * parameter is of type {@link TextDocumentIdentifier} the + * response is of type {@link SymbolInformation SymbolInformation[]} or a Thenable + * that resolves to such. + */ + textDocumentDocumentSymbol: unverifiedRequest({ method: "textDocument/documentSymbol" }), + /** + * A request to provide commands for the given text document and range. + */ + textDocumentCodeAction: unverifiedRequest({ method: "textDocument/codeAction" }), + /** + * Request to resolve additional information for a given code action.The request's + * parameter is of type {@link CodeAction} the response + * is of type {@link CodeAction} or a Thenable that resolves to such. + */ + codeActionResolve: unverifiedRequest({ method: "codeAction/resolve" }), + /** + * A request to list project-wide symbols matching the query string given + * by the {@link WorkspaceSymbolParams}. The response is + * of type {@link SymbolInformation SymbolInformation[]} or a Thenable that + * resolves to such. + * + * @since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients + * need to advertise support for WorkspaceSymbols via the client capability + * `workspace.symbol.resolveSupport`. + * + */ + workspaceSymbol: unverifiedRequest({ method: "workspace/symbol" }), + /** + * A request to resolve the range inside the workspace + * symbol's location. + * + * @since 3.17.0 + */ + workspaceSymbolResolve: unverifiedRequest({ method: "workspaceSymbol/resolve" }), + /** + * A request to provide code lens for the given text document. + */ + textDocumentCodeLens: unverifiedRequest({ method: "textDocument/codeLens" }), + /** + * A request to resolve a command for a given code lens. + */ + codeLensResolve: unverifiedRequest({ method: "codeLens/resolve" }), + /** + * A request to provide document links + */ + textDocumentDocumentLink: unverifiedRequest({ method: "textDocument/documentLink" }), + /** + * Request to resolve additional information for a given document link. The request's + * parameter is of type {@link DocumentLink} the response + * is of type {@link DocumentLink} or a Thenable that resolves to such. + */ + documentLinkResolve: unverifiedRequest({ method: "documentLink/resolve" }), + /** + * A request to format a whole document. + */ + textDocumentFormatting: unverifiedRequest({ method: "textDocument/formatting" }), + /** + * A request to format a range in a document. + */ + textDocumentRangeFormatting: unverifiedRequest({ method: "textDocument/rangeFormatting" }), + /** + * A request to format ranges in a document. + * + * @since 3.18.0 + * @proposed + */ + textDocumentRangesFormatting: unverifiedRequest({ method: "textDocument/rangesFormatting" }), + /** + * A request to format a document on type. + */ + textDocumentOnTypeFormatting: unverifiedRequest({ method: "textDocument/onTypeFormatting" }), + /** + * A request to rename a symbol. + */ + textDocumentRename: unverifiedRequest({ method: "textDocument/rename" }), + /** + * A request to test and perform the setup necessary for a rename. + * + * @since 3.16 - support for default behavior + */ + textDocumentPrepareRename: unverifiedRequest({ method: "textDocument/prepareRename" }), + /** + * A request send from the client to the server to execute a command. The request might return + * a workspace edit which the client will apply to the workspace. + */ + workspaceExecuteCommand: unverifiedRequest({ method: "workspace/executeCommand" }), + /** + * The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace + * folder configuration changes. + */ + workspaceDidChangeWorkspaceFolders: unverifiedNotification({ method: "workspace/didChangeWorkspaceFolders" }), + /** + * The `window/workDoneProgress/cancel` notification is sent from the client to the server to cancel a progress + * initiated on the server side. + */ + windowWorkDoneProgressCancel: unverifiedNotification({ method: "window/workDoneProgress/cancel" }), + /** + * The did create files notification is sent from the client to the server when + * files were created from within the client. + * + * @since 3.16.0 + */ + workspaceDidCreateFiles: unverifiedNotification({ method: "workspace/didCreateFiles" }), + /** + * The did rename files notification is sent from the client to the server when + * files were renamed from within the client. + * + * @since 3.16.0 + */ + workspaceDidRenameFiles: unverifiedNotification({ method: "workspace/didRenameFiles" }), + /** + * The will delete files request is sent from the client to the server before files are actually + * deleted as long as the deletion is triggered from within the client. + * + * @since 3.16.0 + */ + workspaceDidDeleteFiles: unverifiedNotification({ method: "workspace/didDeleteFiles" }), + /** + * A notification sent when a notebook opens. + * + * @since 3.17.0 + */ + notebookDocumentDidOpen: unverifiedNotification({ method: "notebookDocument/didOpen" }), + notebookDocumentDidChange: unverifiedNotification({ method: "notebookDocument/didChange" }), + /** + * A notification sent when a notebook document is saved. + * + * @since 3.17.0 + */ + notebookDocumentDidSave: unverifiedNotification({ method: "notebookDocument/didSave" }), + /** + * A notification sent when a notebook closes. + * + * @since 3.17.0 + */ + notebookDocumentDidClose: unverifiedNotification({ method: "notebookDocument/didClose" }), + /** + * The initialized notification is sent from the client to the + * server after the client is fully initialized and the server + * is allowed to send requests from the server to the client. + */ + initialized: unverifiedNotification({ method: "initialized" }), + /** + * The exit event is sent from the client to the server to + * ask the server to exit its process. + */ + exit: unverifiedNotification({ method: "exit" }), + /** + * The configuration change notification is sent from the client to the server + * when the client's configuration has changed. The notification contains + * the changed configuration as defined by the language client. + */ + workspaceDidChangeConfiguration: unverifiedNotification({ method: "workspace/didChangeConfiguration" }), + /** + * The document open notification is sent from the client to the server to signal + * newly opened text documents. The document's truth is now managed by the client + * and the server must not try to read the document's truth using the document's + * uri. Open in this sense means it is managed by the client. It doesn't necessarily + * mean that its content is presented in an editor. An open notification must not + * be sent more than once without a corresponding close notification send before. + * This means open and close notification must be balanced and the max open count + * is one. + */ + textDocumentDidOpen: unverifiedNotification({ method: "textDocument/didOpen" }), + /** + * The document change notification is sent from the client to the server to signal + * changes to a text document. + */ + textDocumentDidChange: unverifiedNotification({ method: "textDocument/didChange" }), + /** + * The document close notification is sent from the client to the server when + * the document got closed in the client. The document's truth now exists where + * the document's uri points to (e.g. if the document's uri is a file uri the + * truth now exists on disk). As with the open notification the close notification + * is about managing the document's content. Receiving a close notification + * doesn't mean that the document was open in an editor before. A close + * notification requires a previous open notification to be sent. + */ + textDocumentDidClose: unverifiedNotification({ method: "textDocument/didClose" }), + /** + * The document save notification is sent from the client to the server when + * the document got saved in the client. + */ + textDocumentDidSave: unverifiedNotification({ method: "textDocument/didSave" }), + /** + * A document will save notification is sent from the client to the server before + * the document is actually saved. + */ + textDocumentWillSave: unverifiedNotification({ method: "textDocument/willSave" }), + /** + * The watched files notification is sent from the client to the server when + * the client detects changes to file watched by the language client. + */ + workspaceDidChangeWatchedFiles: unverifiedNotification({ method: "workspace/didChangeWatchedFiles" }), + setTrace: unverifiedNotification({ method: "$/setTrace" }), + cancelRequest: unverifiedNotification({ method: "$/cancelRequest" }), + progress: unverifiedNotification({ method: "$/progress" }), + }, + client: { + /** + * The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders. + */ + workspaceWorkspaceFolders: unverifiedRequest({ method: "workspace/workspaceFolders" }).optional(), + /** + * The 'workspace/configuration' request is sent from the server to the client to fetch a certain + * configuration setting. + * + * This pull model replaces the old push model where the client signaled configuration change via an + * event. If the server still needs to react to configuration changes (since the server caches the + * result of `workspace/configuration` requests) the server should register for an empty configuration + * change event and empty the cache if such an event is received. + */ + workspaceConfiguration: unverifiedRequest({ method: "workspace/configuration" }).optional(), + /** + * @since 3.18.0 + * @proposed + */ + workspaceFoldingRangeRefresh: unverifiedRequest({ method: "workspace/foldingRange/refresh" }).optional(), + /** + * The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress + * reporting from the server. + */ + windowWorkDoneProgressCreate: unverifiedRequest({ method: "window/workDoneProgress/create" }).optional(), + /** + * @since 3.16.0 + */ + workspaceSemanticTokensRefresh: unverifiedRequest({ method: "workspace/semanticTokens/refresh" }).optional(), + /** + * A request to show a document. This request might open an + * external program depending on the value of the URI to open. + * For example a request to open `https://code.visualstudio.com/` + * will very likely open the URI in a WEB browser. + * + * @since 3.16.0 + */ + windowShowDocument: unverifiedRequest({ method: "window/showDocument" }).optional(), + /** + * @since 3.17.0 + */ + workspaceInlineValueRefresh: unverifiedRequest({ method: "workspace/inlineValue/refresh" }).optional(), + /** + * @since 3.17.0 + */ + workspaceInlayHintRefresh: unverifiedRequest({ method: "workspace/inlayHint/refresh" }).optional(), + /** + * The diagnostic refresh request definition. + * + * @since 3.17.0 + */ + workspaceDiagnosticRefresh: unverifiedRequest({ method: "workspace/diagnostic/refresh" }).optional(), + /** + * The `client/registerCapability` request is sent from the server to the client to register a new capability + * handler on the client side. + */ + clientRegisterCapability: unverifiedRequest({ method: "client/registerCapability" }).optional(), + /** + * The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability + * handler on the client side. + */ + clientUnregisterCapability: unverifiedRequest({ method: "client/unregisterCapability" }).optional(), + /** + * The show message request is sent from the server to the client to show a message + * and a set of options actions to the user. + */ + windowShowMessageRequest: unverifiedRequest({ method: "window/showMessageRequest" }).optional(), + /** + * A request to refresh all code actions + * + * @since 3.16.0 + */ + workspaceCodeLensRefresh: unverifiedRequest({ method: "workspace/codeLens/refresh" }).optional(), + /** + * A request sent from the server to the client to modified certain resources. + */ + workspaceApplyEdit: unverifiedRequest({ method: "workspace/applyEdit" }).optional(), + /** + * The show message notification is sent from a server to a client to ask + * the client to display a particular message in the user interface. + */ + windowShowMessage: unverifiedNotification({ method: "window/showMessage" }), + /** + * The log message notification is sent from the server to the client to ask + * the client to log a particular message. + */ + windowLogMessage: unverifiedNotification({ method: "window/logMessage" }), + /** + * The telemetry event notification is sent from the server to the client to ask + * the client to log telemetry data. + */ + telemetryEvent: unverifiedNotification({ method: "telemetry/event" }), + /** + * Diagnostics notification are sent from the server to the client to signal + * results of validation runs. + */ + textDocumentPublishDiagnostics: unverifiedNotification({ method: "textDocument/publishDiagnostics" }), + logTrace: unverifiedNotification({ method: "$/logTrace" }), + cancelRequest: unverifiedNotification({ method: "$/cancelRequest" }), + progress: unverifiedNotification({ method: "$/progress" }), + } +}); diff --git a/monaco-lsp-client/src/utils.ts b/monaco-lsp-client/src/utils.ts new file mode 100644 index 00000000..00905499 --- /dev/null +++ b/monaco-lsp-client/src/utils.ts @@ -0,0 +1,75 @@ +export interface IDisposable { + dispose(): void; +} + +export class Disposable implements IDisposable { + static None = Object.freeze({ dispose() { } }); + + private _store = new DisposableStore(); + + constructor() { } + + public dispose(): void { + this._store.dispose(); + } + + protected _register(t: T): T { + if ((t as any) === this) { + throw new Error('Cannot register a disposable on itself!'); + } + return this._store.add(t); + } +} + +export class DisposableStore implements IDisposable { + static DISABLE_DISPOSED_WARNING = false; + + private _toDispose = new Set(); + private _isDisposed = false; + + public dispose(): void { + if (this._isDisposed) { + return; + } + + this._isDisposed = true; + this.clear(); + } + + public clear(): void { + if (this._toDispose.size === 0) { + return; + } + + try { + for (const item of this._toDispose) { + item.dispose(); + } + } finally { + this._toDispose.clear(); + } + } + + public add(t: T): T { + if (!t) { + return t; + } + if ((t as any) === this) { + throw new Error('Cannot register a disposable on itself!'); + } + + if (this._isDisposed) { + if (!DisposableStore.DISABLE_DISPOSED_WARNING) { + console.warn( + new Error( + 'Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!' + ).stack + ); + } + } else { + this._toDispose.add(t); + } + + return t; + } +} diff --git a/package-lock.json b/package-lock.json index c8eccfef..ed65ffae 100644 --- a/package-lock.json +++ b/package-lock.json @@ -17,6 +17,7 @@ "@types/shelljs": "^0.8.11", "@types/trusted-types": "^1.0.6", "@typescript/vfs": "^1.3.5", + "@vscode/monaco-lsp-client": "file:./monaco-lsp-client", "chai": "^4.3.6", "clean-css": "^5.2.4", "css-loader": "^6.7.1", @@ -57,6 +58,24 @@ "yaserver": "^0.4.0" } }, + "monaco-lsp-client": { + "name": "@vscode/monaco-lsp-client", + "version": "0.1.0", + "dev": true, + "dependencies": { + "@hediet/json-rpc": "^0.5.0", + "@hediet/json-rpc-browser": "^0.5.1", + "@hediet/json-rpc-websocket": "^0.5.1" + }, + "devDependencies": { + "rolldown": "^1.0.0-beta.41", + "rolldown-plugin-dts": "^0.16.11", + "rollup-plugin-delete": "^3.0.1" + }, + "peerDependencies": { + "monaco-editor-core": "^0.54.0-dev-20250929" + } + }, "node_modules/@babel/code-frame": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz", @@ -72,6 +91,33 @@ "node": ">=6.9.0" } }, + "node_modules/@babel/generator": { + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz", + "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.28.3", + "@babel/types": "^7.28.2", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@babel/helper-validator-identifier": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", @@ -82,6 +128,36 @@ "node": ">=6.9.0" } }, + "node_modules/@babel/parser": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz", + "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.4" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz", + "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@cspotcode/source-map-consumer": { "version": "0.8.0", "resolved": "https://registry.npmjs.org/@cspotcode/source-map-consumer/-/source-map-consumer-0.8.0.tgz", @@ -103,6 +179,40 @@ "node": ">=12" } }, + "node_modules/@emnapi/core": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.5.0.tgz", + "integrity": "sha512-sbP8GzB1WDzacS8fgNPpHlp6C9VZe+SJP3F90W9rLemaQj2PzIuTEl1qDOYQf58YIpyjViI24y9aPWCjEzY2cg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/wasi-threads": "1.1.0", + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/runtime": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.5.0.tgz", + "integrity": "sha512-97/BJ3iXHww3djw6hYIfErCZFee7qCtrneuLa20UXFCOTCfBM2cvQHjWJ2EG0s0MtdNwInarqCTz35i4wWXHsQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/wasi-threads": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz", + "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, "node_modules/@esbuild/aix-ppc64": { "version": "0.25.9", "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.9.tgz", @@ -511,6 +621,35 @@ "node": ">=18" } }, + "node_modules/@hediet/json-rpc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/@hediet/json-rpc/-/json-rpc-0.5.0.tgz", + "integrity": "sha512-SApO7NbKJztClcznEqg46ZGQzO2v3Q3gVIuRVC9QE/m75J/5AipJdclxEXgT++7j4x4LI2JjEpf2xhi67Ngu9A==", + "dev": true, + "license": "MIT" + }, + "node_modules/@hediet/json-rpc-browser": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@hediet/json-rpc-browser/-/json-rpc-browser-0.5.1.tgz", + "integrity": "sha512-iR+WrTdM7WozRJ/MElfeT8CmH2f911Y8P6xfcj5RCfywp7kjnnqKPUV/VnNnzToxRZUO8WAfJtLvmhDBsSjMtA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@hediet/json-rpc": "^0.5.0" + } + }, + "node_modules/@hediet/json-rpc-websocket": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@hediet/json-rpc-websocket/-/json-rpc-websocket-0.5.1.tgz", + "integrity": "sha512-1H9UjKyR00ZjwcReQdzTxyEoZKaEubeOvxBVrwHGo4n9HeQt6SvQgtef+1AJ9MT7/sV2Qfe0VWarYivx6BWgIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@hediet/json-rpc": "^0.5.0", + "@types/ws": "^6.0.4", + "isomorphic-ws": "^5.0.0" + } + }, "node_modules/@isaacs/cliui": { "version": "8.0.2", "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", @@ -848,6 +987,19 @@ "win32" ] }, + "node_modules/@napi-rs/wasm-runtime": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.0.6.tgz", + "integrity": "sha512-DXj75ewm11LIWUk198QSKUTxjyRjsBwk09MuMk5DGK+GDUtyPhhEHOGP/Xwwj3DjQXXkivoBirmOnKrLfc0+9g==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/core": "^1.5.0", + "@emnapi/runtime": "^1.5.0", + "@tybys/wasm-util": "^0.10.1" + } + }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", @@ -1018,6 +1170,16 @@ "@octokit/openapi-types": "^12.11.0" } }, + "node_modules/@oxc-project/types": { + "version": "0.94.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.94.0.tgz", + "integrity": "sha512-+UgQT/4o59cZfH6Cp7G0hwmqEQ0wE+AdIwhikdwnhWI9Dp8CgSY081+Q3O67/wq3VJu8mgUEB93J9EHHn70fOw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, "node_modules/@parcel/bundler-default": { "version": "2.8.1", "resolved": "https://registry.npmjs.org/@parcel/bundler-default/-/bundler-default-2.8.1.tgz", @@ -2314,6 +2476,251 @@ "node": ">=18" } }, + "node_modules/@rolldown/binding-android-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-W5ZKF3TP3bOWuBfotAGp+UGjxOkGV7jRmIRbBA7NFjggx7Oi6vOmGDqpHEIX7kDCiry1cnIsWQaxNvWbMdkvzQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-abw/wtgJA8OCgaTlL+xJxnN/Z01BwV1rfzIp5Hh9x+IIO6xOBfPsQ0nzi0+rWx3TyZ9FZXyC7bbC+5NpQ9EaXQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-x64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-beta.42.tgz", + "integrity": "sha512-Y/UrZIRVr8CvXVEB88t6PeC46r1K9/QdPEo2ASE/b/KBEyXIx+QbM6kv9QfQVWU2Atly2+SVsQzxQsIvuk3lZQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-freebsd-x64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-beta.42.tgz", + "integrity": "sha512-zRM0oOk7BZiy6DoWBvdV4hyEg+j6+WcBZIMHVirMEZRu8hd18kZdJkg+bjVMfCEhwpWeFUfBfZ1qcaZ5UdYzlQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm-gnueabihf": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-beta.42.tgz", + "integrity": "sha512-6RjFaC52QNwo7ilU8C5H7swbGlgfTkG9pudXwzr3VYyT18s0C9gLg3mvc7OMPIGqNxnQ0M5lU8j6aQCk2DTRVg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-gnu": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-beta.42.tgz", + "integrity": "sha512-LMYHM5Sf6ROq+VUwHMDVX2IAuEsWTv4SnlFEedBnMGpvRuQ14lCmD4m5Q8sjyAQCgyha9oghdGoK8AEg1sXZKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-musl": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-beta.42.tgz", + "integrity": "sha512-/bNTYb9aKNhzdbPn3O4MK2aLv55AlrkUKPE4KNfBYjkoZUfDr4jWp7gsSlvTc5A/99V1RCm9axvt616ZzeXGyA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-beta.42.tgz", + "integrity": "sha512-n/SLa4h342oyeGykZdch7Y3GNCNliRPL4k5wkeZ/5eQZs+c6/ZG1SHCJQoy7bZcmxiMyaXs9HoFmv1PEKrZgWg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-musl": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-beta.42.tgz", + "integrity": "sha512-4PSd46sFzqpLHSGdaSViAb1mk55sCUMpJg+X8ittXaVocQsV3QLG/uydSH8RyL0ngHX5fy3D70LcCzlB15AgHw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-openharmony-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-BmWoeJJyeZXmZBcfoxG6J9+rl2G7eO47qdTkAzEegj4n3aC6CBIHOuDcbE8BvhZaEjQR0nh0nJrtEDlt65Q7Sw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-wasm32-wasi": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-beta.42.tgz", + "integrity": "sha512-2Ft32F7uiDTrGZUKws6CLNTlvTWHC33l4vpXrzUucf9rYtUThAdPCOt89Pmn13tNX6AulxjGEP2R0nZjTSW3eQ==", + "cpu": [ + "wasm32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@napi-rs/wasm-runtime": "^1.0.6" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@rolldown/binding-win32-arm64-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-hC1kShXW/z221eG+WzQMN06KepvPbMBknF0iGR3VMYJLOe9gwnSTfGxFT5hf8XrPv7CEZqTWRd0GQpkSHRbGsw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-ia32-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-AICBYromawouGjj+GS33369E8Vwhy6UwhQEhQ5evfS8jPCsyVvoICJatbDGDGH01dwtVGLD5eDFzPicUOVpe4g==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-x64-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-XpZ0M+tjoEiSc9c+uZR7FCnOI0uxDRNs1elGOMjeB0pUP1QmvVbZGYNsyLbLoP4u7e3VQN8rie1OQ8/mB6rcJg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.42.tgz", + "integrity": "sha512-N7pQzk9CyE7q0bBN/q0J8s6Db279r5kUZc6d7/wWRe9/zXqC52HQovVyu6iXPIDY4BEzzgbVLhVFXrOuGJ22ZQ==", + "dev": true, + "license": "MIT" + }, "node_modules/@rollup/plugin-alias": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/@rollup/plugin-alias/-/plugin-alias-5.1.1.tgz", @@ -2759,6 +3166,17 @@ "integrity": "sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==", "dev": true }, + "node_modules/@tybys/wasm-util": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz", + "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, "node_modules/@types/eslint": { "version": "8.4.10", "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.4.10.tgz", @@ -2847,6 +3265,16 @@ "integrity": "sha512-230RC8sFeHoT6sSUlRO6a8cAnclO06eeiq1QDfiv2FGCLWFvvERWgwIQD4FWqD9A69BN7Lzee4OXwoMVnnsWDw==", "dev": true }, + "node_modules/@types/ws": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-6.0.4.tgz", + "integrity": "sha512-PpPrX7SZW9re6+Ha8ojZG4Se8AZXgf0GK6zmfqEuCsY49LFDNXO3SByp44X3dFEqtB73lkCDAdUazhAjVPiNwg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, "node_modules/@typescript/vfs": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/@typescript/vfs/-/vfs-1.3.5.tgz", @@ -2862,6 +3290,10 @@ "integrity": "sha512-KYSIHVmslkaCDyw013pphY+d7x1qV8IZupYfeIfzNA+nsaWHbn5uPuQRvdRFsa9zFzGeudPuoGoZ1Op4jrJXIQ==", "dev": true }, + "node_modules/@vscode/monaco-lsp-client": { + "resolved": "monaco-lsp-client", + "link": true + }, "node_modules/@webassemblyjs/ast": { "version": "1.11.1", "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.1.tgz", @@ -3147,6 +3579,16 @@ "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, + "node_modules/ansis": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/ansis/-/ansis-4.2.0.tgz", + "integrity": "sha512-HqZ5rWlFjGiV0tDm3UxxgNRqsOTniqoKZu0pIAfh7TZQMGuZK+hH0drySty0si0QXj1ieop4+SkSfPZBPPkHig==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=14" + } + }, "node_modules/arg": { "version": "4.1.3", "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", @@ -3195,6 +3637,23 @@ "node": "*" } }, + "node_modules/ast-kit": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ast-kit/-/ast-kit-2.1.3.tgz", + "integrity": "sha512-TH+b3Lv6pUjy/Nu0m6A2JULtdzLpmqF9x1Dhj00ZoEiML8qvVA9j1flkzTKNYgdEhWrjDwtWNpyyCUbfQe514g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.28.4", + "pathe": "^2.0.3" + }, + "engines": { + "node": ">=20.19.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + } + }, "node_modules/async": { "version": "2.6.4", "resolved": "https://registry.npmjs.org/async/-/async-2.6.4.tgz", @@ -3258,6 +3717,16 @@ "node": "*" } }, + "node_modules/birpc": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.6.1.tgz", + "integrity": "sha512-LPnFhlDpdSH6FJhJyn4M0kFO7vtQ5iPw24FnG0y21q09xC7e8+1LeR31S1MAIrDAHp4m7aas4bEkTDTvMAtebQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, "node_modules/boolbase": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", @@ -4052,6 +4521,27 @@ "integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==", "dev": true }, + "node_modules/dts-resolver": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/dts-resolver/-/dts-resolver-2.1.2.tgz", + "integrity": "sha512-xeXHBQkn2ISSXxbJWD828PFjtyg+/UrMDo7W4Ffcs7+YWCquxU8YjV1KoxuiL+eJ5pg3ll+bC6flVv61L3LKZg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.18.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + }, + "peerDependencies": { + "oxc-resolver": ">=11.0.0" + }, + "peerDependenciesMeta": { + "oxc-resolver": { + "optional": true + } + } + }, "node_modules/eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", @@ -5196,6 +5686,16 @@ "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", "dev": true }, + "node_modules/isomorphic-ws": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-5.0.0.tgz", + "integrity": "sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "ws": "*" + } + }, "node_modules/jackspeak": { "version": "3.4.3", "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", @@ -5291,6 +5791,19 @@ } } }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, "node_modules/json-parse-even-better-errors": { "version": "2.3.1", "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", @@ -7028,6 +7541,85 @@ "node": ">=0.10.0" } }, + "node_modules/rolldown": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-beta.42.tgz", + "integrity": "sha512-xaPcckj+BbJhYLsv8gOqezc8EdMcKKe/gk8v47B0KPvgABDrQ0qmNPAiT/gh9n9Foe0bUkEv2qzj42uU5q1WRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.94.0", + "@rolldown/pluginutils": "1.0.0-beta.42", + "ansis": "=4.2.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm64": "1.0.0-beta.42", + "@rolldown/binding-darwin-arm64": "1.0.0-beta.42", + "@rolldown/binding-darwin-x64": "1.0.0-beta.42", + "@rolldown/binding-freebsd-x64": "1.0.0-beta.42", + "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-beta.42", + "@rolldown/binding-linux-arm64-gnu": "1.0.0-beta.42", + "@rolldown/binding-linux-arm64-musl": "1.0.0-beta.42", + "@rolldown/binding-linux-x64-gnu": "1.0.0-beta.42", + "@rolldown/binding-linux-x64-musl": "1.0.0-beta.42", + "@rolldown/binding-openharmony-arm64": "1.0.0-beta.42", + "@rolldown/binding-wasm32-wasi": "1.0.0-beta.42", + "@rolldown/binding-win32-arm64-msvc": "1.0.0-beta.42", + "@rolldown/binding-win32-ia32-msvc": "1.0.0-beta.42", + "@rolldown/binding-win32-x64-msvc": "1.0.0-beta.42" + } + }, + "node_modules/rolldown-plugin-dts": { + "version": "0.16.11", + "resolved": "https://registry.npmjs.org/rolldown-plugin-dts/-/rolldown-plugin-dts-0.16.11.tgz", + "integrity": "sha512-9IQDaPvPqTx3RjG2eQCK5GYZITo203BxKunGI80AGYicu1ySFTUyugicAaTZWRzFWh9DSnzkgNeMNbDWBbSs0w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/generator": "^7.28.3", + "@babel/parser": "^7.28.4", + "@babel/types": "^7.28.4", + "ast-kit": "^2.1.2", + "birpc": "^2.6.1", + "debug": "^4.4.3", + "dts-resolver": "^2.1.2", + "get-tsconfig": "^4.10.1", + "magic-string": "^0.30.19" + }, + "engines": { + "node": ">=20.18.0" + }, + "funding": { + "url": "https://github.com/sponsors/sxzz" + }, + "peerDependencies": { + "@ts-macro/tsc": "^0.3.6", + "@typescript/native-preview": ">=7.0.0-dev.20250601.1", + "rolldown": "^1.0.0-beta.9", + "typescript": "^5.0.0", + "vue-tsc": "~3.1.0" + }, + "peerDependenciesMeta": { + "@ts-macro/tsc": { + "optional": true + }, + "@typescript/native-preview": { + "optional": true + }, + "typescript": { + "optional": true + }, + "vue-tsc": { + "optional": true + } + } + }, "node_modules/rollup": { "version": "4.52.4", "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.4.tgz", @@ -8493,12 +9085,50 @@ "picocolors": "^1.1.1" } }, + "@babel/generator": { + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz", + "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==", + "dev": true, + "requires": { + "@babel/parser": "^7.28.3", + "@babel/types": "^7.28.2", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + } + }, + "@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true + }, "@babel/helper-validator-identifier": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==", "dev": true }, + "@babel/parser": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz", + "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==", + "dev": true, + "requires": { + "@babel/types": "^7.28.4" + } + }, + "@babel/types": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz", + "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==", + "dev": true, + "requires": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1" + } + }, "@cspotcode/source-map-consumer": { "version": "0.8.0", "resolved": "https://registry.npmjs.org/@cspotcode/source-map-consumer/-/source-map-consumer-0.8.0.tgz", @@ -8514,6 +9144,37 @@ "@cspotcode/source-map-consumer": "0.8.0" } }, + "@emnapi/core": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.5.0.tgz", + "integrity": "sha512-sbP8GzB1WDzacS8fgNPpHlp6C9VZe+SJP3F90W9rLemaQj2PzIuTEl1qDOYQf58YIpyjViI24y9aPWCjEzY2cg==", + "dev": true, + "optional": true, + "requires": { + "@emnapi/wasi-threads": "1.1.0", + "tslib": "^2.4.0" + } + }, + "@emnapi/runtime": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.5.0.tgz", + "integrity": "sha512-97/BJ3iXHww3djw6hYIfErCZFee7qCtrneuLa20UXFCOTCfBM2cvQHjWJ2EG0s0MtdNwInarqCTz35i4wWXHsQ==", + "dev": true, + "optional": true, + "requires": { + "tslib": "^2.4.0" + } + }, + "@emnapi/wasi-threads": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz", + "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==", + "dev": true, + "optional": true, + "requires": { + "tslib": "^2.4.0" + } + }, "@esbuild/aix-ppc64": { "version": "0.25.9", "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.9.tgz", @@ -8682,6 +9343,32 @@ "dev": true, "optional": true }, + "@hediet/json-rpc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/@hediet/json-rpc/-/json-rpc-0.5.0.tgz", + "integrity": "sha512-SApO7NbKJztClcznEqg46ZGQzO2v3Q3gVIuRVC9QE/m75J/5AipJdclxEXgT++7j4x4LI2JjEpf2xhi67Ngu9A==", + "dev": true + }, + "@hediet/json-rpc-browser": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@hediet/json-rpc-browser/-/json-rpc-browser-0.5.1.tgz", + "integrity": "sha512-iR+WrTdM7WozRJ/MElfeT8CmH2f911Y8P6xfcj5RCfywp7kjnnqKPUV/VnNnzToxRZUO8WAfJtLvmhDBsSjMtA==", + "dev": true, + "requires": { + "@hediet/json-rpc": "^0.5.0" + } + }, + "@hediet/json-rpc-websocket": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/@hediet/json-rpc-websocket/-/json-rpc-websocket-0.5.1.tgz", + "integrity": "sha512-1H9UjKyR00ZjwcReQdzTxyEoZKaEubeOvxBVrwHGo4n9HeQt6SvQgtef+1AJ9MT7/sV2Qfe0VWarYivx6BWgIA==", + "dev": true, + "requires": { + "@hediet/json-rpc": "^0.5.0", + "@types/ws": "^6.0.4", + "isomorphic-ws": "^5.0.0" + } + }, "@isaacs/cliui": { "version": "8.0.2", "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", @@ -8899,6 +9586,18 @@ "dev": true, "optional": true }, + "@napi-rs/wasm-runtime": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.0.6.tgz", + "integrity": "sha512-DXj75ewm11LIWUk198QSKUTxjyRjsBwk09MuMk5DGK+GDUtyPhhEHOGP/Xwwj3DjQXXkivoBirmOnKrLfc0+9g==", + "dev": true, + "optional": true, + "requires": { + "@emnapi/core": "^1.5.0", + "@emnapi/runtime": "^1.5.0", + "@tybys/wasm-util": "^0.10.1" + } + }, "@nodelib/fs.scandir": { "version": "2.1.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", @@ -9049,6 +9748,12 @@ "@octokit/openapi-types": "^12.11.0" } }, + "@oxc-project/types": { + "version": "0.94.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.94.0.tgz", + "integrity": "sha512-+UgQT/4o59cZfH6Cp7G0hwmqEQ0wE+AdIwhikdwnhWI9Dp8CgSY081+Q3O67/wq3VJu8mgUEB93J9EHHn70fOw==", + "dev": true + }, "@parcel/bundler-default": { "version": "2.8.1", "resolved": "https://registry.npmjs.org/@parcel/bundler-default/-/bundler-default-2.8.1.tgz", @@ -9907,6 +10612,113 @@ "playwright": "1.54.2" } }, + "@rolldown/binding-android-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-W5ZKF3TP3bOWuBfotAGp+UGjxOkGV7jRmIRbBA7NFjggx7Oi6vOmGDqpHEIX7kDCiry1cnIsWQaxNvWbMdkvzQ==", + "dev": true, + "optional": true + }, + "@rolldown/binding-darwin-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-abw/wtgJA8OCgaTlL+xJxnN/Z01BwV1rfzIp5Hh9x+IIO6xOBfPsQ0nzi0+rWx3TyZ9FZXyC7bbC+5NpQ9EaXQ==", + "dev": true, + "optional": true + }, + "@rolldown/binding-darwin-x64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.0.0-beta.42.tgz", + "integrity": "sha512-Y/UrZIRVr8CvXVEB88t6PeC46r1K9/QdPEo2ASE/b/KBEyXIx+QbM6kv9QfQVWU2Atly2+SVsQzxQsIvuk3lZQ==", + "dev": true, + "optional": true + }, + "@rolldown/binding-freebsd-x64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.0.0-beta.42.tgz", + "integrity": "sha512-zRM0oOk7BZiy6DoWBvdV4hyEg+j6+WcBZIMHVirMEZRu8hd18kZdJkg+bjVMfCEhwpWeFUfBfZ1qcaZ5UdYzlQ==", + "dev": true, + "optional": true + }, + "@rolldown/binding-linux-arm-gnueabihf": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.0.0-beta.42.tgz", + "integrity": "sha512-6RjFaC52QNwo7ilU8C5H7swbGlgfTkG9pudXwzr3VYyT18s0C9gLg3mvc7OMPIGqNxnQ0M5lU8j6aQCk2DTRVg==", + "dev": true, + "optional": true + }, + "@rolldown/binding-linux-arm64-gnu": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.0.0-beta.42.tgz", + "integrity": "sha512-LMYHM5Sf6ROq+VUwHMDVX2IAuEsWTv4SnlFEedBnMGpvRuQ14lCmD4m5Q8sjyAQCgyha9oghdGoK8AEg1sXZKg==", + "dev": true, + "optional": true + }, + "@rolldown/binding-linux-arm64-musl": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.0.0-beta.42.tgz", + "integrity": "sha512-/bNTYb9aKNhzdbPn3O4MK2aLv55AlrkUKPE4KNfBYjkoZUfDr4jWp7gsSlvTc5A/99V1RCm9axvt616ZzeXGyA==", + "dev": true, + "optional": true + }, + "@rolldown/binding-linux-x64-gnu": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.0-beta.42.tgz", + "integrity": "sha512-n/SLa4h342oyeGykZdch7Y3GNCNliRPL4k5wkeZ/5eQZs+c6/ZG1SHCJQoy7bZcmxiMyaXs9HoFmv1PEKrZgWg==", + "dev": true, + "optional": true + }, + "@rolldown/binding-linux-x64-musl": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.0-beta.42.tgz", + "integrity": "sha512-4PSd46sFzqpLHSGdaSViAb1mk55sCUMpJg+X8ittXaVocQsV3QLG/uydSH8RyL0ngHX5fy3D70LcCzlB15AgHw==", + "dev": true, + "optional": true + }, + "@rolldown/binding-openharmony-arm64": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.0.0-beta.42.tgz", + "integrity": "sha512-BmWoeJJyeZXmZBcfoxG6J9+rl2G7eO47qdTkAzEegj4n3aC6CBIHOuDcbE8BvhZaEjQR0nh0nJrtEDlt65Q7Sw==", + "dev": true, + "optional": true + }, + "@rolldown/binding-wasm32-wasi": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.0.0-beta.42.tgz", + "integrity": "sha512-2Ft32F7uiDTrGZUKws6CLNTlvTWHC33l4vpXrzUucf9rYtUThAdPCOt89Pmn13tNX6AulxjGEP2R0nZjTSW3eQ==", + "dev": true, + "optional": true, + "requires": { + "@napi-rs/wasm-runtime": "^1.0.6" + } + }, + "@rolldown/binding-win32-arm64-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-hC1kShXW/z221eG+WzQMN06KepvPbMBknF0iGR3VMYJLOe9gwnSTfGxFT5hf8XrPv7CEZqTWRd0GQpkSHRbGsw==", + "dev": true, + "optional": true + }, + "@rolldown/binding-win32-ia32-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-AICBYromawouGjj+GS33369E8Vwhy6UwhQEhQ5evfS8jPCsyVvoICJatbDGDGH01dwtVGLD5eDFzPicUOVpe4g==", + "dev": true, + "optional": true + }, + "@rolldown/binding-win32-x64-msvc": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.0.0-beta.42.tgz", + "integrity": "sha512-XpZ0M+tjoEiSc9c+uZR7FCnOI0uxDRNs1elGOMjeB0pUP1QmvVbZGYNsyLbLoP4u7e3VQN8rie1OQ8/mB6rcJg==", + "dev": true, + "optional": true + }, + "@rolldown/pluginutils": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.42.tgz", + "integrity": "sha512-N7pQzk9CyE7q0bBN/q0J8s6Db279r5kUZc6d7/wWRe9/zXqC52HQovVyu6iXPIDY4BEzzgbVLhVFXrOuGJ22ZQ==", + "dev": true + }, "@rollup/plugin-alias": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/@rollup/plugin-alias/-/plugin-alias-5.1.1.tgz", @@ -10151,6 +10963,16 @@ "integrity": "sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==", "dev": true }, + "@tybys/wasm-util": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz", + "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==", + "dev": true, + "optional": true, + "requires": { + "tslib": "^2.4.0" + } + }, "@types/eslint": { "version": "8.4.10", "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.4.10.tgz", @@ -10236,6 +11058,15 @@ "integrity": "sha512-230RC8sFeHoT6sSUlRO6a8cAnclO06eeiq1QDfiv2FGCLWFvvERWgwIQD4FWqD9A69BN7Lzee4OXwoMVnnsWDw==", "dev": true }, + "@types/ws": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-6.0.4.tgz", + "integrity": "sha512-PpPrX7SZW9re6+Ha8ojZG4Se8AZXgf0GK6zmfqEuCsY49LFDNXO3SByp44X3dFEqtB73lkCDAdUazhAjVPiNwg==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, "@typescript/vfs": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/@typescript/vfs/-/vfs-1.3.5.tgz", @@ -10251,6 +11082,17 @@ "integrity": "sha512-KYSIHVmslkaCDyw013pphY+d7x1qV8IZupYfeIfzNA+nsaWHbn5uPuQRvdRFsa9zFzGeudPuoGoZ1Op4jrJXIQ==", "dev": true }, + "@vscode/monaco-lsp-client": { + "version": "file:monaco-lsp-client", + "requires": { + "@hediet/json-rpc": "^0.5.0", + "@hediet/json-rpc-browser": "^0.5.1", + "@hediet/json-rpc-websocket": "^0.5.1", + "rolldown": "^1.0.0-beta.41", + "rolldown-plugin-dts": "^0.16.11", + "rollup-plugin-delete": "^3.0.1" + } + }, "@webassemblyjs/ast": { "version": "1.11.1", "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.1.tgz", @@ -10501,6 +11343,12 @@ "color-convert": "^2.0.1" } }, + "ansis": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/ansis/-/ansis-4.2.0.tgz", + "integrity": "sha512-HqZ5rWlFjGiV0tDm3UxxgNRqsOTniqoKZu0pIAfh7TZQMGuZK+hH0drySty0si0QXj1ieop4+SkSfPZBPPkHig==", + "dev": true + }, "arg": { "version": "4.1.3", "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", @@ -10537,6 +11385,16 @@ "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", "dev": true }, + "ast-kit": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ast-kit/-/ast-kit-2.1.3.tgz", + "integrity": "sha512-TH+b3Lv6pUjy/Nu0m6A2JULtdzLpmqF9x1Dhj00ZoEiML8qvVA9j1flkzTKNYgdEhWrjDwtWNpyyCUbfQe514g==", + "dev": true, + "requires": { + "@babel/parser": "^7.28.4", + "pathe": "^2.0.3" + } + }, "async": { "version": "2.6.4", "resolved": "https://registry.npmjs.org/async/-/async-2.6.4.tgz", @@ -10596,6 +11454,12 @@ "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==", "dev": true }, + "birpc": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.6.1.tgz", + "integrity": "sha512-LPnFhlDpdSH6FJhJyn4M0kFO7vtQ5iPw24FnG0y21q09xC7e8+1LeR31S1MAIrDAHp4m7aas4bEkTDTvMAtebQ==", + "dev": true + }, "boolbase": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", @@ -11163,6 +12027,13 @@ "integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==", "dev": true }, + "dts-resolver": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/dts-resolver/-/dts-resolver-2.1.2.tgz", + "integrity": "sha512-xeXHBQkn2ISSXxbJWD828PFjtyg+/UrMDo7W4Ffcs7+YWCquxU8YjV1KoxuiL+eJ5pg3ll+bC6flVv61L3LKZg==", + "dev": true, + "requires": {} + }, "eastasianwidth": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", @@ -11935,6 +12806,13 @@ "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", "dev": true }, + "isomorphic-ws": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-5.0.0.tgz", + "integrity": "sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==", + "dev": true, + "requires": {} + }, "jackspeak": { "version": "3.4.3", "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", @@ -12006,6 +12884,12 @@ "xml-name-validator": "^4.0.0" } }, + "jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true + }, "json-parse-even-better-errors": { "version": "2.3.1", "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", @@ -13163,6 +14047,48 @@ "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", "dev": true }, + "rolldown": { + "version": "1.0.0-beta.42", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-beta.42.tgz", + "integrity": "sha512-xaPcckj+BbJhYLsv8gOqezc8EdMcKKe/gk8v47B0KPvgABDrQ0qmNPAiT/gh9n9Foe0bUkEv2qzj42uU5q1WRg==", + "dev": true, + "requires": { + "@oxc-project/types": "=0.94.0", + "@rolldown/binding-android-arm64": "1.0.0-beta.42", + "@rolldown/binding-darwin-arm64": "1.0.0-beta.42", + "@rolldown/binding-darwin-x64": "1.0.0-beta.42", + "@rolldown/binding-freebsd-x64": "1.0.0-beta.42", + "@rolldown/binding-linux-arm-gnueabihf": "1.0.0-beta.42", + "@rolldown/binding-linux-arm64-gnu": "1.0.0-beta.42", + "@rolldown/binding-linux-arm64-musl": "1.0.0-beta.42", + "@rolldown/binding-linux-x64-gnu": "1.0.0-beta.42", + "@rolldown/binding-linux-x64-musl": "1.0.0-beta.42", + "@rolldown/binding-openharmony-arm64": "1.0.0-beta.42", + "@rolldown/binding-wasm32-wasi": "1.0.0-beta.42", + "@rolldown/binding-win32-arm64-msvc": "1.0.0-beta.42", + "@rolldown/binding-win32-ia32-msvc": "1.0.0-beta.42", + "@rolldown/binding-win32-x64-msvc": "1.0.0-beta.42", + "@rolldown/pluginutils": "1.0.0-beta.42", + "ansis": "=4.2.0" + } + }, + "rolldown-plugin-dts": { + "version": "0.16.11", + "resolved": "https://registry.npmjs.org/rolldown-plugin-dts/-/rolldown-plugin-dts-0.16.11.tgz", + "integrity": "sha512-9IQDaPvPqTx3RjG2eQCK5GYZITo203BxKunGI80AGYicu1ySFTUyugicAaTZWRzFWh9DSnzkgNeMNbDWBbSs0w==", + "dev": true, + "requires": { + "@babel/generator": "^7.28.3", + "@babel/parser": "^7.28.4", + "@babel/types": "^7.28.4", + "ast-kit": "^2.1.2", + "birpc": "^2.6.1", + "debug": "^4.4.3", + "dts-resolver": "^2.1.2", + "get-tsconfig": "^4.10.1", + "magic-string": "^0.30.19" + } + }, "rollup": { "version": "4.52.4", "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.52.4.tgz", diff --git a/package.json b/package.json index 483220a6..ed49ebfe 100644 --- a/package.json +++ b/package.json @@ -30,7 +30,8 @@ "watch": "tsc -w -p ./src", "build-languages": "ts-node ./build/build-languages", "build-monaco-editor": "ts-node ./build/build-monaco-editor", - "build": "npm run build-languages && npm run build-monaco-editor" + "build-lsp": "cd monaco-lsp-client && npm install && npm run build", + "build": "npm run build-lsp && npm run build-languages && npm run build-monaco-editor" }, "typings": "./esm/vs/editor/editor.api.d.ts", "module": "./esm/vs/editor/editor.main.js", @@ -39,6 +40,7 @@ "url": "https://github.com/microsoft/monaco-editor" }, "devDependencies": { + "@vscode/monaco-lsp-client": "file:./monaco-lsp-client", "@playwright/test": "^1.53.2", "@rollup/plugin-alias": "^5.1.1", "@rollup/plugin-node-resolve": "^16.0.2",