{
- return new Promise((resolve, reject) => {
- glob(
- './out/monaco-editor/esm/vs/language/*/monaco.contribution.js',
- { cwd: path.dirname(__dirname) },
- (err, files) => {
- if (err) {
- reject(err);
- return;
- }
-
- resolve(
- files
- .map((file) => file.substring('./out/monaco-editor/esm/vs/language/'.length))
- .map((file) => file.substring(0, file.length - '/monaco.contribution.js'.length))
- );
- }
- );
- });
-}
-
-function getAdvancedLanguages(): Promise<
- { label: string; entry: string; worker: { id: string; entry: string } }[]
-> {
- return readAdvancedLanguages().then((languages) => {
- let result = [];
- for (const lang of languages) {
- let shortLang = lang === 'typescript' ? 'ts' : lang;
- const entry = `vs/language/${lang}/monaco.contribution`;
- checkFileExists(entry);
- const workerId = `vs/language/${lang}/${shortLang}Worker`;
- const workerEntry = `vs/language/${lang}/${shortLang}.worker`;
- checkFileExists(workerEntry);
- result.push({
- label: lang,
- entry: entry,
- worker: {
- id: workerId,
- entry: workerEntry
- }
- });
- }
- return result;
- });
-
- function checkFileExists(moduleName) {
- const filePath = path.join(REPO_ROOT, 'out/monaco-editor/esm', `${moduleName}.js`);
- if (!fs.existsSync(filePath)) {
- console.error(`Could not find ${filePath}.`);
- process.exit(1);
- }
- }
-}
-
-export function generateEsmMetadataJsAndDTs() {
- return Promise.all([getBasicLanguages(), getAdvancedLanguages()]).then(
- ([basicLanguages, advancedLanguages]) => {
- basicLanguages.sort((a, b) => strcmp(a.entry, b.entry));
- advancedLanguages.sort((a, b) => strcmp(a.entry, b.entry));
-
- let i = 0,
- len = basicLanguages.length;
- let j = 0,
- lenJ = advancedLanguages.length;
- let languages = [];
- while (i < len || j < lenJ) {
- if (i < len && j < lenJ) {
- if (basicLanguages[i].label === advancedLanguages[j].label) {
- let entry = [];
- entry.push(basicLanguages[i].entry);
- entry.push(advancedLanguages[j].entry);
- languages.push({
- label: basicLanguages[i].label,
- entry: entry,
- worker: advancedLanguages[j].worker
- });
- i++;
- j++;
- } else if (basicLanguages[i].label < advancedLanguages[j].label) {
- languages.push(basicLanguages[i]);
- i++;
- } else {
- languages.push(advancedLanguages[j]);
- j++;
- }
- } else if (i < len) {
- languages.push(basicLanguages[i]);
- i++;
- } else {
- languages.push(advancedLanguages[j]);
- j++;
- }
- }
-
- const features = getFeatures();
-
- const dtsContents = `
-/*!----------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *----------------------------------------------------------------*/
-
-export interface IWorkerDefinition {
- id: string;
- entry: string;
-}
-
-export interface IFeatureDefinition {
- label: string;
- entry: string | string[] | undefined;
- worker?: IWorkerDefinition;
-}
-
-export const features: IFeatureDefinition[];
-
-export const languages: IFeatureDefinition[];
-
-export type EditorLanguage = ${languages.map((el) => `'${el.label}'`).join(' | ')};
-
-export type EditorFeature = ${features.map((el) => `'${el.label}'`).join(' | ')};
-
-export type NegatedEditorFeature = ${features.map((el) => `'!${el.label}'`).join(' | ')};
-
-`;
- const dtsDestination = path.join(REPO_ROOT, 'out/monaco-editor/esm/metadata.d.ts');
- ensureDir(path.dirname(dtsDestination));
- fs.writeFileSync(dtsDestination, dtsContents.replace(/\r\n/g, '\n'));
-
- const jsContents = `
-exports.features = ${JSON.stringify(features, null, ' ')};
-exports.languages = ${JSON.stringify(languages, null, ' ')};
-`;
- const jsDestination = path.join(REPO_ROOT, 'out/monaco-editor/esm/metadata.js');
- ensureDir(path.dirname(jsDestination));
- fs.writeFileSync(jsDestination, jsContents.replace(/\r\n/g, '\n'));
-
- for (const feature of [...features, ...languages]) {
- const entries = [].concat(feature.entry);
- for (const entry of entries) {
- const dtsDestination = path.join(REPO_ROOT, 'out/monaco-editor/esm', entry) + '.d.ts';
- ensureDir(path.dirname(dtsDestination));
- fs.writeFileSync(dtsDestination, 'export {}\n');
- }
- }
- }
- );
-}
-
-function strcmp(a: string, b: string) {
- if (a < b) {
- return -1;
- }
- if (a > b) {
- return 1;
- }
- return 0;
-}
-
-function getFeatures(): { label: string; entry: string | string[] }[] {
- const skipImports = [
- 'vs/editor/browser/widget/codeEditorWidget',
- 'vs/editor/browser/widget/diffEditorWidget',
- 'vs/editor/browser/widget/diffNavigator',
- 'vs/editor/common/standaloneStrings',
- 'vs/editor/contrib/tokenization/tokenization',
- 'vs/editor/editor.all',
- 'vs/base/browser/ui/codicons/codiconStyles',
- 'vs/editor/contrib/gotoSymbol/documentSymbols'
- ];
-
- let features: string[] = [];
- const files =
- fs
- .readFileSync(path.join(REPO_ROOT, 'out/monaco-editor/esm/vs/editor/edcore.main.js'))
- .toString() +
- fs
- .readFileSync(path.join(REPO_ROOT, 'out/monaco-editor/esm/vs/editor/editor.all.js'))
- .toString();
- files.split(/\r\n|\n/).forEach((line) => {
- const m = line.match(/import '([^']+)'/);
- if (m) {
- const tmp = path.posix.join('vs/editor', m[1]).replace(/\.js$/, '');
- if (skipImports.indexOf(tmp) === -1) {
- features.push(tmp);
- }
- }
- });
-
- let result: { label: string; entry: any }[] = features.map((feature) => {
- /** @type {string} */ let label;
- if (customFeatureLabels[feature]) {
- label = customFeatureLabels[feature];
- } else {
- const m1 = feature.match(/^vs\/editor\/contrib\/([^\/]+)/);
- if (m1) {
- // for editor/contrib features, use the first segment
- label = m1[1];
- } else {
- // for everything else, use the last segment folder
- label = path.basename(path.dirname(feature));
- }
- }
- return {
- label: label,
- entry: feature
- };
- });
-
- result.sort((a, b) => {
- const labelCmp = strcmp(a.label, b.label);
- if (labelCmp === 0) {
- return strcmp(a.entry, b.entry);
- }
- return labelCmp;
- });
-
- for (let i = 0; i < result.length; i++) {
- if (i + 1 < result.length && result[i].label === result[i + 1].label) {
- if (typeof result[i].entry === 'string') {
- result[i].entry = [result[i].entry];
- }
- result[i].entry.push(result[i + 1].entry);
- result.splice(i + 1, 1);
- }
- }
-
- return result;
-}
diff --git a/build/shared.mjs b/build/shared.mjs
deleted file mode 100644
index dc471455..00000000
--- a/build/shared.mjs
+++ /dev/null
@@ -1,96 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-// @ts-check
-
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { readdirSync } from 'fs';
-
-/**
- * @param {string} filePath
- * @param {string} newExt
- */
-export function changeExt(filePath, newExt) {
- const idx = filePath.lastIndexOf('.');
- if (idx === -1) {
- return filePath + newExt;
- } else {
- return filePath.substring(0, idx) + newExt;
- }
-}
-
-export function getNlsEntryPoints() {
- const nlsDir = dirname(fileURLToPath(import.meta.resolve('monaco-editor-core/esm/nls.messages.en.js')));
- const nlsFiles = readdirSync(nlsDir)
- .filter(file => file.startsWith('nls.messages.') && file.endsWith('.js'))
- .reduce((acc, file) => {
- // @ts-ignore
- acc[file] = join(nlsDir, file);
- return acc;
- }, {});
- return nlsFiles;
-}
-
-const root = join(import.meta.dirname, '../');
-
-const mappedPaths = {
- [join(root, 'node_modules/monaco-editor-core/esm/')]: '.',
- [join(root, 'node_modules/')]: 'external/',
- [join(root, 'monaco-lsp-client/')]: 'external/monaco-lsp-client/',
- [join(root, 'src/')]: 'vs/',
-};
-
-/**
- * @param {string} moduleId
- * @param {string} newExt (with leading .)
- * @returns {string | undefined}
- */
-export function mapModuleId(moduleId, newExt) {
- for (const [key, val] of Object.entries(mappedPaths)) {
- if (moduleId.startsWith(key)) {
- const relativePath = moduleId.substring(key.length);
- return changeExt(join(val, relativePath), newExt);
- }
- }
- return undefined;
-}
-
-/**
- * @param {(moduleId: string) => boolean} [filter]
- * @return {import('rollup').Plugin}
- */
-export function dtsDeprecationWarning(filter) {
- return {
- name: 'add-dts-deprecation-warning',
- generateBundle(options, bundle) {
- for (const fileName in bundle) {
- if (filter && !filter(fileName)) {
- continue;
- }
- const file = bundle[fileName];
- if (file.type === 'chunk' && fileName.endsWith('.d.ts')) {
- let content = file.code.toString();
- content = content + `
-declare namespace languages {
- /** @deprecated Use the new top level "css" namespace instead. */
- export const css: { deprecated: true };
-
- /** @deprecated Use the new top level "html" namespace instead. */
- export const html: { deprecated: true };
-
- /** @deprecated Use the new top level "json" namespace instead. */
- export const json: { deprecated: true };
-
- /** @deprecated Use the new top level "typescript" namespace instead. */
- export const typescript: { deprecated: true };
-}
-`;
- file.code = content;
- }
- }
- }
- };
-}
diff --git a/build/simpleserver.ts b/build/simpleserver.ts
deleted file mode 100644
index bdfe8e51..00000000
--- a/build/simpleserver.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import fs = require('fs');
-import path = require('path');
-import http = require('http');
-import yaserver = require('yaserver');
-import { REPO_ROOT } from './utils';
-import { ensureDir } from './fs';
-
-generateTestSamplesTask();
-
-const SERVER_ROOT = path.normalize(path.join(REPO_ROOT, '../'));
-createSimpleServer(SERVER_ROOT, 8080);
-createSimpleServer(SERVER_ROOT, 8088);
-
-function generateTestSamplesTask() {
- const sampleNames = fs.readdirSync(path.join(REPO_ROOT, 'test/manual/samples'));
- let samples = sampleNames.map((sampleName) => {
- const samplePath = path.join(REPO_ROOT, 'test/manual/samples', sampleName);
- const sampleContent = fs.readFileSync(samplePath).toString();
- return {
- name: sampleName,
- content: sampleContent
- };
- });
-
- // Add samples from website
- {
- let sampleNames = fs.readdirSync(path.join(REPO_ROOT, 'website/index/samples'));
- sampleNames = sampleNames.filter((name) => /^sample/.test(name));
-
- samples = samples.concat(
- sampleNames.map((sampleName) => {
- const samplePath = path.join(REPO_ROOT, 'website/index/samples', sampleName);
- const sampleContent = fs.readFileSync(samplePath).toString();
- return {
- name: sampleName,
- content: sampleContent
- };
- })
- );
- }
-
- const prefix =
- '//This is a generated file via `npm run simpleserver`\ndefine([], function() { return';
- const suffix = '; });';
-
- const destination = path.join(REPO_ROOT, 'test/manual/generated/all-samples.js');
- ensureDir(path.dirname(destination));
- fs.writeFileSync(destination, prefix + JSON.stringify(samples, null, '\t') + suffix);
-}
-
-function createSimpleServer(rootDir: string, port: number) {
- yaserver
- .createServer({
- rootDir: rootDir
- })
- .then((staticServer) => {
- const server = http.createServer((request, response) => {
- return staticServer.handle(request, response);
- });
- server.listen(port, '127.0.0.1', () => {
- console.log(`Running at http://127.0.0.1:${port}`);
- });
- });
-}
diff --git a/build/tsconfig.json b/build/tsconfig.json
deleted file mode 100644
index 9d84cea7..00000000
--- a/build/tsconfig.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- "compilerOptions": {
- "noEmit": true,
- "module": "CommonJS",
- "esModuleInterop": true
- },
- "include": ["./**/*"]
-}
diff --git a/build/utils.ts b/build/utils.ts
deleted file mode 100644
index 8a11841c..00000000
--- a/build/utils.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as glob from 'glob';
-import { ensureDir } from './fs';
-
-export const REPO_ROOT = path.join(__dirname, '../');
-
-
-export interface IFile {
- path: string;
- contents: Buffer;
-}
-
-export function readFiles(
- pattern: string,
- options: { base: string; ignore?: string[]; dot?: boolean }
-): IFile[] {
- let files = glob.sync(pattern, { cwd: REPO_ROOT, ignore: options.ignore, dot: options.dot });
- // remove dirs
- files = files.filter((file) => {
- const fullPath = path.join(REPO_ROOT, file);
- const stats = fs.statSync(fullPath);
- return stats.isFile();
- });
-
- const base = options.base;
- return files.map((file) => readFile(file, base));
-}
-
-export function readFile(file: string, base: string = '') {
- const baseLength = base === '' ? 0 : base.endsWith('/') ? base.length : base.length + 1;
- const fullPath = path.join(REPO_ROOT, file);
- const contents = fs.readFileSync(fullPath);
- const relativePath = file.substring(baseLength);
- return {
- path: relativePath,
- contents
- };
-}
-
-export function writeFiles(files: IFile[], dest: string) {
- for (const file of files) {
- const fullPath = path.join(REPO_ROOT, dest, file.path);
- ensureDir(path.dirname(fullPath));
- fs.writeFileSync(fullPath, file.contents);
- }
-}
diff --git a/docs/code-structure.dio.svg b/docs/code-structure.dio.svg
deleted file mode 100644
index f4b0abb2..00000000
--- a/docs/code-structure.dio.svg
+++ /dev/null
@@ -1,275 +0,0 @@
-
diff --git a/docs/debugging-core.gif b/docs/debugging-core.gif
deleted file mode 100644
index 37179f6d..00000000
Binary files a/docs/debugging-core.gif and /dev/null differ
diff --git a/docs/debugging-languages.gif b/docs/debugging-languages.gif
deleted file mode 100644
index 73c0d6d4..00000000
Binary files a/docs/debugging-languages.gif and /dev/null differ
diff --git a/docs/integrate-amd-cross.md b/docs/integrate-amd-cross.md
new file mode 100644
index 00000000..5dd315b5
--- /dev/null
+++ b/docs/integrate-amd-cross.md
@@ -0,0 +1,78 @@
+## Integrating the AMD version of the Monaco Editor in a cross-domain setup
+
+Here is the most basic HTML page that embeds the editor, using AMD, in the case that the editor sources are hosted on a different domain (e.g. CDN) than the document origin.
+
+More self-contained samples are available at [monaco-editor-samples](https://github.com/Microsoft/monaco-editor-samples).
+
+If you are hosting your `.js` on a different domain (e.g. on a CDN) than the HTML, you should know that the Monaco Editor creates web workers for smart language features. Cross-domain web workers are not allowed, but here is how you can proxy their loading and get them to work:
+
+Assuming the HTML lives on `www.mydomain.com` and the editor is hosted on `www.mycdn.com`.
+
+----
+
+# Option 1: Use a data: worker URI
+
+* `https://www.mydomain.com/index.html`:
+```html
+
+
+```
+
+----
+
+# Option 2: Host on your domain a worker proxy
+
+* `https://www.mydomain.com/index.html`:
+```html
+
+
+```
+
+* `https://www.mydomain.com/monaco-editor-worker-loader-proxy.js`:
+```js
+self.MonacoEnvironment = {
+ baseUrl: 'http://www.mycdn.com/monaco-editor/min/'
+};
+importScripts('www.mycdn.com/monaco-editor/min/vs/base/worker/workerMain.js');
+```
+
+----
+
+That's it. You're good to go! :)
\ No newline at end of file
diff --git a/docs/integrate-amd.md b/docs/integrate-amd.md
new file mode 100644
index 00000000..05103536
--- /dev/null
+++ b/docs/integrate-amd.md
@@ -0,0 +1,34 @@
+## Integrating the AMD version of the Monaco Editor
+
+Here is the most basic HTML page that embeds the editor using AMD.
+
+More self-contained samples are available at [monaco-editor-samples](https://github.com/Microsoft/monaco-editor-samples).
+
+```html
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
\ No newline at end of file
diff --git a/docs/integrate-esm.md b/docs/integrate-esm.md
index d4b11cc9..9eabb54d 100644
--- a/docs/integrate-esm.md
+++ b/docs/integrate-esm.md
@@ -1,59 +1,51 @@
## Integrating the ESM version of the Monaco Editor
-- [Webpack](#using-webpack)
- - [Option 1: Using the Monaco Editor WebPack Plugin](#option-1-using-the-monaco-editor-webpack-plugin)
- - [Option 2: Using plain webpack](#option-2-using-plain-webpack)
-- [Parcel](#using-parcel)
-- [Vite](#using-vite)
-
### Using webpack
Here is the most basic script that imports the editor using ESM with webpack.
-More self-contained samples are available in the [samples folder](../samples/).
+More self-contained samples are available at [monaco-editor-samples](https://github.com/Microsoft/monaco-editor-samples).
---
-### Option 1: Using the Monaco Editor WebPack Plugin
+### Option 1: Using the Monaco Editor Loader Plugin
-This is the easiest method, and it allows for options to be passed into the plugin in order to select only a subset of editor features or editor languages. Read more about the [Monaco Editor WebPack Plugin](../webpack-plugin/), which is a community authored plugin.
-
-- `index.js`
+This is the easiest method, and it allows for options to be passed in to the plugin in order to select only a subset of editor features or editor languages. Read more about the [Monaco Editor Loader Plugin](https://github.com/Microsoft/monaco-editor-webpack-plugin), which is a community authored plugin.
+* `index.js`
```js
import * as monaco from 'monaco-editor';
monaco.editor.create(document.getElementById('container'), {
- value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
- language: 'javascript'
+ value: [
+ 'function x() {',
+ '\tconsole.log("Hello world!");',
+ '}'
+ ].join('\n'),
+ language: 'javascript'
});
```
-- `webpack.config.js`
-
+* `webpack.config.js`
```js
const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin');
const path = require('path');
module.exports = {
- entry: './index.js',
- output: {
- path: path.resolve(__dirname, 'dist'),
- filename: 'app.js'
- },
- module: {
- rules: [
- {
- test: /\.css$/,
- use: ['style-loader', 'css-loader']
- },
- {
- test: /\.ttf$/,
- use: ['file-loader']
- }
- ]
- },
- plugins: [new MonacoWebpackPlugin()]
+ entry: './index.js',
+ output: {
+ path: path.resolve(__dirname, 'dist'),
+ filename: 'app.js'
+ },
+ module: {
+ rules: [{
+ test: /\.css$/,
+ use: ['style-loader', 'css-loader']
+ }]
+ },
+ plugins: [
+ new MonacoWebpackPlugin()
+ ]
};
```
@@ -61,10 +53,7 @@ module.exports = {
### Option 2: Using plain webpack
-Full working samples are available at https://github.com/microsoft/monaco-editor/tree/main/samples/browser-esm-webpack or https://github.com/microsoft/monaco-editor/tree/main/samples/browser-esm-webpack-small
-
-- `index.js`
-
+* `index.js`
```js
import * as monaco from 'monaco-editor';
@@ -72,158 +61,57 @@ import * as monaco from 'monaco-editor';
// to instruct the editor how you named the
// bundles that contain the web workers.
self.MonacoEnvironment = {
- getWorkerUrl: function (moduleId, label) {
- if (label === 'json') {
- return './json.worker.bundle.js';
- }
- if (label === 'css' || label === 'scss' || label === 'less') {
- return './css.worker.bundle.js';
- }
- if (label === 'html' || label === 'handlebars' || label === 'razor') {
- return './html.worker.bundle.js';
- }
- if (label === 'typescript' || label === 'javascript') {
- return './ts.worker.bundle.js';
- }
- return './editor.worker.bundle.js';
- }
-};
+ getWorkerUrl: function (moduleId, label) {
+ if (label === 'json') {
+ return './json.worker.bundle.js';
+ }
+ if (label === 'css') {
+ return './css.worker.bundle.js';
+ }
+ if (label === 'html') {
+ return './html.worker.bundle.js';
+ }
+ if (label === 'typescript' || label === 'javascript') {
+ return './ts.worker.bundle.js';
+ }
+ return './editor.worker.bundle.js';
+ }
+}
monaco.editor.create(document.getElementById('container'), {
- value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
- language: 'javascript'
+ value: [
+ 'function x() {',
+ '\tconsole.log("Hello world!");',
+ '}'
+ ].join('\n'),
+ language: 'javascript'
});
```
-- `webpack.config.js`:
-
+* `webpack.config.js`:
```js
const path = require('path');
module.exports = {
- entry: {
- app: './index.js',
- // Package each language's worker and give these filenames in `getWorkerUrl`
- 'editor.worker': 'monaco-editor/esm/vs/editor/editor.worker.js',
- 'json.worker': 'monaco-editor/esm/vs/language/json/json.worker',
- 'css.worker': 'monaco-editor/esm/vs/language/css/css.worker',
- 'html.worker': 'monaco-editor/esm/vs/language/html/html.worker',
- 'ts.worker': 'monaco-editor/esm/vs/language/typescript/ts.worker'
- },
- output: {
- globalObject: 'self',
- filename: '[name].bundle.js',
- path: path.resolve(__dirname, 'dist')
- },
- module: {
- rules: [
- {
- test: /\.css$/,
- use: ['style-loader', 'css-loader']
- },
- {
- test: /\.ttf$/,
- use: ['file-loader']
- }
- ]
- }
+ entry: {
+ "app": './index.js',
+ // Package each language's worker and give these filenames in `getWorkerUrl`
+ "editor.worker": 'monaco-editor/esm/vs/editor/editor.worker.js',
+ "json.worker": 'monaco-editor/esm/vs/language/json/json.worker',
+ "css.worker": 'monaco-editor/esm/vs/language/css/css.worker',
+ "html.worker": 'monaco-editor/esm/vs/language/html/html.worker',
+ "ts.worker": 'monaco-editor/esm/vs/language/typescript/ts.worker',
+ },
+ output: {
+ globalObject: 'self',
+ filename: '[name].bundle.js',
+ path: path.resolve(__dirname, 'dist')
+ },
+ module: {
+ rules: [{
+ test: /\.css$/,
+ use: ['style-loader', 'css-loader']
+ }]
+ }
};
```
-
----
-
-### Using parcel
-
-A full working sample is available at https://github.com/microsoft/monaco-editor/tree/main/samples/browser-esm-parcel
-
-When using parcel, we need to use the `getWorkerUrl` function and build the workers seperately from our main source. To simplify things, we can write a tiny bash script to build the workers for us.
-
-- `index.js`
-
-```js
-import * as monaco from 'monaco-editor';
-
-self.MonacoEnvironment = {
- getWorkerUrl: function (moduleId, label) {
- if (label === 'json') {
- return './json.worker.js';
- }
- if (label === 'css' || label === 'scss' || label === 'less') {
- return './css.worker.js';
- }
- if (label === 'html' || label === 'handlebars' || label === 'razor') {
- return './html.worker.js';
- }
- if (label === 'typescript' || label === 'javascript') {
- return './ts.worker.js';
- }
- return './editor.worker.js';
- }
-};
-
-monaco.editor.create(document.getElementById('container'), {
- value: ['function x() {', '\tconsole.log("Hello world!");', '}'].join('\n'),
- language: 'javascript'
-});
-```
-
-- `build_workers.sh`
-
-```sh
-ROOT=$PWD/node_modules/monaco-editor/esm/vs
-OPTS="--no-source-maps --log-level 1" # Parcel options - See: https://parceljs.org/cli.html
-
-parcel build $ROOT/language/json/json.worker.js $OPTS
-parcel build $ROOT/language/css/css.worker.js $OPTS
-parcel build $ROOT/language/html/html.worker.js $OPTS
-parcel build $ROOT/language/typescript/ts.worker.js $OPTS
-parcel build $ROOT/editor/editor.worker.js $OPTS
-```
-
-Then, simply run `sh ./build_workers.sh && parcel index.html`. This builds the workers into the same directory as your main bundle (usually `./dist`). If you want to change the `--out-dir` of the workers, you must change the paths in `index.js` to reflect their new location.
-
-_note - the `getWorkerUrl` paths are relative to the build directory of your src bundle_
-
----
-
-### Using Vite
-
-Adding monaco editor to [Vite](https://vitejs.dev/) is simple since it has built-in support for web workers. You only need to implement the `getWorker` function (NOT the `getWorkerUrl`) to use Vite's output ([Source](https://github.com/vitejs/vite/discussions/1791#discussioncomment-321046)):
-
-```js
-import * as monaco from 'monaco-editor';
-
-self.MonacoEnvironment = {
- getWorker: function (workerId, label) {
- const getWorkerModule = (moduleUrl, label) => {
- return new Worker(self.MonacoEnvironment.getWorkerUrl(moduleUrl), {
- name: label,
- type: 'module'
- });
- };
-
- switch (label) {
- case 'json':
- return getWorkerModule('/monaco-editor/esm/vs/language/json/json.worker?worker', label);
- case 'css':
- case 'scss':
- case 'less':
- return getWorkerModule('/monaco-editor/esm/vs/language/css/css.worker?worker', label);
- case 'html':
- case 'handlebars':
- case 'razor':
- return getWorkerModule('/monaco-editor/esm/vs/language/html/html.worker?worker', label);
- case 'typescript':
- case 'javascript':
- return getWorkerModule('/monaco-editor/esm/vs/language/typescript/ts.worker?worker', label);
- default:
- return getWorkerModule('/monaco-editor/esm/vs/editor/editor.worker?worker', label);
- }
- }
-};
-
-monaco.editor.create(document.getElementById('container'), {
- value: "function hello() {\n\talert('Hello world!');\n}",
- language: 'javascript'
-});
-```
diff --git a/docs/launch config.png b/docs/launch config.png
deleted file mode 100644
index d39e0b15..00000000
Binary files a/docs/launch config.png and /dev/null differ
diff --git a/docs/out-folders.dio.svg b/docs/out-folders.dio.svg
deleted file mode 100644
index 81022ce4..00000000
--- a/docs/out-folders.dio.svg
+++ /dev/null
@@ -1,347 +0,0 @@
-
diff --git a/editor.code-workspace b/editor.code-workspace
deleted file mode 100644
index 18ac4963..00000000
--- a/editor.code-workspace
+++ /dev/null
@@ -1,13 +0,0 @@
-{
- "folders": [
- {
- "path": "../vscode"
- },
- {
- "path": "../vscode-loc"
- },
- {
- "path": "."
- }
- ]
-}
diff --git a/gulpfile.js b/gulpfile.js
index b59b7b03..8de3e2fe 100644
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -1,9 +1,781 @@
-const gulp = require('gulp');
-const es = require('event-stream');
-const path = require('path');
-const fs = require('fs');
-const rimraf = require('rimraf');
-const cp = require('child_process');
-const CleanCSS = require('clean-css');
-const uncss = require('uncss');
-const File = require('vinyl');
+
+const gulp = require('gulp');
+const metadata = require('./metadata');
+const es = require('event-stream');
+const path = require('path');
+const fs = require('fs');
+const rimraf = require('rimraf');
+const cp = require('child_process');
+const os = require('os');
+const httpServer = require('http-server');
+const typedoc = require("gulp-typedoc");
+const CleanCSS = require('clean-css');
+const uncss = require('uncss');
+const File = require('vinyl');
+const ts = require('typescript');
+
+const WEBSITE_GENERATED_PATH = path.join(__dirname, 'website/playground/new-samples');
+const MONACO_EDITOR_VERSION = (function() {
+ const packageJsonPath = path.join(__dirname, 'package.json');
+ const packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString());
+ const version = packageJson.version;
+ if (!/\d+\.\d+\.\d+/.test(version)) {
+ console.log('unrecognized package.json version: ' + version);
+ process.exit(0);
+ }
+ return version;
+})();
+
+gulp.task('clean-release', function(cb) { rimraf('release', { maxBusyTries: 1 }, cb); });
+gulp.task('release', ['clean-release'], function() {
+ return es.merge(
+
+ // dev folder
+ releaseOne('dev'),
+
+ // min folder
+ releaseOne('min'),
+
+ // esm folder
+ ESM_release(),
+
+ // package.json
+ gulp.src('package.json')
+ .pipe(es.through(function(data) {
+ var json = JSON.parse(data.contents.toString());
+ json.private = false;
+ data.contents = new Buffer(JSON.stringify(json, null, ' '));
+ this.emit('data', data);
+ }))
+ .pipe(gulp.dest('release')),
+
+ gulp.src('CHANGELOG.md')
+ .pipe(gulp.dest('release')),
+
+ // min-maps folder
+ gulp.src('node_modules/monaco-editor-core/min-maps/**/*').pipe(gulp.dest('release/min-maps')),
+
+ // other files
+ gulp.src([
+ 'node_modules/monaco-editor-core/LICENSE',
+ 'node_modules/monaco-editor-core/monaco.d.ts',
+ 'node_modules/monaco-editor-core/ThirdPartyNotices.txt',
+ 'README.md'
+ ])
+ .pipe(addPluginDTS())
+ .pipe(addPluginThirdPartyNotices())
+ .pipe(gulp.dest('release'))
+ )
+});
+
+/**
+ * Release to `dev` or `min`.
+ */
+function releaseOne(type) {
+ return es.merge(
+ gulp.src('node_modules/monaco-editor-core/' + type + '/**/*')
+ .pipe(addPluginContribs(type))
+ .pipe(gulp.dest('release/' + type)),
+ pluginStreams(type, 'release/' + type + '/')
+ )
+}
+
+/**
+ * Release plugins to `dev` or `min`.
+ */
+function pluginStreams(type, destinationPath) {
+ return es.merge(
+ metadata.METADATA.PLUGINS.map(function(plugin) {
+ return pluginStream(plugin, type, destinationPath);
+ })
+ );
+}
+
+/**
+ * Release a plugin to `dev` or `min`.
+ */
+function pluginStream(plugin, type, destinationPath) {
+ var pluginPath = plugin.paths[`npm/${type}`]; // npm/dev or npm/min
+ var contribPath = path.join(pluginPath, plugin.contrib.substr(plugin.modulePrefix.length)) + '.js';
+ return (
+ gulp.src([
+ pluginPath + '/**/*',
+ '!' + contribPath
+ ])
+ .pipe(es.through(function(data) {
+ if (!/_\.contribution/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+
+ let contents = data.contents.toString();
+ contents = contents.replace('define(["require", "exports"],', 'define(["require", "exports", "vs/editor/editor.api"],');
+ data.contents = new Buffer(contents);
+ this.emit('data', data);
+ }))
+ .pipe(gulp.dest(destinationPath + plugin.modulePrefix))
+ );
+}
+
+/**
+ * Edit editor.main.js:
+ * - rename the AMD module 'vs/editor/editor.main' to 'vs/editor/edcore.main'
+ * - append monaco.contribution modules from plugins
+ * - append new AMD module 'vs/editor/editor.main' that stiches things together
+ */
+function addPluginContribs(type) {
+ return es.through(function(data) {
+ if (!/editor\.main\.js$/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+ var contents = data.contents.toString();
+
+ // Rename the AMD module 'vs/editor/editor.main' to 'vs/editor/edcore.main'
+ contents = contents.replace(/"vs\/editor\/editor\.main\"/, '"vs/editor/edcore.main"');
+
+ var extraContent = [];
+ var allPluginsModuleIds = [];
+
+ metadata.METADATA.PLUGINS.forEach(function(plugin) {
+ allPluginsModuleIds.push(plugin.contrib);
+ var pluginPath = plugin.paths[`npm/${type}`]; // npm/dev or npm/min
+ var contribPath = path.join(__dirname, pluginPath, plugin.contrib.substr(plugin.modulePrefix.length)) + '.js';
+ var contribContents = fs.readFileSync(contribPath).toString();
+
+ // Check for the anonymous define call case 1
+ // transform define(function() {...}) to define("moduleId",["require"],function() {...})
+ var anonymousContribDefineCase1 = contribContents.indexOf('define(function');
+ if (anonymousContribDefineCase1 >= 0) {
+ contribContents = (
+ contribContents.substring(0, anonymousContribDefineCase1)
+ + `define("${plugin.contrib}",["require"],function`
+ + contribContents.substring(anonymousContribDefineCase1 + 'define(function'.length)
+ );
+ }
+
+ // Check for the anonymous define call case 2
+ // transform define([ to define("moduleId",[
+ var anonymousContribDefineCase2 = contribContents.indexOf('define([');
+ if (anonymousContribDefineCase2 >= 0) {
+ contribContents = (
+ contribContents.substring(0, anonymousContribDefineCase2)
+ + `define("${plugin.contrib}",[`
+ + contribContents.substring(anonymousContribDefineCase2 + 'define(['.length)
+ );
+ }
+
+ var contribDefineIndex = contribContents.indexOf('define("' + plugin.contrib);
+ if (contribDefineIndex === -1) {
+ contribDefineIndex = contribContents.indexOf('define(\'' + plugin.contrib);
+ if (contribDefineIndex === -1) {
+ console.error('(1) CANNOT DETERMINE AMD define location for contribution', pluginPath);
+ process.exit(-1);
+ }
+ }
+
+ var depsEndIndex = contribContents.indexOf(']', contribDefineIndex);
+ if (contribDefineIndex === -1) {
+ console.error('(2) CANNOT DETERMINE AMD define location for contribution', pluginPath);
+ process.exit(-1);
+ }
+
+ contribContents = contribContents.substring(0, depsEndIndex) + ',"vs/editor/editor.api"' + contribContents.substring(depsEndIndex);
+
+ contribContents = contribContents.replace(
+ 'define("vs/basic-languages/_.contribution",["require","exports"],',
+ 'define("vs/basic-languages/_.contribution",["require","exports","vs/editor/editor.api"],',
+ );
+
+ extraContent.push(contribContents);
+ });
+
+ extraContent.push(`define("vs/editor/editor.main", ["vs/editor/edcore.main","${allPluginsModuleIds.join('","')}"], function(api) { return api; });`);
+ var insertIndex = contents.lastIndexOf('//# sourceMappingURL=');
+ if (insertIndex === -1) {
+ insertIndex = contents.length;
+ }
+ contents = contents.substring(0, insertIndex) + '\n' + extraContent.join('\n') + '\n' + contents.substring(insertIndex);
+
+ data.contents = new Buffer(contents);
+ this.emit('data', data);
+ });
+}
+
+function ESM_release() {
+ return es.merge(
+ gulp.src([
+ 'node_modules/monaco-editor-core/esm/**/*',
+ // we will create our own editor.api.d.ts which also contains the plugins API
+ '!node_modules/monaco-editor-core/esm/vs/editor/editor.api.d.ts'
+ ])
+ .pipe(ESM_addImportSuffix())
+ .pipe(ESM_addPluginContribs('release/esm'))
+ .pipe(gulp.dest('release/esm')),
+ ESM_pluginStreams('release/esm/')
+ )
+}
+
+/**
+ * Release plugins to `esm`.
+ */
+function ESM_pluginStreams(destinationPath) {
+ return es.merge(
+ metadata.METADATA.PLUGINS.map(function(plugin) {
+ return ESM_pluginStream(plugin, destinationPath);
+ })
+ );
+}
+
+/**
+ * Release a plugin to `esm`.
+ * Adds a dependency to 'vs/editor/editor.api' in contrib files in order for `monaco` to be defined.
+ * Rewrites imports for 'monaco-editor-core/**'
+ */
+function ESM_pluginStream(plugin, destinationPath) {
+ const DESTINATION = path.join(__dirname, destinationPath);
+ let pluginPath = plugin.paths[`esm`];
+ return (
+ gulp.src([
+ pluginPath + '/**/*'
+ ])
+ .pipe(es.through(function(data) {
+ if (!/\.js$/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+
+ let contents = data.contents.toString();
+
+ const info = ts.preProcessFile(contents);
+ for (let i = info.importedFiles.length - 1; i >= 0; i--) {
+ const importText = info.importedFiles[i].fileName;
+ const pos = info.importedFiles[i].pos;
+ const end = info.importedFiles[i].end;
+
+ if (!/(^\.\/)|(^\.\.\/)/.test(importText)) {
+ // non-relative import
+ if (!/^monaco-editor-core/.test(importText)) {
+ console.error(`Non-relative import for unknown module: ${importText} in ${data.path}`);
+ process.exit(0);
+ }
+
+ const myFileDestPath = path.join(DESTINATION, plugin.modulePrefix, data.relative);
+ const importFilePath = path.join(DESTINATION, importText.substr('monaco-editor-core/esm/'.length));
+ let relativePath = path.relative(path.dirname(myFileDestPath), importFilePath);
+ if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
+ relativePath = './' + relativePath;
+ }
+
+ contents = (
+ contents.substring(0, pos + 1)
+ + relativePath
+ + contents.substring(end + 1)
+ );
+ }
+ }
+
+ data.contents = new Buffer(contents);
+ this.emit('data', data);
+ }))
+ .pipe(es.through(function(data) {
+ if (!/monaco\.contribution\.js$/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+
+ const myFileDestPath = path.join(DESTINATION, plugin.modulePrefix, data.relative);
+ const apiFilePath = path.join(DESTINATION, 'vs/editor/editor.api');
+ let relativePath = path.relative(path.dirname(myFileDestPath), apiFilePath);
+ if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
+ relativePath = './' + relativePath;
+ }
+
+ let contents = data.contents.toString();
+ contents = (
+ `import '${relativePath}';\n` +
+ contents
+ );
+
+ data.contents = new Buffer(contents);
+
+ this.emit('data', data);
+ }))
+ .pipe(ESM_addImportSuffix())
+ .pipe(gulp.dest(destinationPath + plugin.modulePrefix))
+ );
+}
+
+function ESM_addImportSuffix() {
+ return es.through(function(data) {
+ if (!/\.js$/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+
+ let contents = data.contents.toString();
+
+ const info = ts.preProcessFile(contents);
+ for (let i = info.importedFiles.length - 1; i >= 0; i--) {
+ const importText = info.importedFiles[i].fileName;
+ const pos = info.importedFiles[i].pos;
+ const end = info.importedFiles[i].end;
+
+ if (/\.css$/.test(importText)) {
+ continue;
+ }
+
+ contents = (
+ contents.substring(0, pos + 1)
+ + importText + '.js'
+ + contents.substring(end + 1)
+ );
+ }
+
+ data.contents = new Buffer(contents);
+ this.emit('data', data);
+ });
+}
+
+/**
+ * - Rename esm/vs/editor/editor.main.js to esm/vs/editor/edcore.main.js
+ * - Create esm/vs/editor/editor.main.js that that stiches things together
+ */
+function ESM_addPluginContribs(dest) {
+ const DESTINATION = path.join(__dirname, dest);
+ return es.through(function(data) {
+ if (!/editor\.main\.js$/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+
+ this.emit('data', new File({
+ path: data.path.replace(/editor\.main/, 'edcore.main'),
+ base: data.base,
+ contents: data.contents
+ }));
+
+ const mainFileDestPath = path.join(DESTINATION, 'vs/editor/editor.main.js');
+ let mainFileImports = [];
+ metadata.METADATA.PLUGINS.forEach(function(plugin) {
+ const contribDestPath = path.join(DESTINATION, plugin.contrib);
+
+ let relativePath = path.relative(path.dirname(mainFileDestPath), contribDestPath);
+ if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
+ relativePath = './' + relativePath;
+ }
+
+ mainFileImports.push(relativePath);
+ });
+
+ let mainFileContents = (
+ mainFileImports.map((name) => `import '${name}';`).join('\n')
+ + `\n\nexport * from './edcore.main';`
+ );
+
+ this.emit('data', new File({
+ path: data.path,
+ base: data.base,
+ contents: new Buffer(mainFileContents)
+ }));
+ });
+}
+
+/**
+ * Edit monaco.d.ts:
+ * - append monaco.d.ts from plugins
+ */
+function addPluginDTS() {
+ return es.through(function(data) {
+ if (!/monaco\.d\.ts$/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+ var contents = data.contents.toString();
+
+ var extraContent = [];
+ metadata.METADATA.PLUGINS.forEach(function(plugin) {
+ var pluginPath = plugin.paths[`npm/min`]; // npm/dev or npm/min
+ var dtsPath = path.join(pluginPath, '../monaco.d.ts');
+ try {
+ let plugindts = fs.readFileSync(dtsPath).toString();
+ plugindts = plugindts.replace('declare module', 'declare namespace');
+ extraContent.push(plugindts);
+ } catch (err) {
+ return;
+ }
+ });
+
+ contents = [
+ '/*!-----------------------------------------------------------',
+ ' * Copyright (c) Microsoft Corporation. All rights reserved.',
+ ' * Type definitions for monaco-editor v'+MONACO_EDITOR_VERSION,
+ ' * Released under the MIT license',
+ '*-----------------------------------------------------------*/',
+ ].join('\n') + '\n' + contents + '\n' + extraContent.join('\n');
+
+ // Ensure consistent indentation and line endings
+ contents = cleanFile(contents);
+
+ data.contents = new Buffer(contents);
+
+ this.emit('data', new File({
+ path: path.join(path.dirname(data.path), 'esm/vs/editor/editor.api.d.ts'),
+ base: data.base,
+ contents: new Buffer(toExternalDTS(contents))
+ }));
+
+ fs.writeFileSync('website/playground/monaco.d.ts.txt', contents);
+ fs.writeFileSync('monaco.d.ts', contents);
+ this.emit('data', data);
+ });
+}
+
+function toExternalDTS(contents) {
+ let lines = contents.split('\n');
+ let killNextCloseCurlyBrace = false;
+ for (let i = 0; i < lines.length; i++) {
+ let line = lines[i];
+
+ if (killNextCloseCurlyBrace) {
+ if ('}' === line) {
+ lines[i] = '';
+ killNextCloseCurlyBrace = false;
+ continue;
+ }
+
+ if (line.indexOf(' ') === 0) {
+ lines[i] = line.substr(4);
+ } else if (line.charAt(0) === '\t') {
+ lines[i] = line.substr(1);
+ }
+
+ continue;
+ }
+
+ if ('declare namespace monaco {' === line) {
+ lines[i] = '';
+ killNextCloseCurlyBrace = true;
+ continue;
+ }
+
+ if (line.indexOf('declare namespace monaco.') === 0) {
+ lines[i] = line.replace('declare namespace monaco.', 'export namespace ');
+ }
+ }
+ return lines.join('\n');
+}
+
+/**
+ * Normalize line endings and ensure consistent 4 spaces indentation
+ */
+function cleanFile(contents) {
+ return contents.split(/\r\n|\r|\n/).map(function(line) {
+ var m = line.match(/^(\t+)/);
+ if (!m) {
+ return line;
+ }
+ var tabsCount = m[1].length;
+ var newIndent = '';
+ for (var i = 0; i < 4 * tabsCount; i++) {
+ newIndent += ' ';
+ }
+ return newIndent + line.substring(tabsCount);
+ }).join('\n');
+}
+
+/**
+ * Edit ThirdPartyNotices.txt:
+ * - append ThirdPartyNotices.txt from plugins
+ */
+function addPluginThirdPartyNotices() {
+ return es.through(function(data) {
+ if (!/ThirdPartyNotices\.txt$/.test(data.path)) {
+ this.emit('data', data);
+ return;
+ }
+ var contents = data.contents.toString();
+
+ var extraContent = [];
+ metadata.METADATA.PLUGINS.forEach(function(plugin) {
+ if (!plugin.thirdPartyNotices) {
+ return;
+ }
+
+ console.log('ADDING ThirdPartyNotices from ' + plugin.thirdPartyNotices);
+ var thirdPartyNoticeContent = fs.readFileSync(plugin.thirdPartyNotices).toString();
+ thirdPartyNoticeContent = thirdPartyNoticeContent.split('\n').slice(8).join('\n');
+ extraContent.push(thirdPartyNoticeContent);
+ });
+
+ contents += '\n' + extraContent.join('\n');
+ data.contents = new Buffer(contents);
+
+ this.emit('data', data);
+ });
+}
+
+
+// --- website
+
+gulp.task('clean-website', function(cb) { rimraf('../monaco-editor-website', { maxBusyTries: 1 }, cb); });
+gulp.task('website', ['clean-website'], function() {
+
+ const initialCWD = process.cwd();
+
+ function replaceWithRelativeResource(dataPath, contents, regex, callback) {
+ return contents.replace(regex, function(_, m0) {
+ var filePath = path.join(path.dirname(dataPath), m0);
+ return callback(m0, fs.readFileSync(filePath));
+ });
+ }
+
+ var waiting = 0;
+ var done = false;
+
+ return (
+ es.merge(
+ gulp.src([
+ 'website/**/*',
+ '!website/typedoc-theme/**'
+ ], { dot: true })
+ .pipe(es.through(function(data) {
+ if (!data.contents || !/\.(html)$/.test(data.path) || /new-samples/.test(data.path)) {
+ return this.emit('data', data);
+ }
+
+ var contents = data.contents.toString();
+ contents = contents.replace(/\.\.\/release\/dev/g, 'node_modules/monaco-editor/min');
+ contents = contents.replace(/{{version}}/g, MONACO_EDITOR_VERSION);
+ // contents = contents.replace('© 2017 Microsoft', '© 2017 Microsoft [' + builtTime + ']');
+
+ // Preload xhr contents
+ contents = replaceWithRelativeResource(data.path, contents, /'
+ + fileContents.toString('utf8')
+ .replace(/&/g, '&')
+ .replace(//g, '>')
+ + ''
+ );
+ });
+
+ // Inline fork.png
+ contents = replaceWithRelativeResource(data.path, contents, /src="(\.\/fork.png)"/g, function(m0, fileContents) {
+ return (
+ 'src="data:image/png;base64,' + fileContents.toString('base64') + '"'
+ );
+ });
+
+ var allCSS = '';
+ var tmpcontents = replaceWithRelativeResource(data.path, contents, /' + output + '';
+ }
+ return '';
+ });
+ }
+
+ // Inline javascript
+ contents = replaceWithRelativeResource(data.path, contents, /';
+ });
+
+ data.contents = new Buffer(contents.split(/\r\n|\r|\n/).join('\n'));
+ this.emit('data', data);
+
+ if (done && waiting === 0) {
+ this.emit('end');
+ }
+ }.bind(this));
+
+ }, function() {
+ done = true;
+ if (waiting === 0) {
+ this.emit('end');
+ }
+ }))
+ .pipe(gulp.dest('../monaco-editor-website')),
+
+ // TypeDoc is silly and consumes the `exclude` option.
+ // This option does not make it to typescript compiler, which ends up including /node_modules/ .d.ts files.
+ // We work around this by changing the cwd... :O
+
+ gulp.src('monaco.d.ts')
+ .pipe(es.through(undefined, function() {
+ process.chdir(os.tmpdir());
+ this.emit('end');
+ }))
+ .pipe(typedoc({
+ mode: 'file',
+ out: path.join(__dirname, '../monaco-editor-website/api'),
+ includeDeclarations: true,
+ theme: path.join(__dirname, 'website/typedoc-theme'),
+ entryPoint: 'monaco',
+ name: 'Monaco Editor API v' + MONACO_EDITOR_VERSION,
+ readme: 'none',
+ hideGenerator: true
+ }))
+ .pipe(es.through(undefined, function() {
+ process.chdir(initialCWD);
+ this.emit('end');
+ }))
+ )
+
+ .pipe(es.through(function(data) {
+ this.emit('data', data);
+ }, function() {
+
+ // temporarily create package.json so that npm install doesn't bark
+ fs.writeFileSync('../monaco-editor-website/package.json', '{}');
+ fs.writeFileSync('../monaco-editor-website/.nojekyll', '');
+ cp.execSync('npm install monaco-editor', {
+ cwd: path.join(__dirname, '../monaco-editor-website')
+ });
+ fs.unlink('../monaco-editor-website/package.json');
+
+ cp.execSync('git init', {
+ cwd: path.join(__dirname, '../monaco-editor-website')
+ });
+ cp.execSync('git remote add origin https://github.com/Microsoft/monaco-editor.git', {
+ cwd: path.join(__dirname, '../monaco-editor-website')
+ });
+ cp.execSync('git checkout -b gh-pages', {
+ cwd: path.join(__dirname, '../monaco-editor-website')
+ });
+ cp.execSync('git add .', {
+ cwd: path.join(__dirname, '../monaco-editor-website')
+ });
+ cp.execSync('git commit -m "Publish website"', {
+ cwd: path.join(__dirname, '../monaco-editor-website')
+ });
+ console.log('RUN monaco-editor-website>git push origin gh-pages --force')
+ this.emit('end');
+ }))
+ );
+
+});
+
+gulp.task('generate-test-samples', function() {
+ var sampleNames = fs.readdirSync(path.join(__dirname, 'test/samples'));
+ var samples = sampleNames.map(function(sampleName) {
+ var samplePath = path.join(__dirname, 'test/samples', sampleName);
+ var sampleContent = fs.readFileSync(samplePath).toString();
+ return {
+ name: sampleName,
+ content: sampleContent
+ };
+ });
+ var prefix = '//This is a generated file via gulp generate-test-samples\ndefine([], function() { return';
+ var suffix = '; });'
+ fs.writeFileSync(path.join(__dirname, 'test/samples-all.generated.js'), prefix + JSON.stringify(samples, null, '\t') + suffix );
+
+ var PLAY_SAMPLES = require(path.join(WEBSITE_GENERATED_PATH, 'all.js')).PLAY_SAMPLES;
+ var locations = [];
+ for (var i = 0; i < PLAY_SAMPLES.length; i++) {
+ var sample = PLAY_SAMPLES[i];
+ var sampleId = sample.id;
+ var samplePath = path.join(WEBSITE_GENERATED_PATH, sample.path);
+
+ var html = fs.readFileSync(path.join(samplePath, 'sample.html'));
+ var js = fs.readFileSync(path.join(samplePath, 'sample.js'));
+ var css = fs.readFileSync(path.join(samplePath, 'sample.css'));
+
+ var result = [
+ '',
+ '',
+ '',
+ '',
+ ' ',
+ ' ',
+ ' ',
+ '',
+ '',
+ '',
+ '[<< BACK]
',
+ 'THIS IS A GENERATED FILE VIA gulp generate-test-samples',
+ '',
+ '',
+ '',
+ '',
+ '',
+ '',
+ '',
+ html,
+ '',
+ '',
+ '
',
+ '',
+ '',
+ '',
+ '',
+ '',
+ '',
+ '',
+ ];
+ fs.writeFileSync(path.join(__dirname, 'test/playground.generated/' + sampleId + '.html'), result.join('\n'));
+ locations.push({
+ path: sampleId + '.html',
+ name: sample.chapter + ' > ' + sample.name
+ })
+ }
+
+ var index = [
+ '',
+ '',
+ '',
+ '',
+ ' ',
+ '',
+ '',
+ '[<< BACK]
',
+ 'THIS IS A GENERATED FILE VIA gulp generate-test-samples
',
+ locations.map(function(location) {
+ return '' + location.name + '';
+ }).join('
\n'),
+ '',
+ '',
+ '',
+ '',
+ ]
+ fs.writeFileSync(path.join(__dirname, 'test/playground.generated/index.html'), index.join('\n'));
+});
+
+gulp.task('simpleserver', ['generate-test-samples'], function(cb) {
+ httpServer.createServer({ root: '../', cache: 5 }).listen(8080);
+ httpServer.createServer({ root: '../', cache: 5 }).listen(8088);
+ console.log('LISTENING on 8080 and 8088');
+});
diff --git a/metadata.js b/metadata.js
new file mode 100644
index 00000000..d9e7f34b
--- /dev/null
+++ b/metadata.js
@@ -0,0 +1,82 @@
+(function () {
+
+ var METADATA = {
+ CORE: {
+ paths: {
+ src: '/vscode/out/vs',
+ 'npm/dev': 'node_modules/monaco-editor-core/dev/vs',
+ 'npm/min': 'node_modules/monaco-editor-core/min/vs',
+ built: '/vscode/out-monaco-editor-core/min/vs',
+ releaseDev: 'release/dev/vs',
+ releaseMin: 'release/min/vs',
+ }
+ },
+ PLUGINS: [
+ {
+ name: 'monaco-typescript',
+ contrib: 'vs/language/typescript/monaco.contribution',
+ modulePrefix: 'vs/language/typescript',
+ thirdPartyNotices: 'node_modules/monaco-typescript/ThirdPartyNotices.txt',
+ paths: {
+ src: '/monaco-typescript/release/dev',
+ 'npm/dev': 'node_modules/monaco-typescript/release/dev',
+ 'npm/min': 'node_modules/monaco-typescript/release/min',
+ esm: 'node_modules/monaco-typescript/release/esm',
+ }
+ },
+ {
+ name: 'monaco-css',
+ contrib: 'vs/language/css/monaco.contribution',
+ modulePrefix: 'vs/language/css',
+ paths: {
+ src: '/monaco-css/release/dev',
+ 'npm/dev': 'node_modules/monaco-css/release/dev',
+ 'npm/min': 'node_modules/monaco-css/release/min',
+ esm: 'node_modules/monaco-css/release/esm',
+ }
+ },
+ {
+ name: 'monaco-json',
+ contrib: 'vs/language/json/monaco.contribution',
+ modulePrefix: 'vs/language/json',
+ paths: {
+ src: '/monaco-json/release/dev',
+ 'npm/dev': 'node_modules/monaco-json/release/dev',
+ 'npm/min': 'node_modules/monaco-json/release/min',
+ esm: 'node_modules/monaco-json/release/esm',
+ }
+ },
+ {
+ name: 'monaco-html',
+ contrib: 'vs/language/html/monaco.contribution',
+ modulePrefix: 'vs/language/html',
+ thirdPartyNotices: 'node_modules/monaco-html/ThirdPartyNotices.txt',
+ paths: {
+ src: '/monaco-html/release/dev',
+ 'npm/dev': 'node_modules/monaco-html/release/dev',
+ 'npm/min': 'node_modules/monaco-html/release/min',
+ esm: 'node_modules/monaco-html/release/esm',
+ }
+ },
+ {
+ name: 'monaco-languages',
+ contrib: 'vs/basic-languages/monaco.contribution',
+ modulePrefix: 'vs/basic-languages',
+ thirdPartyNotices: 'node_modules/monaco-languages/ThirdPartyNotices.txt',
+ paths: {
+ src: '/monaco-languages/release/dev',
+ 'npm/dev': 'node_modules/monaco-languages/release/dev',
+ 'npm/min': 'node_modules/monaco-languages/release/min',
+ esm: 'node_modules/monaco-languages/release/esm',
+ }
+ }
+ ]
+ }
+
+ if (typeof exports !== 'undefined') {
+ exports.METADATA = METADATA
+ } else {
+ self.METADATA = METADATA;
+ }
+
+})();
diff --git a/monaco-lsp-client/README.md b/monaco-lsp-client/README.md
deleted file mode 100644
index 8e6f3433..00000000
--- a/monaco-lsp-client/README.md
+++ /dev/null
@@ -1,5 +0,0 @@
-# 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
deleted file mode 100644
index df3b100c..00000000
--- a/monaco-lsp-client/generator/index.ts
+++ /dev/null
@@ -1,687 +0,0 @@
-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
deleted file mode 100644
index 2f47ccae..00000000
--- a/monaco-lsp-client/package-lock.json
+++ /dev/null
@@ -1,1607 +0,0 @@
-{
- "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-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-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": {
- "version": "0.5.0",
- "resolved": "https://registry.npmjs.org/@hediet/json-rpc/-/json-rpc-0.5.0.tgz",
- "integrity": "sha512-SApO7NbKJztClcznEqg46ZGQzO2v3Q3gVIuRVC9QE/m75J/5AipJdclxEXgT++7j4x4LI2JjEpf2xhi67Ngu9A==",
- "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==",
- "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==",
- "license": "MIT",
- "dependencies": {
- "@hediet/json-rpc": "^0.5.0",
- "@types/ws": "^6.0.4",
- "isomorphic-ws": "^5.0.0"
- }
- },
- "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/@types/node": {
- "version": "24.10.0",
- "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.0.tgz",
- "integrity": "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A==",
- "license": "MIT",
- "dependencies": {
- "undici-types": "~7.16.0"
- }
- },
- "node_modules/@types/ws": {
- "version": "6.0.4",
- "resolved": "https://registry.npmjs.org/@types/ws/-/ws-6.0.4.tgz",
- "integrity": "sha512-PpPrX7SZW9re6+Ha8ojZG4Se8AZXgf0GK6zmfqEuCsY49LFDNXO3SByp44X3dFEqtB73lkCDAdUazhAjVPiNwg==",
- "license": "MIT",
- "dependencies": {
- "@types/node": "*"
- }
- },
- "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/isomorphic-ws": {
- "version": "5.0.0",
- "resolved": "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-5.0.0.tgz",
- "integrity": "sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==",
- "license": "MIT",
- "peerDependencies": {
- "ws": "*"
- }
- },
- "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/undici-types": {
- "version": "7.16.0",
- "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
- "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
- "license": "MIT"
- },
- "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"
- }
- },
- "node_modules/ws": {
- "version": "8.18.3",
- "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
- "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
- "license": "MIT",
- "peer": true,
- "engines": {
- "node": ">=10.0.0"
- },
- "peerDependencies": {
- "bufferutil": "^4.0.1",
- "utf-8-validate": ">=5.0.2"
- },
- "peerDependenciesMeta": {
- "bufferutil": {
- "optional": true
- },
- "utf-8-validate": {
- "optional": true
- }
- }
- }
- }
-}
diff --git a/monaco-lsp-client/package.json b/monaco-lsp-client/package.json
deleted file mode 100644
index 98b09fe5..00000000
--- a/monaco-lsp-client/package.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
- "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
deleted file mode 100644
index e6336a2b..00000000
--- a/monaco-lsp-client/rolldown.config.mjs
+++ /dev/null
@@ -1,33 +0,0 @@
-// @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
deleted file mode 100644
index 2193bb85..00000000
--- a/monaco-lsp-client/src/adapters/ITextModelBridge.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-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
deleted file mode 100644
index 0f87f574..00000000
--- a/monaco-lsp-client/src/adapters/LspCapabilitiesRegistry.ts
+++ /dev/null
@@ -1,254 +0,0 @@
-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* id */ string, CapabilityRegistration>();
-}
-
-class DynamicFromStaticOptions {
- private readonly _mappings = new Map* method */ string, (serverCapabilities: ServerCapabilities) => 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
deleted file mode 100644
index 1c5d7321..00000000
--- a/monaco-lsp-client/src/adapters/LspClient.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-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
deleted file mode 100644
index b9f619a2..00000000
--- a/monaco-lsp-client/src/adapters/LspConnection.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-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
deleted file mode 100644
index c2b3620c..00000000
--- a/monaco-lsp-client/src/adapters/TextDocumentSynchronizer.ts
+++ /dev/null
@@ -1,183 +0,0 @@
-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* uri */ string, monaco.editor.ITextModel>();
-
- 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
deleted file mode 100644
index aed4e0dd..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspCodeActionFeature.ts
+++ /dev/null
@@ -1,169 +0,0 @@
-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
deleted file mode 100644
index f11fdf71..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspCodeLensFeature.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-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
deleted file mode 100644
index 2c11ea1a..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspCompletionFeature.ts
+++ /dev/null
@@ -1,202 +0,0 @@
-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
deleted file mode 100644
index ab306047..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspDeclarationFeature.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-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
deleted file mode 100644
index bf87f896..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspDefinitionFeature.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-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
deleted file mode 100644
index 2ba7bdea..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspDiagnosticsFeature.ts
+++ /dev/null
@@ -1,208 +0,0 @@
-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
deleted file mode 100644
index b07aad78..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentHighlightFeature.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-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
deleted file mode 100644
index 8825b10f..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentLinkFeature.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-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
deleted file mode 100644
index 4f3b4a35..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspDocumentSymbolFeature.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-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
deleted file mode 100644
index 36218023..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspFoldingRangeFeature.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-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
deleted file mode 100644
index 6a3bdc69..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspFormattingFeature.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-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
deleted file mode 100644
index 6a8fda53..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspHoverFeature.ts
+++ /dev/null
@@ -1,79 +0,0 @@
-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
deleted file mode 100644
index 9dd2d06e..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspImplementationFeature.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-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
deleted file mode 100644
index 2ef9e63d..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspInlayHintsFeature.ts
+++ /dev/null
@@ -1,212 +0,0 @@
-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
deleted file mode 100644
index 77b50223..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspOnTypeFormattingFeature.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-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
deleted file mode 100644
index 5cc79ec5..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspRangeFormattingFeature.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-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
deleted file mode 100644
index 2beab9b7..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspReferencesFeature.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-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
deleted file mode 100644
index 008abf20..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspRenameFeature.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-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
deleted file mode 100644
index d7f0f73d..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspSelectionRangeFeature.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-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
deleted file mode 100644
index f57ccc13..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspSemanticTokensFeature.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-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
deleted file mode 100644
index 672cdc53..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspSignatureHelpFeature.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-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
deleted file mode 100644
index 8736647f..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/LspTypeDefinitionFeature.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-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
deleted file mode 100644
index 4d648e7d..00000000
--- a/monaco-lsp-client/src/adapters/languageFeatures/common.ts
+++ /dev/null
@@ -1,401 +0,0 @@
-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
deleted file mode 100644
index ade3e55f..00000000
--- a/monaco-lsp-client/src/index.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index c007b2fb..00000000
--- a/monaco-lsp-client/src/types.ts
+++ /dev/null
@@ -1,7514 +0,0 @@
-// 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
deleted file mode 100644
index 00905499..00000000
--- a/monaco-lsp-client/src/utils.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-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/monaco.d.ts b/monaco.d.ts
new file mode 100644
index 00000000..078891c8
--- /dev/null
+++ b/monaco.d.ts
@@ -0,0 +1,5708 @@
+/*!-----------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Type definitions for monaco-editor v0.14.3
+ * Released under the MIT license
+*-----------------------------------------------------------*/
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare namespace monaco {
+
+ export type Thenable = PromiseLike;
+
+ export interface IDisposable {
+ dispose(): void;
+ }
+
+ export interface IEvent {
+ (listener: (e: T) => any, thisArg?: any): IDisposable;
+ }
+
+ /**
+ * A helper that allows to emit and listen to typed events
+ */
+ export class Emitter {
+ constructor();
+ readonly event: IEvent;
+ fire(event?: T): void;
+ dispose(): void;
+ }
+
+ export enum MarkerTag {
+ Unnecessary = 1,
+ }
+
+ export enum MarkerSeverity {
+ Hint = 1,
+ Info = 2,
+ Warning = 4,
+ Error = 8,
+ }
+
+
+
+
+ export type TValueCallback = (value: T | PromiseLike) => void;
+
+ export type ProgressCallback = (progress: TProgress) => void;
+
+
+ export class Promise {
+ constructor(
+ executor: (
+ resolve: (value: T | PromiseLike