-
-
-
diff --git a/packages/examples/resources/clangd/build.docker-compose.yml b/packages/examples/resources/clangd/build.docker-compose.yml
index 2bc2595cb..157ddd6ea 100644
--- a/packages/examples/resources/clangd/build.docker-compose.yml
+++ b/packages/examples/resources/clangd/build.docker-compose.yml
@@ -6,6 +6,6 @@ services:
context: .
# only linux/amd64 for now
platforms:
- - "linux/amd64"
+ - 'linux/amd64'
platform: linux/amd64
container_name: clangd-wasm-build
diff --git a/packages/examples/resources/clangd/clangd-include.files.md b/packages/examples/resources/clangd/clangd-include.files.md
index 49419d14b..0b3e7f313 100644
--- a/packages/examples/resources/clangd/clangd-include.files.md
+++ b/packages/examples/resources/clangd/clangd-include.files.md
@@ -2,6 +2,7 @@
## Files
+```shell
/usr/include/wasm32-wasi-threads/__errno.h
/usr/include/wasm32-wasi-threads/__errno_values.h
/usr/include/wasm32-wasi-threads/__fd_set.h
@@ -6394,3 +6395,4 @@
/usr/include/wasm32-wasip2/netpacket
/usr/include/wasm32-wasip2/sys
/usr/include/wasm32-wasip2/wasi
+```
diff --git a/packages/examples/resources/clangd/configure.docker-compose.yml b/packages/examples/resources/clangd/configure.docker-compose.yml
index 33c84b044..74176de12 100644
--- a/packages/examples/resources/clangd/configure.docker-compose.yml
+++ b/packages/examples/resources/clangd/configure.docker-compose.yml
@@ -6,6 +6,6 @@ services:
context: .
# only linux/amd64 for now
platforms:
- - "linux/amd64"
+ - 'linux/amd64'
platform: linux/amd64
container_name: clangd-wasm-configure
diff --git a/packages/examples/resources/clangd/scripts/extractDockerFiles.ts b/packages/examples/resources/clangd/scripts/extractDockerFiles.ts
index 490e8b052..4cdf4f949 100644
--- a/packages/examples/resources/clangd/scripts/extractDockerFiles.ts
+++ b/packages/examples/resources/clangd/scripts/extractDockerFiles.ts
@@ -1,23 +1,28 @@
-import * as fs from "node:fs";
-import child_process from "node:child_process";
+import * as fs from 'node:fs';
+import child_process from 'node:child_process';
const outputDir = './resources/clangd/wasm';
try {
- child_process.execFileSync('docker', ['create', '--name', 'extract-clangd', 'ghcr.io/typefox/monaco-languageclient/clangd-wasm-build:latest']);
+ child_process.execFileSync('docker', [
+ 'create',
+ '--name',
+ 'extract-clangd',
+ 'ghcr.io/typefox/monaco-languageclient/clangd-wasm-build:latest'
+ ]);
- // clean but only if container start was successful
- fs.rmSync(outputDir, {
- force: true,
- recursive: true
- });
- fs.mkdirSync(outputDir);
+ // clean but only if container start was successful
+ fs.rmSync(outputDir, {
+ force: true,
+ recursive: true
+ });
+ fs.mkdirSync(outputDir);
- child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.js', outputDir]);
- child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.wasm', outputDir]);
- child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.worker.js', outputDir]);
- child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.worker.mjs', outputDir]);
- child_process.execFileSync('docker', ['rm', 'extract-clangd']);
+ child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.js', outputDir]);
+ child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.wasm', outputDir]);
+ child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.worker.js', outputDir]);
+ child_process.execFileSync('docker', ['cp', 'extract-clangd:/builder/llvm-project/build/bin/clangd.worker.mjs', outputDir]);
+ child_process.execFileSync('docker', ['rm', 'extract-clangd']);
} catch (e) {
- console.warn('Clangd wasm data was not extracted from container image!');
+ console.warn('Clangd wasm data was not extracted from container image!');
}
diff --git a/packages/examples/resources/clangd/workspace/.clangd b/packages/examples/resources/clangd/workspace/.clangd
index 912fddf12..3f42939ae 100644
--- a/packages/examples/resources/clangd/workspace/.clangd
+++ b/packages/examples/resources/clangd/workspace/.clangd
@@ -1,16 +1,17 @@
{
- CompileFlags:
+ CompileFlags:
{
- Add: [
- '-xc++',
- '-std=c++2b',
- '-pedantic-errors',
- '-Wall',
- '--target=wasm32-wasi',
- '-isystem/usr/include/c++/v1',
- '-isystem/usr/include/wasm32-wasi/c++/v1',
- '-isystem/usr/include',
- '-isystem/usr/include/wasm32-wasi'
+ Add:
+ [
+ '-xc++',
+ '-std=c++2b',
+ '-pedantic-errors',
+ '-Wall',
+ '--target=wasm32-wasi',
+ '-isystem/usr/include/c++/v1',
+ '-isystem/usr/include/wasm32-wasi/c++/v1',
+ '-isystem/usr/include',
+ '-isystem/usr/include/wasm32-wasi'
]
}
}
diff --git a/packages/examples/resources/debugger/docker-compose.yml b/packages/examples/resources/debugger/docker-compose.yml
index e16366518..28dbc4363 100644
--- a/packages/examples/resources/debugger/docker-compose.yml
+++ b/packages/examples/resources/debugger/docker-compose.yml
@@ -7,13 +7,11 @@ services:
context: ../../../..
# only linux/amd64 for now
platforms:
- - "linux/amd64"
+ - 'linux/amd64'
platform: linux/amd64
ports:
- 55555:5555
tty: true
# just for completness. Is already set in the Dockerfile
working_dir: /home/mlc/server
- command: [
- "bash", "-c", "npm run start"
- ]
+ command: ['bash', '-c', 'npm run start']
diff --git a/packages/examples/resources/debugger/package.json b/packages/examples/resources/debugger/package.json
index f12a3a67a..ffb6a8d69 100644
--- a/packages/examples/resources/debugger/package.json
+++ b/packages/examples/resources/debugger/package.json
@@ -2,20 +2,14 @@
"name": "graalpy-debugger",
"version": "2025.2.1",
"description": "Monaco Language client Graalpy Debugger",
+ "license": "MIT",
"author": {
"name": "TypeFox GmbH",
"url": "http://www.typefox.io"
},
- "license": "MIT",
"type": "module",
"main": "./dist/debugServer.js",
"module": "./dist/debugServer.js",
- "exports": {
- ".": {
- "types": "./dist/debugServer.d.ts",
- "default": "./dist/debugServer.js"
- }
- },
"typesVersions": {
"*": {
".": [
@@ -23,13 +17,14 @@
]
}
},
- "engines": {
- "node": ">=20.10.0",
- "npm": ">=10.2.3"
+ "exports": {
+ ".": {
+ "types": "./dist/debugServer.d.ts",
+ "default": "./dist/debugServer.js"
+ }
},
- "volta": {
- "node": "24.13.0",
- "npm": "11.6.2"
+ "scripts": {
+ "start": "npm i && tsx src/debugServer.ts"
},
"dependencies": {
"express": "~4.21.2",
@@ -39,7 +34,12 @@
"devDependencies": {
"tsx": "~4.19.2"
},
- "scripts": {
- "start": "npm i && tsx src/debugServer.ts"
+ "engines": {
+ "node": ">=20.10.0",
+ "npm": ">=10.2.3"
+ },
+ "volta": {
+ "node": "24.13.0",
+ "npm": "11.6.2"
}
}
diff --git a/packages/examples/resources/eclipse.jdt.ls/docker-compose.yml b/packages/examples/resources/eclipse.jdt.ls/docker-compose.yml
index 30bcba2ba..e643f253a 100644
--- a/packages/examples/resources/eclipse.jdt.ls/docker-compose.yml
+++ b/packages/examples/resources/eclipse.jdt.ls/docker-compose.yml
@@ -6,11 +6,9 @@ services:
context: ../../../..
# only linux/amd64 for now
platforms:
- - "linux/amd64"
+ - 'linux/amd64'
platform: linux/amd64
- command: [
- "bash", "-c", "npm run start:example:server:jdtls"
- ]
+ command: ['bash', '-c', 'npm run start:example:server:jdtls']
ports:
- 30003:30003
working_dir: /home/mlc
diff --git a/packages/examples/resources/groovy/docker-compose.yml b/packages/examples/resources/groovy/docker-compose.yml
index 3979c00f0..b5a9c4b0d 100644
--- a/packages/examples/resources/groovy/docker-compose.yml
+++ b/packages/examples/resources/groovy/docker-compose.yml
@@ -6,11 +6,9 @@ services:
context: ../../../..
# only linux/amd64 for now
platforms:
- - "linux/amd64"
+ - 'linux/amd64'
platform: linux/amd64
- command: [
- "bash", "-c", "npm run start:example:server:groovy"
- ]
+ command: ['bash', '-c', 'npm run start:example:server:groovy']
ports:
- 30002:30002
working_dir: /home/gradle/mlc
diff --git a/packages/examples/resources/scripts/downloadResources.ts b/packages/examples/resources/scripts/downloadResources.ts
index 2d84ff1db..8c9812fde 100644
--- a/packages/examples/resources/scripts/downloadResources.ts
+++ b/packages/examples/resources/scripts/downloadResources.ts
@@ -8,32 +8,38 @@ import { dirname, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
export const getLocalDirectory = () => {
- const __filename = fileURLToPath(import.meta.url);
- return dirname(__filename);
+ const __filename = fileURLToPath(import.meta.url);
+ return dirname(__filename);
};
const downloadResource = async (url: string, targetDir: string, filename: string) => {
- const target = resolve(targetDir, filename);
- if (existsSync(target)) {
- console.log(`Skipping download because ${target} already exists.`);
- } else {
- const result = mkdirSync(targetDir, { recursive: true });
- if (result) {
- console.log(`Created target directory: ${targetDir}`);
- }
- console.log(`Downloading ${url} to ${target}`);
- const resp = await fetch(url);
- const buffer = await resp.arrayBuffer();
- writeFileSync(target, Buffer.from(buffer));
+ const target = resolve(targetDir, filename);
+ if (existsSync(target)) {
+ console.log(`Skipping download because ${target} already exists.`);
+ } else {
+ const result = mkdirSync(targetDir, { recursive: true });
+ if (result) {
+ console.log(`Created target directory: ${targetDir}`);
}
+ console.log(`Downloading ${url} to ${target}`);
+ const resp = await fetch(url);
+ const buffer = await resp.arrayBuffer();
+ writeFileSync(target, Buffer.from(buffer));
+ }
};
// Source: https://gist.github.com/wanglf/7acc591890dc0d8ceff1e7ec9af32a55?permalink_comment_id=4151555#gistcomment-4151555
// https://marketplace.visualstudio.com/_apis/public/gallery/publishers/${publisher}/vsextensions/${extension}/${version}/vspackage
-await downloadResource('https://marketplace.visualstudio.com/_apis/public/gallery/publishers/GitHub/vsextensions/github-vscode-theme/6.3.5/vspackage',
- resolve(getLocalDirectory(), '../vsix/'), 'github-vscode-theme.vsix');
+await downloadResource(
+ 'https://marketplace.visualstudio.com/_apis/public/gallery/publishers/GitHub/vsextensions/github-vscode-theme/6.3.5/vspackage',
+ resolve(getLocalDirectory(), '../vsix/'),
+ 'github-vscode-theme.vsix'
+);
// not yet used
-await downloadResource('https://marketplace.visualstudio.com/_apis/public/gallery/publishers/TypeFox/vsextensions/open-collaboration-tools/0.3.5/vspackage',
- resolve(getLocalDirectory(), '../vsix/'), 'open-collaboration-tools.vsix');
+await downloadResource(
+ 'https://marketplace.visualstudio.com/_apis/public/gallery/publishers/TypeFox/vsextensions/open-collaboration-tools/0.3.5/vspackage',
+ resolve(getLocalDirectory(), '../vsix/'),
+ 'open-collaboration-tools.vsix'
+);
diff --git a/packages/examples/resources/styles/views.css b/packages/examples/resources/styles/views.css
index 68b03eb0b..f1515fcba 100644
--- a/packages/examples/resources/styles/views.css
+++ b/packages/examples/resources/styles/views.css
@@ -1,79 +1,79 @@
:root {
- font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
- font-size: 16px;
- line-height: 24px;
- font-weight: 400;
+ font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
+ font-size: 16px;
+ line-height: 24px;
+ font-weight: 400;
- font-synthesis: none;
- text-rendering: optimizeLegibility;
- -webkit-font-smoothing: antialiased;
- -moz-osx-font-smoothing: grayscale;
- -webkit-text-size-adjust: 100%;
+ font-synthesis: none;
+ text-rendering: optimizeLegibility;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+ -webkit-text-size-adjust: 100%;
}
body {
- background-color: var(--vscode-editorWidget-background);
- color: var(--vscode-editorWidget-foreground);
- margin: 0;
+ background-color: var(--vscode-editorWidget-background);
+ color: var(--vscode-editorWidget-foreground);
+ margin: 0;
}
#sidebarDiv,
#sidebarRightDiv {
- display: flex;
- flex: none;
- border: 1px solid var(--vscode-editorWidget-border);
+ display: flex;
+ flex: none;
+ border: 1px solid var(--vscode-editorWidget-border);
}
#sidebar {
- width: 300px;
+ width: 300px;
}
#editorsDiv {
- flex: 1;
- min-width: 0;
+ flex: 1;
+ min-width: 0;
}
#editors {
- position: relative;
- min-width: 0;
- height: 99%;
- border: 1px solid var(--vscode-editorWidget-border);
+ position: relative;
+ min-width: 0;
+ height: 99%;
+ border: 1px solid var(--vscode-editorWidget-border);
}
#sidebar-right {
- max-width: 500px;
+ max-width: 500px;
}
#auxiliaryBar-left,
#auxiliaryBar {
- max-width: 300px;
+ max-width: 300px;
}
#panel {
- display: none;
- flex: 1;
- border: 1px solid var(--vscode-editorWidget-border);
- min-height: 0;
+ display: none;
+ flex: 1;
+ border: 1px solid var(--vscode-editorWidget-border);
+ min-height: 0;
}
#titleBar {
- position: relative;
- flex: none;
+ position: relative;
+ flex: none;
}
#banner {
- flex: none;
+ flex: none;
}
#workbench-container {
- height: 95vh;
- display: flex;
- flex-direction: column
+ height: 95vh;
+ display: flex;
+ flex-direction: column;
}
#workbench-top {
- display: flex;
- gap: 20px;
- flex: 2;
- min-height: 0
+ display: flex;
+ gap: 20px;
+ flex: 2;
+ min-height: 0;
}
diff --git a/packages/examples/resources/styles/views.editorOnly.css b/packages/examples/resources/styles/views.editorOnly.css
index c8542f4f3..b53529e8a 100644
--- a/packages/examples/resources/styles/views.editorOnly.css
+++ b/packages/examples/resources/styles/views.editorOnly.css
@@ -1,29 +1,29 @@
:root {
- font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
- font-size: 16px;
- line-height: 24px;
- font-weight: 400;
+ font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
+ font-size: 16px;
+ line-height: 24px;
+ font-weight: 400;
- font-synthesis: none;
- text-rendering: optimizeLegibility;
- -webkit-font-smoothing: antialiased;
- -moz-osx-font-smoothing: grayscale;
- -webkit-text-size-adjust: 100%;
+ font-synthesis: none;
+ text-rendering: optimizeLegibility;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+ -webkit-text-size-adjust: 100%;
}
body {
- background-color: var(--vscode-editorWidget-background);
- color: var(--vscode-editorWidget-foreground);
- margin: 0;
+ background-color: var(--vscode-editorWidget-background);
+ color: var(--vscode-editorWidget-foreground);
+ margin: 0;
}
#editorsDiv {
- min-width: 0;
+ min-width: 0;
}
#editors {
- position: relative;
- min-width: 0;
- height: 95vh;
- border: 1px solid var(--vscode-editorWidget-border);
+ position: relative;
+ min-width: 0;
+ height: 95vh;
+ border: 1px solid var(--vscode-editorWidget-border);
}
diff --git a/packages/examples/src/appPlayground/common.ts b/packages/examples/src/appPlayground/common.ts
index 847aaa9da..abd43f641 100644
--- a/packages/examples/src/appPlayground/common.ts
+++ b/packages/examples/src/appPlayground/common.ts
@@ -1,7 +1,7 @@
/* --------------------------------------------------------------------------------------------
-* Copyright (c) 2024 TypeFox and others.
-* Licensed under the MIT License. See LICENSE in the package root for license information.
-* ------------------------------------------------------------------------------------------ */
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
import * as vscode from 'vscode';
import type { RegisterLocalProcessExtensionResult } from '@codingame/monaco-vscode-api/extensions';
@@ -9,18 +9,16 @@ import type { ConfigResult } from './config.js';
import type { MonacoVscodeApiWrapper } from 'monaco-languageclient/vscodeApiWrapper';
export const configurePostStart = async (apiWrapper: MonacoVscodeApiWrapper, configResult: ConfigResult) => {
- const result = apiWrapper.getExtensionRegisterResult('mlc-app-playground') as RegisterLocalProcessExtensionResult;
- await result.setAsDefaultApi();
+ const result = apiWrapper.getExtensionRegisterResult('mlc-app-playground') as RegisterLocalProcessExtensionResult;
+ await result.setAsDefaultApi();
- await Promise.all([
- await vscode.workspace.openTextDocument(configResult.helloTsUri),
- await vscode.workspace.openTextDocument(configResult.testerTsUri),
- await vscode.workspace.openTextDocument(configResult.helloJsonUri)
- ]);
+ await Promise.all([
+ await vscode.workspace.openTextDocument(configResult.helloTsUri),
+ await vscode.workspace.openTextDocument(configResult.testerTsUri),
+ await vscode.workspace.openTextDocument(configResult.helloJsonUri)
+ ]);
- await Promise.all([
- await vscode.window.showTextDocument(configResult.helloTsUri)
- ]);
+ await Promise.all([await vscode.window.showTextDocument(configResult.helloTsUri)]);
- console.log('Application Playground started');
+ console.log('Application Playground started');
};
diff --git a/packages/examples/src/appPlayground/config.ts b/packages/examples/src/appPlayground/config.ts
index ed066efd7..308096441 100644
--- a/packages/examples/src/appPlayground/config.ts
+++ b/packages/examples/src/appPlayground/config.ts
@@ -6,7 +6,11 @@
import { LogLevel } from '@codingame/monaco-vscode-api';
import getEnvironmentServiceOverride from '@codingame/monaco-vscode-environment-service-override';
import getExplorerServiceOverride from '@codingame/monaco-vscode-explorer-service-override';
-import { InMemoryFileSystemProvider, registerFileSystemOverlay, type IFileWriteOptions } from '@codingame/monaco-vscode-files-service-override';
+import {
+ InMemoryFileSystemProvider,
+ registerFileSystemOverlay,
+ type IFileWriteOptions
+} from '@codingame/monaco-vscode-files-service-override';
import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
import getLifecycleServiceOverride from '@codingame/monaco-vscode-lifecycle-service-override';
import getLocalizationServiceOverride from '@codingame/monaco-vscode-localization-service-override';
@@ -41,117 +45,119 @@ import helloJsonCode from '../../resources/appPlayground/hello.json?raw';
import { createDefaultWorkspaceContent } from '../common/client/utils.js';
export type ConfigResult = {
- vscodeApiConfig: MonacoVscodeApiConfig;
- workspaceFileUri: vscode.Uri;
- helloTsUri: vscode.Uri;
- testerTsUri: vscode.Uri;
- helloJsonUri: vscode.Uri;
+ vscodeApiConfig: MonacoVscodeApiConfig;
+ workspaceFileUri: vscode.Uri;
+ helloTsUri: vscode.Uri;
+ testerTsUri: vscode.Uri;
+ helloJsonUri: vscode.Uri;
};
export const configure = async (htmlContainer?: HTMLElement): Promise
=> {
- const workspaceFileUri = vscode.Uri.file('/workspace.code-workspace');
+ const workspaceFileUri = vscode.Uri.file('/workspace.code-workspace');
- const vscodeApiConfig: MonacoVscodeApiConfig = {
- $type: 'extended',
- logLevel: LogLevel.Debug,
- serviceOverrides: {
- ...getKeybindingsServiceOverride(),
- ...getLifecycleServiceOverride(),
- ...getLocalizationServiceOverride(createDefaultLocaleConfiguration()),
- ...getBannerServiceOverride(),
- ...getStatusBarServiceOverride(),
- ...getTitleBarServiceOverride(),
- ...getExplorerServiceOverride(),
- ...getRemoteAgentServiceOverride(),
- ...getEnvironmentServiceOverride(),
- ...getSecretStorageServiceOverride(),
- ...getStorageServiceOverride(),
- ...getSearchServiceOverride(),
- ...getOutlineServiceOverride()
+ const vscodeApiConfig: MonacoVscodeApiConfig = {
+ $type: 'extended',
+ logLevel: LogLevel.Debug,
+ serviceOverrides: {
+ ...getKeybindingsServiceOverride(),
+ ...getLifecycleServiceOverride(),
+ ...getLocalizationServiceOverride(createDefaultLocaleConfiguration()),
+ ...getBannerServiceOverride(),
+ ...getStatusBarServiceOverride(),
+ ...getTitleBarServiceOverride(),
+ ...getExplorerServiceOverride(),
+ ...getRemoteAgentServiceOverride(),
+ ...getEnvironmentServiceOverride(),
+ ...getSecretStorageServiceOverride(),
+ ...getStorageServiceOverride(),
+ ...getSearchServiceOverride(),
+ ...getOutlineServiceOverride()
+ },
+ viewsConfig: {
+ $type: 'ViewsService',
+ htmlContainer,
+ htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
+ viewsInitFunc: defaultViewsInit
+ },
+ workspaceConfig: {
+ enableWorkspaceTrust: true,
+ windowIndicator: {
+ label: 'mlc-app-playground',
+ tooltip: '',
+ command: ''
+ },
+ workspaceProvider: {
+ trusted: true,
+ async open() {
+ window.open(window.location.href);
+ return true;
},
- viewsConfig: {
- $type: 'ViewsService',
- htmlContainer,
- htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
- viewsInitFunc: defaultViewsInit
- },
- workspaceConfig: {
- enableWorkspaceTrust: true,
- windowIndicator: {
- label: 'mlc-app-playground',
- tooltip: '',
- command: ''
- },
- workspaceProvider: {
- trusted: true,
- async open() {
- window.open(window.location.href);
- return true;
- },
- workspace: {
- workspaceUri: workspaceFileUri
- }
- },
- configurationDefaults: {
- 'window.title': 'mlc-app-playground${separator}${dirty}${activeEditorShort}'
- },
- productConfiguration: {
- nameShort: 'mlc-app-playground',
- nameLong: 'mlc-app-playground'
- }
- },
- userConfiguration: {
- json: JSON.stringify({
- 'workbench.colorTheme': 'Default Dark Modern',
- 'editor.wordBasedSuggestions': 'off',
- 'typescript.tsserver.web.projectWideIntellisense.enabled': true,
- 'typescript.tsserver.web.projectWideIntellisense.suppressSemanticErrors': false,
- 'editor.guides.bracketPairsHorizontal': true,
- 'oct.serverUrl': 'https://api.open-collab.tools/',
- 'editor.experimental.asyncTokenization': true
- })
- },
- extensions: [{
- config: {
- name: 'mlc-app-playground',
- publisher: 'TypeFox',
- version: '1.0.0',
- engines: {
- vscode: '*'
- }
- }
- }],
- advanced: {
- enableExtHostWorker: true,
- },
- monacoWorkerFactory: configureDefaultWorkerFactory
- };
+ workspace: {
+ workspaceUri: workspaceFileUri
+ }
+ },
+ configurationDefaults: {
+ 'window.title': 'mlc-app-playground${separator}${dirty}${activeEditorShort}'
+ },
+ productConfiguration: {
+ nameShort: 'mlc-app-playground',
+ nameLong: 'mlc-app-playground'
+ }
+ },
+ userConfiguration: {
+ json: JSON.stringify({
+ 'workbench.colorTheme': 'Default Dark Modern',
+ 'editor.wordBasedSuggestions': 'off',
+ 'typescript.tsserver.web.projectWideIntellisense.enabled': true,
+ 'typescript.tsserver.web.projectWideIntellisense.suppressSemanticErrors': false,
+ 'editor.guides.bracketPairsHorizontal': true,
+ 'oct.serverUrl': 'https://api.open-collab.tools/',
+ 'editor.experimental.asyncTokenization': true
+ })
+ },
+ extensions: [
+ {
+ config: {
+ name: 'mlc-app-playground',
+ publisher: 'TypeFox',
+ version: '1.0.0',
+ engines: {
+ vscode: '*'
+ }
+ }
+ }
+ ],
+ advanced: {
+ enableExtHostWorker: true
+ },
+ monacoWorkerFactory: configureDefaultWorkerFactory
+ };
- const workspaceUri = vscode.Uri.file('/workspace');
- const helloTsUri = vscode.Uri.file('/workspace/hello.ts');
- const testerTsUri = vscode.Uri.file('/workspace/tester.ts');
- const helloJsonUri = vscode.Uri.file('/workspace/hello.json');
- const fileSystemProvider = new InMemoryFileSystemProvider();
- const textEncoder = new TextEncoder();
+ const workspaceUri = vscode.Uri.file('/workspace');
+ const helloTsUri = vscode.Uri.file('/workspace/hello.ts');
+ const testerTsUri = vscode.Uri.file('/workspace/tester.ts');
+ const helloJsonUri = vscode.Uri.file('/workspace/hello.json');
+ const fileSystemProvider = new InMemoryFileSystemProvider();
+ const textEncoder = new TextEncoder();
- const options: IFileWriteOptions = {
- atomic: false,
- unlock: false,
- create: true,
- overwrite: true
- };
- await fileSystemProvider.mkdir(workspaceUri);
- await fileSystemProvider.writeFile(helloTsUri, textEncoder.encode(helloTsCode), options);
- await fileSystemProvider.writeFile(testerTsUri, textEncoder.encode(testerTsCode), options);
- await fileSystemProvider.writeFile(helloJsonUri, textEncoder.encode(helloJsonCode), options);
- await fileSystemProvider.writeFile(workspaceFileUri, textEncoder.encode(createDefaultWorkspaceContent('/workspace')), options);
- registerFileSystemOverlay(1, fileSystemProvider);
+ const options: IFileWriteOptions = {
+ atomic: false,
+ unlock: false,
+ create: true,
+ overwrite: true
+ };
+ await fileSystemProvider.mkdir(workspaceUri);
+ await fileSystemProvider.writeFile(helloTsUri, textEncoder.encode(helloTsCode), options);
+ await fileSystemProvider.writeFile(testerTsUri, textEncoder.encode(testerTsCode), options);
+ await fileSystemProvider.writeFile(helloJsonUri, textEncoder.encode(helloJsonCode), options);
+ await fileSystemProvider.writeFile(workspaceFileUri, textEncoder.encode(createDefaultWorkspaceContent('/workspace')), options);
+ registerFileSystemOverlay(1, fileSystemProvider);
- return {
- vscodeApiConfig,
- workspaceFileUri,
- helloTsUri,
- testerTsUri,
- helloJsonUri
- };
+ return {
+ vscodeApiConfig,
+ workspaceFileUri,
+ helloTsUri,
+ testerTsUri,
+ helloJsonUri
+ };
};
diff --git a/packages/examples/src/appPlayground/main.ts b/packages/examples/src/appPlayground/main.ts
index 12a9a0366..2fd291f51 100644
--- a/packages/examples/src/appPlayground/main.ts
+++ b/packages/examples/src/appPlayground/main.ts
@@ -9,13 +9,13 @@ import { disableElement } from '../common/client/utils.js';
import { MonacoVscodeApiWrapper } from 'monaco-languageclient/vscodeApiWrapper';
export const runApplicationPlayground = async () => {
- disableElement('button-start', true);
+ disableElement('button-start', true);
- const configResult = await configure(document.body);
+ const configResult = await configure(document.body);
- // perform global init
- const apiWrapper = new MonacoVscodeApiWrapper(configResult.vscodeApiConfig);
- await apiWrapper.start();
+ // perform global init
+ const apiWrapper = new MonacoVscodeApiWrapper(configResult.vscodeApiConfig);
+ await apiWrapper.start();
- await configurePostStart(apiWrapper, configResult);
+ await configurePostStart(apiWrapper, configResult);
};
diff --git a/packages/examples/src/appPlayground/reactMain.tsx b/packages/examples/src/appPlayground/reactMain.tsx
index 2e398146e..086bbf3f1 100644
--- a/packages/examples/src/appPlayground/reactMain.tsx
+++ b/packages/examples/src/appPlayground/reactMain.tsx
@@ -10,22 +10,22 @@ import { configurePostStart } from './common.js';
import { configure } from './config.js';
export const runApplicationPlaygroundReact = async () => {
-
- const configResult = await configure(document.body);
- const root = ReactDOM.createRoot(document.getElementById('react-root')!);
- const App = () => {
- return (
-
- {
- await configurePostStart(apiWrapper, configResult);
- }}
- onError={(e) => {
- console.error(e);
- }} />
-
- );
- };
- root.render();
+ const configResult = await configure(document.body);
+ const root = ReactDOM.createRoot(document.getElementById('react-root')!);
+ const App = () => {
+ return (
+
+ {
+ await configurePostStart(apiWrapper, configResult);
+ }}
+ onError={(e) => {
+ console.error(e);
+ }}
+ />
+
+ );
+ };
+ root.render();
};
diff --git a/packages/examples/src/browser/main.ts b/packages/examples/src/browser/main.ts
index 0cecc3bf5..9bcc033cd 100644
--- a/packages/examples/src/browser/main.ts
+++ b/packages/examples/src/browser/main.ts
@@ -19,152 +19,155 @@ import { configureDefaultWorkerFactory } from 'monaco-languageclient/workerFacto
import { MonacoVscodeApiWrapper, type MonacoVscodeApiConfig } from 'monaco-languageclient/vscodeApiWrapper';
export const runBrowserEditor = async () => {
- const codeConverter = createCodeConverter();
- const protocolConverter = createProtocolConverter(undefined, true, true);
+ const codeConverter = createCodeConverter();
+ const protocolConverter = createProtocolConverter(undefined, true, true);
- let mainVscodeDocument: vscode.TextDocument | undefined;
- const languageId = 'json';
- const code = `{
+ let mainVscodeDocument: vscode.TextDocument | undefined;
+ const languageId = 'json';
+ const code = `{
"$schema": "http://json.schemastore.org/coffeelint",
"line_endings": "unix"
}`;
- const codeUri = '/workspace/model.json';
-
- const htmlContainer = document.getElementById('monaco-editor-root')!;
- const vscodeApiConfig: MonacoVscodeApiConfig = {
- $type: 'extended',
- viewsConfig: {
- $type: 'EditorService',
- htmlContainer
- },
- logLevel: LogLevel.Debug,
- serviceOverrides: {
- ...getKeybindingsServiceOverride(),
- },
- userConfiguration: {
- json: JSON.stringify({
- 'workbench.colorTheme': 'GitHub Dark High Contrast',
- 'editor.guides.bracketPairsHorizontal': 'active',
- 'editor.lightbulb.enabled': 'On',
- 'editor.experimental.asyncTokenization': true
- })
- },
- monacoWorkerFactory: configureDefaultWorkerFactory
- };
- const editorAppConfig: EditorAppConfig = {
- codeResources: {
- modified: {
- text: code,
- uri: codeUri
- }
- }
- };
- const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
- await apiWrapper.start();
-
- const editorApp = new EditorApp(editorAppConfig);
-
- vscode.workspace.onDidOpenTextDocument((_event) => {
- mainVscodeDocument = _event;
+ const codeUri = '/workspace/model.json';
+
+ const htmlContainer = document.getElementById('monaco-editor-root')!;
+ const vscodeApiConfig: MonacoVscodeApiConfig = {
+ $type: 'extended',
+ viewsConfig: {
+ $type: 'EditorService',
+ htmlContainer
+ },
+ logLevel: LogLevel.Debug,
+ serviceOverrides: {
+ ...getKeybindingsServiceOverride()
+ },
+ userConfiguration: {
+ json: JSON.stringify({
+ 'workbench.colorTheme': 'GitHub Dark High Contrast',
+ 'editor.guides.bracketPairsHorizontal': 'active',
+ 'editor.lightbulb.enabled': 'On',
+ 'editor.experimental.asyncTokenization': true
+ })
+ },
+ monacoWorkerFactory: configureDefaultWorkerFactory
+ };
+ const editorAppConfig: EditorAppConfig = {
+ codeResources: {
+ modified: {
+ text: code,
+ uri: codeUri
+ }
+ }
+ };
+ const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
+ await apiWrapper.start();
+
+ const editorApp = new EditorApp(editorAppConfig);
+
+ vscode.workspace.onDidOpenTextDocument((_event) => {
+ mainVscodeDocument = _event;
+ });
+
+ const createDocument = (vscodeDocument: vscode.TextDocument) => {
+ return TextDocument.create(vscodeDocument.uri.toString(), vscodeDocument.languageId, vscodeDocument.version, vscodeDocument.getText());
+ };
+
+ const resolveSchema = (url: string): Promise => {
+ const promise = new Promise((resolve, reject) => {
+ const xhr = new XMLHttpRequest();
+ xhr.onload = () => resolve(xhr.responseText);
+ xhr.onerror = () => reject(xhr.statusText);
+ xhr.open('GET', url, true);
+ xhr.send();
});
-
- const createDocument = (vscodeDocument: vscode.TextDocument) => {
- return TextDocument.create(vscodeDocument.uri.toString(), vscodeDocument.languageId, vscodeDocument.version, vscodeDocument.getText());
- };
-
- const resolveSchema = (url: string): Promise => {
- const promise = new Promise((resolve, reject) => {
- const xhr = new XMLHttpRequest();
- xhr.onload = () => resolve(xhr.responseText);
- xhr.onerror = () => reject(xhr.statusText);
- xhr.open('GET', url, true);
- xhr.send();
- });
- return promise;
- };
-
- const jsonService = getLanguageService({
- schemaRequestService: resolveSchema
- });
- const pendingValidationRequests = new Map();
-
- vscode.languages.registerCompletionItemProvider(languageId, {
- async provideCompletionItems(vscodeDocument, position, _token, _context) {
- const document = createDocument(vscodeDocument);
- const jsonDocument = jsonService.parseJSONDocument(document);
- const completionList = await jsonService.doComplete(document, codeConverter.asPosition(position), jsonDocument);
- return protocolConverter.asCompletionResult(completionList);
- },
-
- async resolveCompletionItem(item, _token) {
- return await jsonService.doResolve(codeConverter.asCompletionItem(item)).then(result => protocolConverter.asCompletionItem(result));
- }
+ return promise;
+ };
+
+ const jsonService = getLanguageService({
+ schemaRequestService: resolveSchema
+ });
+ const pendingValidationRequests = new Map();
+
+ vscode.languages.registerCompletionItemProvider(languageId, {
+ async provideCompletionItems(vscodeDocument, position, _token, _context) {
+ const document = createDocument(vscodeDocument);
+ const jsonDocument = jsonService.parseJSONDocument(document);
+ const completionList = await jsonService.doComplete(document, codeConverter.asPosition(position), jsonDocument);
+ return protocolConverter.asCompletionResult(completionList);
+ },
+
+ async resolveCompletionItem(item, _token) {
+ return await jsonService.doResolve(codeConverter.asCompletionItem(item)).then((result) => protocolConverter.asCompletionItem(result));
+ }
+ });
+
+ vscode.languages.registerDocumentRangeFormattingEditProvider(languageId, {
+ provideDocumentRangeFormattingEdits(vscodeDocument, range, options, _token) {
+ const document = createDocument(vscodeDocument);
+ const edits = jsonService.format(document, codeConverter.asRange(range), codeConverter.asFormattingOptions(options, {}));
+ return protocolConverter.asTextEdits(edits);
+ }
+ });
+
+ vscode.languages.registerDocumentSymbolProvider(languageId, {
+ provideDocumentSymbols(vscodeDocument, _token) {
+ const document = createDocument(vscodeDocument);
+ const jsonDocument = jsonService.parseJSONDocument(document);
+ return protocolConverter.asSymbolInformations(jsonService.findDocumentSymbols(document, jsonDocument));
+ }
+ });
+
+ vscode.languages.registerHoverProvider(languageId, {
+ async provideHover(vscodeDocument, position, _token) {
+ const document = createDocument(vscodeDocument);
+ const jsonDocument = jsonService.parseJSONDocument(document);
+ return await jsonService.doHover(document, codeConverter.asPosition(position), jsonDocument).then((hover) => {
+ return protocolConverter.asHover(hover)!;
+ });
+ }
+ });
+
+ const validate = () => {
+ const document = createDocument(mainVscodeDocument!);
+ cleanPendingValidation(document);
+ pendingValidationRequests.set(
+ document.uri,
+ window.setTimeout(() => {
+ pendingValidationRequests.delete(document.uri);
+ doValidate(document);
+ })
+ );
+ };
+
+ const cleanPendingValidation = (document: TextDocument) => {
+ const request = pendingValidationRequests.get(document.uri);
+ if (request !== undefined) {
+ window.clearTimeout(request);
+ pendingValidationRequests.delete(document.uri);
+ }
+ };
+
+ const diagnosticCollection = vscode.languages.createDiagnosticCollection('json');
+ const doValidate = (document: TextDocument) => {
+ if (document.getText().length === 0) {
+ cleanDiagnostics();
+ return;
+ }
+ const jsonDocument = jsonService.parseJSONDocument(document);
+
+ jsonService.doValidation(document, jsonDocument).then(async (pDiagnostics) => {
+ const diagnostics = await protocolConverter.asDiagnostics(pDiagnostics);
+ diagnosticCollection.set(vscode.Uri.parse(codeUri), diagnostics);
});
+ };
- vscode.languages.registerDocumentRangeFormattingEditProvider(languageId, {
- provideDocumentRangeFormattingEdits(vscodeDocument, range, options, _token) {
- const document = createDocument(vscodeDocument);
- const edits = jsonService.format(document, codeConverter.asRange(range), codeConverter.asFormattingOptions(options, {}));
- return protocolConverter.asTextEdits(edits);
- }
- });
+ const cleanDiagnostics = () => {
+ diagnosticCollection.clear();
+ };
- vscode.languages.registerDocumentSymbolProvider(languageId, {
- provideDocumentSymbols(vscodeDocument, _token) {
- const document = createDocument(vscodeDocument);
- const jsonDocument = jsonService.parseJSONDocument(document);
- return protocolConverter.asSymbolInformations(jsonService.findDocumentSymbols(document, jsonDocument));
- }
- });
+ await editorApp.start(htmlContainer);
- vscode.languages.registerHoverProvider(languageId, {
- async provideHover(vscodeDocument, position, _token) {
- const document = createDocument(vscodeDocument);
- const jsonDocument = jsonService.parseJSONDocument(document);
- return await jsonService.doHover(document, codeConverter.asPosition(position), jsonDocument).then((hover) => {
- return protocolConverter.asHover(hover)!;
- });
- }
- });
-
- const validate = () => {
- const document = createDocument(mainVscodeDocument!);
- cleanPendingValidation(document);
- pendingValidationRequests.set(document.uri, window.setTimeout(() => {
- pendingValidationRequests.delete(document.uri);
- doValidate(document);
- }));
- };
-
- const cleanPendingValidation = (document: TextDocument) => {
- const request = pendingValidationRequests.get(document.uri);
- if (request !== undefined) {
- window.clearTimeout(request);
- pendingValidationRequests.delete(document.uri);
- }
- };
-
- const diagnosticCollection = vscode.languages.createDiagnosticCollection('json');
- const doValidate = (document: TextDocument) => {
- if (document.getText().length === 0) {
- cleanDiagnostics();
- return;
- }
- const jsonDocument = jsonService.parseJSONDocument(document);
-
- jsonService.doValidation(document, jsonDocument).then(async (pDiagnostics) => {
- const diagnostics = await protocolConverter.asDiagnostics(pDiagnostics);
- diagnosticCollection.set(vscode.Uri.parse(codeUri), diagnostics);
- });
- };
-
- const cleanDiagnostics = () => {
- diagnosticCollection.clear();
- };
-
- await editorApp.start(htmlContainer);
-
- editorApp.getTextModels().modified?.onDidChangeContent(() => {
- validate();
- });
+ editorApp.getTextModels().modified?.onDidChangeContent(() => {
+ validate();
+ });
};
diff --git a/packages/examples/src/clangd/client/config.ts b/packages/examples/src/clangd/client/config.ts
index 132d55bae..4382ea73e 100644
--- a/packages/examples/src/clangd/client/config.ts
+++ b/packages/examples/src/clangd/client/config.ts
@@ -21,115 +21,117 @@ import { Uri } from 'vscode';
import { ClangdWorkerHandler } from './workerHandler.js';
export type ClangdAppConfig = {
- languageClientConfig: LanguageClientConfig;
- vscodeApiConfig: MonacoVscodeApiConfig;
- editorAppConfig: EditorAppConfig;
-}
+ languageClientConfig: LanguageClientConfig;
+ vscodeApiConfig: MonacoVscodeApiConfig;
+ editorAppConfig: EditorAppConfig;
+};
export const createClangdAppConfig = async (config: {
- htmlContainer: HTMLElement,
- workspaceUri: Uri,
- workspaceFileUri: Uri,
- clangdWorkerHandler: ClangdWorkerHandler,
- lsMessageLocalPort: MessagePort
+ htmlContainer: HTMLElement;
+ workspaceUri: Uri;
+ workspaceFileUri: Uri;
+ clangdWorkerHandler: ClangdWorkerHandler;
+ lsMessageLocalPort: MessagePort;
}): Promise => {
- const vscodeApiConfig: MonacoVscodeApiConfig = {
- $type: 'extended',
- logLevel: LogLevel.Debug,
- serviceOverrides: {
- ...getKeybindingsServiceOverride(),
- ...getLifecycleServiceOverride(),
- ...getBannerServiceOverride(),
- ...getStatusBarServiceOverride(),
- ...getTitleBarServiceOverride(),
- ...getExplorerServiceOverride(),
- ...getRemoteAgentServiceOverride(),
- ...getEnvironmentServiceOverride(),
- ...getSecretStorageServiceOverride()
- },
- viewsConfig: {
- $type: 'ViewsService',
- htmlContainer: config.htmlContainer,
- htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
- viewsInitFunc: defaultViewsInit
- },
- workspaceConfig: {
- enableWorkspaceTrust: true,
- windowIndicator: {
- label: 'mlc-clangd-example',
- tooltip: '',
- command: ''
- },
- workspaceProvider: {
- trusted: true,
- async open() {
- window.open(window.location.href);
- return true;
- },
- workspace: {
- workspaceUri: config.workspaceFileUri
- },
- },
- configurationDefaults: {
- 'window.title': 'mlc-clangd-exampled${separator}${dirty}${activeEditorShort}'
- },
- productConfiguration: {
- nameShort: 'mlc-clangd-example',
- nameLong: 'mlc-clangd-example'
- }
+ const vscodeApiConfig: MonacoVscodeApiConfig = {
+ $type: 'extended',
+ logLevel: LogLevel.Debug,
+ serviceOverrides: {
+ ...getKeybindingsServiceOverride(),
+ ...getLifecycleServiceOverride(),
+ ...getBannerServiceOverride(),
+ ...getStatusBarServiceOverride(),
+ ...getTitleBarServiceOverride(),
+ ...getExplorerServiceOverride(),
+ ...getRemoteAgentServiceOverride(),
+ ...getEnvironmentServiceOverride(),
+ ...getSecretStorageServiceOverride()
+ },
+ viewsConfig: {
+ $type: 'ViewsService',
+ htmlContainer: config.htmlContainer,
+ htmlAugmentationInstructions: defaultHtmlAugmentationInstructions,
+ viewsInitFunc: defaultViewsInit
+ },
+ workspaceConfig: {
+ enableWorkspaceTrust: true,
+ windowIndicator: {
+ label: 'mlc-clangd-example',
+ tooltip: '',
+ command: ''
+ },
+ workspaceProvider: {
+ trusted: true,
+ async open() {
+ window.open(window.location.href);
+ return true;
},
- userConfiguration: {
- json: JSON.stringify({
- 'workbench.colorTheme': 'Default Dark Modern',
- 'editor.wordBasedSuggestions': 'off',
- 'editor.guides.bracketPairsHorizontal': true,
- 'editor.inlayHints.enabled': 'offUnlessPressed',
- 'editor.quickSuggestionsDelay': 200,
- 'editor.experimental.asyncTokenization': false
- })
- },
- extensions: [{
- config: {
- name: 'mlc-clangd-example',
- publisher: 'TypeFox',
- version: '1.0.0',
- engines: {
- vscode: '*'
- }
- }
- }],
- monacoWorkerFactory: configureDefaultWorkerFactory
- };
-
- const languageClientConfig: LanguageClientConfig = {
- languageId: 'cpp',
- connection: {
- options: {
- $type: 'WorkerDirect',
- worker: await config.clangdWorkerHandler.createWorker(),
- messagePort: config.lsMessageLocalPort
- }
- },
- restartOptions: {
- retries: 5,
- timeout: 1000,
- keepWorker: true
- },
- clientOptions: {
- documentSelector: ['cpp'],
- workspaceFolder: {
- index: 0,
- name: 'workspace',
- uri: config.workspaceUri
- }
+ workspace: {
+ workspaceUri: config.workspaceFileUri
}
- };
+ },
+ configurationDefaults: {
+ 'window.title': 'mlc-clangd-exampled${separator}${dirty}${activeEditorShort}'
+ },
+ productConfiguration: {
+ nameShort: 'mlc-clangd-example',
+ nameLong: 'mlc-clangd-example'
+ }
+ },
+ userConfiguration: {
+ json: JSON.stringify({
+ 'workbench.colorTheme': 'Default Dark Modern',
+ 'editor.wordBasedSuggestions': 'off',
+ 'editor.guides.bracketPairsHorizontal': true,
+ 'editor.inlayHints.enabled': 'offUnlessPressed',
+ 'editor.quickSuggestionsDelay': 200,
+ 'editor.experimental.asyncTokenization': false
+ })
+ },
+ extensions: [
+ {
+ config: {
+ name: 'mlc-clangd-example',
+ publisher: 'TypeFox',
+ version: '1.0.0',
+ engines: {
+ vscode: '*'
+ }
+ }
+ }
+ ],
+ monacoWorkerFactory: configureDefaultWorkerFactory
+ };
+
+ const languageClientConfig: LanguageClientConfig = {
+ languageId: 'cpp',
+ connection: {
+ options: {
+ $type: 'WorkerDirect',
+ worker: await config.clangdWorkerHandler.createWorker(),
+ messagePort: config.lsMessageLocalPort
+ }
+ },
+ restartOptions: {
+ retries: 5,
+ timeout: 1000,
+ keepWorker: true
+ },
+ clientOptions: {
+ documentSelector: ['cpp'],
+ workspaceFolder: {
+ index: 0,
+ name: 'workspace',
+ uri: config.workspaceUri
+ }
+ }
+ };
- const editorAppConfig: EditorAppConfig = {};
+ const editorAppConfig: EditorAppConfig = {};
- return {
- vscodeApiConfig,
- languageClientConfig,
- editorAppConfig
- };
+ return {
+ vscodeApiConfig,
+ languageClientConfig,
+ editorAppConfig
+ };
};
diff --git a/packages/examples/src/clangd/client/main.ts b/packages/examples/src/clangd/client/main.ts
index a69693792..bea6de354 100644
--- a/packages/examples/src/clangd/client/main.ts
+++ b/packages/examples/src/clangd/client/main.ts
@@ -3,7 +3,11 @@
* Licensed under the MIT License. See LICENSE in the package root for license information.
* ------------------------------------------------------------------------------------------ */
-import { RegisteredFileSystemProvider, RegisteredMemoryFile, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override';
+import {
+ RegisteredFileSystemProvider,
+ RegisteredMemoryFile,
+ registerFileSystemOverlay
+} from '@codingame/monaco-vscode-files-service-override';
import * as vscode from 'vscode';
// this is required syntax highlighting
import '@codingame/monaco-vscode-cpp-default-extension';
@@ -16,65 +20,65 @@ import { MainRemoteMessageChannelFs } from './mainRemoteMessageChannelFs.js';
import { ClangdWorkerHandler } from './workerHandler.js';
export const runClangdWrapper = async () => {
- const channelLs = new MessageChannel();
- const channelFs = new MessageChannel();
+ const channelLs = new MessageChannel();
+ const channelFs = new MessageChannel();
- const fileSystemProvider = new RegisteredFileSystemProvider(false);
- const workspaceFileUri = vscode.Uri.file(`${HOME_DIR}/workspace.code-workspace`);
- fileSystemProvider.registerFile(new RegisteredMemoryFile(workspaceFileUri, createDefaultWorkspaceContent(WORKSPACE_PATH)));
- registerFileSystemOverlay(1, fileSystemProvider);
+ const fileSystemProvider = new RegisteredFileSystemProvider(false);
+ const workspaceFileUri = vscode.Uri.file(`${HOME_DIR}/workspace.code-workspace`);
+ fileSystemProvider.registerFile(new RegisteredMemoryFile(workspaceFileUri, createDefaultWorkspaceContent(WORKSPACE_PATH)));
+ registerFileSystemOverlay(1, fileSystemProvider);
- const readiness = async () => {
- const resourceUri = vscode.Uri.file(`${WORKSPACE_PATH}/main.cpp`);
- await vscode.window.showTextDocument(resourceUri);
- };
- new MainRemoteMessageChannelFs(fileSystemProvider, channelFs.port1, readiness);
+ const readiness = async () => {
+ const resourceUri = vscode.Uri.file(`${WORKSPACE_PATH}/main.cpp`);
+ await vscode.window.showTextDocument(resourceUri);
+ };
+ new MainRemoteMessageChannelFs(fileSystemProvider, channelFs.port1, readiness);
- const clangdWorkerHandler = new ClangdWorkerHandler();
- const appConfig = await createClangdAppConfig({
- htmlContainer: document.body,
- workspaceUri: vscode.Uri.file(WORKSPACE_PATH),
- workspaceFileUri,
- clangdWorkerHandler,
- lsMessageLocalPort: channelLs.port1
- });
+ const clangdWorkerHandler = new ClangdWorkerHandler();
+ const appConfig = await createClangdAppConfig({
+ htmlContainer: document.body,
+ workspaceUri: vscode.Uri.file(WORKSPACE_PATH),
+ workspaceFileUri,
+ clangdWorkerHandler,
+ lsMessageLocalPort: channelLs.port1
+ });
- // perform global init
- const apiWrapper = new MonacoVscodeApiWrapper(appConfig.vscodeApiConfig);
- await apiWrapper.start();
+ // perform global init
+ const apiWrapper = new MonacoVscodeApiWrapper(appConfig.vscodeApiConfig);
+ await apiWrapper.start();
- const lcWrapper = new LanguageClientWrapper(appConfig.languageClientConfig);
+ const lcWrapper = new LanguageClientWrapper(appConfig.languageClientConfig);
- /* @vite-ignore */
- const compressedWorkspaceUrl = new URL('../../../resources/clangd/workspace.zip', import.meta.url).href;
- const initConfig = {
- lsMessagePort: channelLs.port2,
- fsMessagePort: channelFs.port2,
- clearIndexedDb: false,
- // set to true to use the compressed workspace at the specified URL
- useCompressedWorkspace: false,
- compressedWorkspaceUrl
- };
+ /* @vite-ignore */
+ const compressedWorkspaceUrl = new URL('../../../resources/clangd/workspace.zip', import.meta.url).href;
+ const initConfig = {
+ lsMessagePort: channelLs.port2,
+ fsMessagePort: channelFs.port2,
+ clearIndexedDb: false,
+ // set to true to use the compressed workspace at the specified URL
+ useCompressedWorkspace: false,
+ compressedWorkspaceUrl
+ };
- const startWrapper = async () => {
- await clangdWorkerHandler.init(initConfig);
- await clangdWorkerHandler.launch();
- await lcWrapper.start();
- };
+ const startWrapper = async () => {
+ await clangdWorkerHandler.init(initConfig);
+ await clangdWorkerHandler.launch();
+ await lcWrapper.start();
+ };
- try {
- document.querySelector('#button-start')?.addEventListener('click', async () => {
- disableElement('button-start', true);
- disableElement('button-start-fresh', true);
- await startWrapper();
- });
- document.querySelector('#button-start-fresh')?.addEventListener('click', async () => {
- initConfig.clearIndexedDb = true;
- disableElement('button-start', true);
- disableElement('button-start-fresh', true);
- await startWrapper();
- });
- } catch (e) {
- console.error(e);
- }
+ try {
+ document.querySelector('#button-start')?.addEventListener('click', async () => {
+ disableElement('button-start', true);
+ disableElement('button-start-fresh', true);
+ await startWrapper();
+ });
+ document.querySelector('#button-start-fresh')?.addEventListener('click', async () => {
+ initConfig.clearIndexedDb = true;
+ disableElement('button-start', true);
+ disableElement('button-start-fresh', true);
+ await startWrapper();
+ });
+ } catch (e) {
+ console.error(e);
+ }
};
diff --git a/packages/examples/src/clangd/client/mainRemoteMessageChannelFs.ts b/packages/examples/src/clangd/client/mainRemoteMessageChannelFs.ts
index a494b0d3f..9b0ef0b3d 100644
--- a/packages/examples/src/clangd/client/mainRemoteMessageChannelFs.ts
+++ b/packages/examples/src/clangd/client/mainRemoteMessageChannelFs.ts
@@ -11,79 +11,80 @@ import { ComChannelEndpoint, RawPayload, WorkerMessage, type ComRouter } from 'w
* Answer the file create request
*/
export class FileHandlerMain implements ComRouter {
+ private endpointFs?: ComChannelEndpoint;
+ private fileSystemProvider: RegisteredFileSystemProvider;
+ private readiness: () => void;
- private endpointFs?: ComChannelEndpoint;
- private fileSystemProvider: RegisteredFileSystemProvider;
- private readiness: () => void;
+ constructor(fileSystemProvider: RegisteredFileSystemProvider, readiness: () => void) {
+ this.fileSystemProvider = fileSystemProvider;
+ this.readiness = readiness;
+ }
- constructor(fileSystemProvider: RegisteredFileSystemProvider, readiness: () => void) {
- this.fileSystemProvider = fileSystemProvider;
- this.readiness = readiness;
- }
+ setComChannelEndpoint(comChannelEndpoint: ComChannelEndpoint): void {
+ this.endpointFs = comChannelEndpoint;
+ }
- setComChannelEndpoint(comChannelEndpoint: ComChannelEndpoint): void {
- this.endpointFs = comChannelEndpoint;
- }
+ async fs_driver_init(message: WorkerMessage) {
+ await this.endpointFs?.sentAnswer({
+ message: WorkerMessage.createFromExisting(message, {
+ overrideCmd: 'fs_driver_init_confirm'
+ }),
+ awaitAnswer: false
+ });
- async fs_driver_init(message: WorkerMessage) {
- await this.endpointFs?.sentAnswer({
- message: WorkerMessage.createFromExisting(message, {
- overrideCmd: 'fs_driver_init_confirm',
- }),
- awaitAnswer: false
- });
+ // send double confirmation
+ await this.endpointFs?.sentMessage({
+ message: WorkerMessage.fromPayload(
+ new RawPayload({
+ hello: 'worker'
+ }),
+ 'fs_follower_init'
+ ),
+ awaitAnswer: true,
+ expectedAnswer: 'fs_follower_init_confirm'
+ });
+ }
- // send double confirmation
- await this.endpointFs?.sentMessage({
- message: WorkerMessage.fromPayload(new RawPayload({
- hello: 'worker',
- }), 'fs_follower_init'),
- awaitAnswer: true,
- expectedAnswer: 'fs_follower_init_confirm'
- });
- }
+ async syncFile(message: WorkerMessage) {
+ const rawPayload = message.payloads[0] as RawPayload;
+ const resourceUri = vscode.Uri.file(rawPayload.message.raw.resourceUri);
+ this.fileSystemProvider.registerFile(new RegisteredMemoryFile(resourceUri, rawPayload.message.raw.content));
- async syncFile(message: WorkerMessage) {
- const rawPayload = message.payloads[0] as RawPayload;
- const resourceUri = vscode.Uri.file(rawPayload.message.raw.resourceUri);
- this.fileSystemProvider.registerFile(new RegisteredMemoryFile(resourceUri, rawPayload.message.raw.content));
+ await this.endpointFs?.sentAnswer({
+ message: WorkerMessage.createFromExisting(message, {
+ overrideCmd: 'syncFile_confirm',
+ overridePayloads: new RawPayload({
+ status: 'created',
+ message: `Created: ${rawPayload.message.raw.resourceUri}`
+ })
+ })
+ });
+ }
- await this.endpointFs?.sentAnswer({
- message: WorkerMessage.createFromExisting(message, {
- overrideCmd: 'syncFile_confirm',
- overridePayloads: new RawPayload({
- status: 'created',
- message: `Created: ${rawPayload.message.raw.resourceUri}`
- })
- })
- });
- }
+ async fs_driver_ready(message: WorkerMessage) {
+ this.readiness();
- async fs_driver_ready(message: WorkerMessage) {
- this.readiness();
-
- await this.endpointFs?.sentAnswer({
- message: WorkerMessage.createFromExisting(message, {
- overrideCmd: 'fs_driver_ready_confirm',
- }),
- awaitAnswer: false
- });
- }
+ await this.endpointFs?.sentAnswer({
+ message: WorkerMessage.createFromExisting(message, {
+ overrideCmd: 'fs_driver_ready_confirm'
+ }),
+ awaitAnswer: false
+ });
+ }
}
export class MainRemoteMessageChannelFs {
-
- constructor(fileSystemProvider: RegisteredFileSystemProvider, port: MessagePort, readiness: () => void) {
- const fileHandlerMain = new FileHandlerMain(fileSystemProvider, readiness);
- const endpointFs = new ComChannelEndpoint({
- endpointId: 21,
- endpointName: 'port_main_fs',
- endpointConfig: {
- $type: 'DirectImplConfig',
- impl: port
- },
- verbose: false
- });
- endpointFs.connect(fileHandlerMain);
- }
+ constructor(fileSystemProvider: RegisteredFileSystemProvider, port: MessagePort, readiness: () => void) {
+ const fileHandlerMain = new FileHandlerMain(fileSystemProvider, readiness);
+ const endpointFs = new ComChannelEndpoint({
+ endpointId: 21,
+ endpointName: 'port_main_fs',
+ endpointConfig: {
+ $type: 'DirectImplConfig',
+ impl: port
+ },
+ verbose: false
+ });
+ endpointFs.connect(fileHandlerMain);
+ }
}
diff --git a/packages/examples/src/clangd/client/workerHandler.ts b/packages/examples/src/clangd/client/workerHandler.ts
index 9378c94a4..0eaa62a9b 100644
--- a/packages/examples/src/clangd/client/workerHandler.ts
+++ b/packages/examples/src/clangd/client/workerHandler.ts
@@ -6,65 +6,65 @@
import { ComChannelEndpoint, type ComRouter, RawPayload, WorkerMessage } from 'wtd-core';
class ClangdInteractionMain implements ComRouter {
+ setComChannelEndpoint(_comChannelEndpoint: ComChannelEndpoint): void {}
- setComChannelEndpoint(_comChannelEndpoint: ComChannelEndpoint): void {
- }
+ clangd_progress(_message: WorkerMessage) {}
- clangd_progress(_message: WorkerMessage) { }
-
- clangd_error(_message: WorkerMessage) { }
+ clangd_error(_message: WorkerMessage) {}
}
export class ClangdWorkerHandler {
+ private interactionMain: ClangdInteractionMain = new ClangdInteractionMain();
+ private endpointMain?: ComChannelEndpoint;
- private interactionMain: ClangdInteractionMain = new ClangdInteractionMain();
- private endpointMain?: ComChannelEndpoint;
-
- async createWorker() {
- const languageServerWorker = new Worker(new URL('../worker/clangd-server.ts', import.meta.url), {
- type: 'module',
- name: 'Clangd Server Worker',
- });
- this.endpointMain = new ComChannelEndpoint({
- endpointId: 1,
- endpointConfig: {
- $type: 'DirectImplConfig',
- impl: languageServerWorker
- },
- verbose: true,
- endpointName: 'main_worker'
- });
- this.endpointMain.connect(this.interactionMain);
+ async createWorker() {
+ const languageServerWorker = new Worker(new URL('../worker/clangd-server.ts', import.meta.url), {
+ type: 'module',
+ name: 'Clangd Server Worker'
+ });
+ this.endpointMain = new ComChannelEndpoint({
+ endpointId: 1,
+ endpointConfig: {
+ $type: 'DirectImplConfig',
+ impl: languageServerWorker
+ },
+ verbose: true,
+ endpointName: 'main_worker'
+ });
+ this.endpointMain.connect(this.interactionMain);
- return languageServerWorker;
- }
+ return languageServerWorker;
+ }
- async init(config: {
- lsMessagePort: MessagePort,
- fsMessagePort: MessagePort,
- clearIndexedDb: boolean,
- useCompressedWorkspace: boolean,
- compressedWorkspaceUrl?: string
- }) {
- await this.endpointMain?.sentMessage({
- message: WorkerMessage.fromPayload(new RawPayload({
- lsMessagePort: config.lsMessagePort,
- fsMessagePort: config.fsMessagePort,
- clearIndexedDb: config.clearIndexedDb,
- useCompressedWorkspace: config.useCompressedWorkspace,
- compressedWorkspaceUrl: config.compressedWorkspaceUrl
- }), 'clangd_init'),
- transferables: [config.lsMessagePort, config.fsMessagePort],
- awaitAnswer: true,
- expectedAnswer: 'clangd_init_complete'
- });
- }
+ async init(config: {
+ lsMessagePort: MessagePort;
+ fsMessagePort: MessagePort;
+ clearIndexedDb: boolean;
+ useCompressedWorkspace: boolean;
+ compressedWorkspaceUrl?: string;
+ }) {
+ await this.endpointMain?.sentMessage({
+ message: WorkerMessage.fromPayload(
+ new RawPayload({
+ lsMessagePort: config.lsMessagePort,
+ fsMessagePort: config.fsMessagePort,
+ clearIndexedDb: config.clearIndexedDb,
+ useCompressedWorkspace: config.useCompressedWorkspace,
+ compressedWorkspaceUrl: config.compressedWorkspaceUrl
+ }),
+ 'clangd_init'
+ ),
+ transferables: [config.lsMessagePort, config.fsMessagePort],
+ awaitAnswer: true,
+ expectedAnswer: 'clangd_init_complete'
+ });
+ }
- async launch() {
- await this.endpointMain?.sentMessage({
- message: WorkerMessage.fromPayload(new RawPayload({}), 'clangd_launch'),
- awaitAnswer: true,
- expectedAnswer: 'clangd_launch_complete'
- });
- }
+ async launch() {
+ await this.endpointMain?.sentMessage({
+ message: WorkerMessage.fromPayload(new RawPayload({}), 'clangd_launch'),
+ awaitAnswer: true,
+ expectedAnswer: 'clangd_launch_complete'
+ });
+ }
}
diff --git a/packages/examples/src/clangd/worker/clangd-server.ts b/packages/examples/src/clangd/worker/clangd-server.ts
index 6799dd7ac..809625a5c 100644
--- a/packages/examples/src/clangd/worker/clangd-server.ts
+++ b/packages/examples/src/clangd/worker/clangd-server.ts
@@ -17,460 +17,458 @@ import JSZip from 'jszip';
declare const self: DedicatedWorkerGlobalScope;
interface RequiredResources {
- // oxlint-disable-next-line @typescript-eslint/no-explicit-any
- ClangdJsModule: any;
- wasmDataUrl: string;
+ // oxlint-disable-next-line @typescript-eslint/no-explicit-any
+ ClangdJsModule: any;
+ wasmDataUrl: string;
}
export class ClangdInteractionWorker implements ComRouter {
-
- private endpointWorker?: ComChannelEndpoint;
-
- private reader?: BrowserMessageReader;
- private writer?: BrowserMessageWriter;
-
- private lsMessagePort?: MessagePort;
- private fsMessagePort?: MessagePort;
-
- private emscriptenFS?: typeof FS;
- private remoteFs?: WorkerRemoteMessageChannelFs;
-
- private clearIndexedDb: boolean;
- private useCompressedWorkspace: boolean;
- private compressedWorkspaceUrl?: string;
-
- private startingAwait?: Promise;
- private startingResolve: (value: void | PromiseLike) => void;
-
- private synchingFSAwait?: Promise;
- private synchingFSResolve: (value: void | PromiseLike) => void;
-
- setComChannelEndpoint(comChannelEndpoint: ComChannelEndpoint): void {
- this.endpointWorker = comChannelEndpoint;
- }
-
- /**
- * Triggered by worker message
- */
- async clangd_init(message: WorkerMessage) {
- const rawPayload = (message.payloads![0] as RawPayload).message.raw;
- this.lsMessagePort = rawPayload.lsMessagePort as MessagePort;
- this.fsMessagePort = rawPayload.fsMessagePort as MessagePort;
- this.clearIndexedDb = rawPayload.clearIndexedDb as boolean;
- this.useCompressedWorkspace = rawPayload.useCompressedWorkspace as boolean;
- this.compressedWorkspaceUrl = rawPayload.compressedWorkspaceUrl as string;
-
- this.reader = new BrowserMessageReader(this.lsMessagePort);
- this.writer = new BrowserMessageWriter(this.lsMessagePort);
-
- await this.endpointWorker?.sentAnswer({
- message: WorkerMessage.createFromExisting(message, {
- overrideCmd: 'clangd_init_complete'
- })
- });
- }
-
- /**
- * Triggered by worker message
- */
- async clangd_launch(message: WorkerMessage) {
- // load everything needed beforehand
- const requiredResurces = await this.loadRequiredResources();
-
- // start the clangd language server
- const clangd = await this.runClangdLanguageServer(requiredResurces);
-
- // perform all file system updates
- this.emscriptenFS = clangd.FS as typeof FS;
- await this.updateWorkerFilesystem(requiredResurces);
- await this.updateRemoteFilesystem();
-
- // run main clangd
- // oxlint-disable-next-line @typescript-eslint/no-explicit-any
- (clangd as any).callMain([]);
-
- // send the launch complete message to the client
- await this.endpointWorker?.sentAnswer({
- message: WorkerMessage.createFromExisting(message, {
- overrideCmd: 'clangd_launch_complete'
- })
- });
+ private endpointWorker?: ComChannelEndpoint;
+
+ private reader?: BrowserMessageReader;
+ private writer?: BrowserMessageWriter;
+
+ private lsMessagePort?: MessagePort;
+ private fsMessagePort?: MessagePort;
+
+ private emscriptenFS?: typeof FS;
+ private remoteFs?: WorkerRemoteMessageChannelFs;
+
+ private clearIndexedDb: boolean;
+ private useCompressedWorkspace: boolean;
+ private compressedWorkspaceUrl?: string;
+
+ private startingAwait?: Promise;
+ private startingResolve: (value: void | PromiseLike) => void;
+
+ private synchingFSAwait?: Promise;
+ private synchingFSResolve: (value: void | PromiseLike) => void;
+
+ setComChannelEndpoint(comChannelEndpoint: ComChannelEndpoint): void {
+ this.endpointWorker = comChannelEndpoint;
+ }
+
+ /**
+ * Triggered by worker message
+ */
+ async clangd_init(message: WorkerMessage) {
+ const rawPayload = (message.payloads![0] as RawPayload).message.raw;
+ this.lsMessagePort = rawPayload.lsMessagePort as MessagePort;
+ this.fsMessagePort = rawPayload.fsMessagePort as MessagePort;
+ this.clearIndexedDb = rawPayload.clearIndexedDb as boolean;
+ this.useCompressedWorkspace = rawPayload.useCompressedWorkspace as boolean;
+ this.compressedWorkspaceUrl = rawPayload.compressedWorkspaceUrl as string;
+
+ this.reader = new BrowserMessageReader(this.lsMessagePort);
+ this.writer = new BrowserMessageWriter(this.lsMessagePort);
+
+ await this.endpointWorker?.sentAnswer({
+ message: WorkerMessage.createFromExisting(message, {
+ overrideCmd: 'clangd_init_complete'
+ })
+ });
+ }
+
+ /**
+ * Triggered by worker message
+ */
+ async clangd_launch(message: WorkerMessage) {
+ // load everything needed beforehand
+ const requiredResurces = await this.loadRequiredResources();
+
+ // start the clangd language server
+ const clangd = await this.runClangdLanguageServer(requiredResurces);
+
+ // perform all file system updates
+ this.emscriptenFS = clangd.FS as typeof FS;
+ await this.updateWorkerFilesystem(requiredResurces);
+ await this.updateRemoteFilesystem();
+
+ // run main clangd
+ // oxlint-disable-next-line @typescript-eslint/no-explicit-any
+ (clangd as any).callMain([]);
+
+ // send the launch complete message to the client
+ await this.endpointWorker?.sentAnswer({
+ message: WorkerMessage.createFromExisting(message, {
+ overrideCmd: 'clangd_launch_complete'
+ })
+ });
+ }
+
+ private async loadRequiredResources(): Promise {
+ const clangdWasmUrl = new URL('../../../resources/clangd/wasm/clangd.wasm', import.meta.url);
+ const clangdJsUrl = new URL('../../../resources/clangd/wasm/clangd.js', import.meta.url);
+
+ // Pre-fetch wasm file
+ const wasmReader = (await fetch(clangdWasmUrl)).body!.getReader();
+
+ const chunks: BlobPart[] = [];
+ let loadingComplete = false;
+ while (!loadingComplete) {
+ const { done, value } = await wasmReader.read();
+ loadingComplete = done;
+ if (value !== undefined) {
+ chunks.push(value);
+ }
}
-
- private async loadRequiredResources(): Promise {
- const clangdWasmUrl = new URL('../../../resources/clangd/wasm/clangd.wasm', import.meta.url);
- const clangdJsUrl = new URL('../../../resources/clangd/wasm/clangd.js', import.meta.url);
-
- // Pre-fetch wasm file
- const wasmReader = (await fetch(clangdWasmUrl)).body!.getReader();
-
- const chunks: BlobPart[] = [];
- let loadingComplete = false;
- while (!loadingComplete) {
- const { done, value } = await wasmReader.read();
- loadingComplete = done;
- if (value !== undefined) {
- chunks.push(value);
- }
+ const wasmBlob = new Blob(chunks, { type: 'application/wasm' });
+ const wasmDataUrl = URL.createObjectURL(wasmBlob);
+
+ const jsModule = import(`${clangdJsUrl}`);
+ const { default: ClangdJsModule } = await jsModule;
+
+ return { ClangdJsModule, wasmDataUrl };
+ }
+
+ private markStarting() {
+ this.startingAwait = new Promise((resolve) => {
+ this.startingResolve = resolve;
+ });
+ }
+
+ private markStarted() {
+ this.startingResolve();
+ this.startingAwait = undefined;
+ }
+
+ /**
+ * Prepares & starts up a clangd language server instance
+ * @returns
+ */
+ private async runClangdLanguageServer(requiredResurces: RequiredResources) {
+ this.markStarting();
+
+ const textEncoder = new TextEncoder();
+ let resolveStdinReady = () => {};
+ const stdinChunks: string[] = [];
+ const currentStdinChunk: Array = [];
+
+ const stdin = (): number | null => {
+ if (currentStdinChunk.length === 0) {
+ if (stdinChunks.length === 0) {
+ // Should not reach here
+ // stdinChunks.push("Content-Length: 0\r\n", "\r\n");
+ console.error('Try to fetch exhausted stdin');
+ return null;
}
- const wasmBlob = new Blob(chunks, { type: 'application/wasm' });
- const wasmDataUrl = URL.createObjectURL(wasmBlob);
-
- const jsModule = import(`${clangdJsUrl}`);
- const { default: ClangdJsModule } = await jsModule;
-
- return { ClangdJsModule, wasmDataUrl };
+ const nextChunk = stdinChunks.shift()!;
+ currentStdinChunk.push(...textEncoder.encode(nextChunk), null);
+ }
+ return currentStdinChunk.shift()!;
+ };
+
+ const jsonStream = new JsonStream();
+
+ const stdout = async (charCode: number) => {
+ const jsonOrNull = jsonStream.insert(charCode);
+ if (jsonOrNull !== null) {
+ console.log('%c%s', 'color: green', jsonOrNull);
+ await this.writer?.write(JSON.parse(jsonOrNull));
+ }
+ };
+
+ const LF = 10;
+ let stderrLine = '';
+ const stderr = async (charCode: number) => {
+ if (charCode === LF) {
+ console.log('%c%s', 'color: darkorange', stderrLine);
+ stderrLine = '';
+ } else {
+ stderrLine += String.fromCharCode(charCode);
+ }
+ };
+
+ const stdinReady = async () => {
+ if (stdinChunks.length === 0) {
+ return new Promise((r) => (resolveStdinReady = r));
+ }
+ };
+
+ const onAbort = async () => {
+ this.writer?.end();
+
+ await this.endpointWorker?.sentMessage({
+ message: WorkerMessage.fromPayload(
+ new RawPayload({
+ type: 'error',
+ value: 'clangd aborted'
+ }),
+ 'clangd_error'
+ )
+ });
+ };
+
+ const onRuntimeInitialized = async () => {
+ console.log('%c%s', 'color: green', 'Clangd runtime initialized');
+ this.markStarted();
+ return Promise.resolve();
+ };
+
+ const clangd = await requiredResurces.ClangdJsModule({
+ thisProgram: '/usr/bin/clangd',
+ locateFile: (path: string, prefix: string) => {
+ return path.endsWith('.wasm') ? requiredResurces.wasmDataUrl : `${prefix}${path}`;
+ },
+ stdinReady,
+ stdin,
+ stdout,
+ stderr,
+ onExit: onAbort,
+ onAbort,
+ onRuntimeInitialized
+ });
+
+ // listen for messages from the language server
+ this.reader?.listen((data) => {
+ // non-ASCII characters cause bad Content-Length. Just escape them.
+ const body = JSON.stringify(data).replace(/[\u007F-\uFFFF]/g, (ch) => {
+ return '\\u' + ch.codePointAt(0)!.toString(16).padStart(4, '0');
+ });
+ const header = `Content-Length: ${body.length}\r\n`;
+ const delimiter = '\r\n';
+ stdinChunks.push(header, delimiter, body);
+ resolveStdinReady();
+ // console.log("%c%s", "color: red", `${header}${delimiter}${body}`);
+ });
+
+ await this.startingAwait;
+
+ return clangd;
+ }
+
+ private markSynchingFS() {
+ this.synchingFSAwait = new Promise((resolve) => {
+ this.synchingFSResolve = resolve;
+ });
+ }
+
+ private markSynchingFSDone() {
+ this.synchingFSResolve();
+ this.synchingFSAwait = undefined;
+ }
+
+ /**
+ * Initialize the filesystem using the fs's persistent source. Invoked on start-up
+ */
+ private async populateFS() {
+ console.log('Populating filesystem: Start');
+ this.markSynchingFS();
+ this.syncFS(true);
+ await this.synchingFSAwait;
+ console.log('Populating filesystem: End');
+ }
+
+ /**
+ * Persist the filesystem to IndexedDB. Can be invoked on shutdown or periodically
+ */
+ private async persistFS() {
+ console.log('Persisting filesystem: Start');
+ this.markSynchingFS();
+ this.syncFS(false);
+ await this.synchingFSAwait;
+ console.log('Persisting filesystem: End');
+ }
+
+ /**
+ * Used to sync the filesystem from memory to IndexedDB or vice versa:
+ * populate fs = true; persist fs = false
+ * @param readOrWrite Whether to read or write the filesystem
+ */
+ private syncFS(readOrWrite: boolean) {
+ if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
+
+ this.emscriptenFS.syncfs(readOrWrite, (err) => {
+ if (err !== null) {
+ console.error(`Error syncing filesystem: ${err}`);
+ }
+ this.markSynchingFSDone();
+ });
+ }
+
+ private async updateWorkerFilesystem(requiredResurces: RequiredResources) {
+ if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
+
+ const t0 = performance.now();
+ console.log('Updating Worker FS');
+
+ // Clear the IndexedDB filesystem if requested
+ if (this.clearIndexedDb) {
+ indexedDB.deleteDatabase(WORKSPACE_PATH);
}
- private markStarting() {
- this.startingAwait = new Promise((resolve) => {
- this.startingResolve = resolve;
- });
- }
-
- private markStarted() {
- this.startingResolve();
- this.startingAwait = undefined;
- }
-
- /**
- * Prepares & starts up a clangd language server instance
- * @returns
- */
- private async runClangdLanguageServer(requiredResurces: RequiredResources) {
- this.markStarting();
-
- const textEncoder = new TextEncoder();
- let resolveStdinReady = () => { };
- const stdinChunks: string[] = [];
- const currentStdinChunk: Array = [];
-
- const stdin = (): number | null => {
- if (currentStdinChunk.length === 0) {
- if (stdinChunks.length === 0) {
- // Should not reach here
- // stdinChunks.push("Content-Length: 0\r\n", "\r\n");
- console.error('Try to fetch exhausted stdin');
- return null;
- }
- const nextChunk = stdinChunks.shift()!;
- currentStdinChunk.push(...textEncoder.encode(nextChunk), null);
- }
- return currentStdinChunk.shift()!;
- };
-
- const jsonStream = new JsonStream();
-
- const stdout = async (charCode: number) => {
- const jsonOrNull = jsonStream.insert(charCode);
- if (jsonOrNull !== null) {
- console.log('%c%s', 'color: green', jsonOrNull);
- await this.writer?.write(JSON.parse(jsonOrNull));
- }
- };
-
- const LF = 10;
- let stderrLine = '';
- const stderr = async (charCode: number) => {
- if (charCode === LF) {
- console.log('%c%s', 'color: darkorange', stderrLine);
- stderrLine = '';
- } else {
- stderrLine += String.fromCharCode(charCode);
- }
- };
-
- const stdinReady = async () => {
- if (stdinChunks.length === 0) {
- return new Promise((r) => (resolveStdinReady = r));
- }
- };
-
- const onAbort = async () => {
- this.writer?.end();
-
- await this.endpointWorker?.sentMessage({
- message: WorkerMessage.fromPayload(
- new RawPayload({
- type: 'error',
- value: 'clangd aborted',
- }),
- 'clangd_error')
- });
- };
-
- const onRuntimeInitialized = async () => {
- console.log('%c%s', 'color: green', 'Clangd runtime initialized');
- this.markStarted();
- return Promise.resolve();
- };
-
- const clangd = await requiredResurces.ClangdJsModule({
- thisProgram: '/usr/bin/clangd',
- locateFile: (path: string, prefix: string) => {
- return path.endsWith('.wasm') ? requiredResurces.wasmDataUrl : `${prefix}${path}`;
- },
- stdinReady,
- stdin,
- stdout,
- stderr,
- onExit: onAbort,
- onAbort,
- onRuntimeInitialized
- });
-
- // listen for messages from the language server
- this.reader?.listen((data) => {
- // non-ASCII characters cause bad Content-Length. Just escape them.
- const body = JSON.stringify(data).replace(/[\u007F-\uFFFF]/g, (ch) => {
- return '\\u' + ch.codePointAt(0)!.toString(16).padStart(4, '0');
- });
- const header = `Content-Length: ${body.length}\r\n`;
- const delimiter = '\r\n';
- stdinChunks.push(header, delimiter, body);
- resolveStdinReady();
- // console.log("%c%s", "color: red", `${header}${delimiter}${body}`);
- });
-
- await this.startingAwait;
-
- return clangd;
- }
+ this.emscriptenFS.createPreloadedFile('/', 'clangd.wasm', requiredResurces.wasmDataUrl, true, true);
- private markSynchingFS() {
- this.synchingFSAwait = new Promise((resolve) => {
- this.synchingFSResolve = resolve;
- });
- }
+ await this.loadWorkspaceFiles();
- private markSynchingFSDone() {
- this.synchingFSResolve();
- this.synchingFSAwait = undefined;
- }
+ const t1 = performance.now();
+ const msg = `Worker FS: File loading completed in ${t1 - t0}ms.`;
+ console.log(msg);
+ }
- /**
- * Initialize the filesystem using the fs's persistent source. Invoked on start-up
- */
- private async populateFS() {
- console.log('Populating filesystem: Start');
- this.markSynchingFS();
- this.syncFS(true);
- await this.synchingFSAwait;
- console.log('Populating filesystem: End');
- }
+ /**
+ * Loads workspace files separately or the compressed workspace from a zip archive
+ */
+ private async loadWorkspaceFiles() {
+ if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
- /**
- * Persist the filesystem to IndexedDB. Can be invoked on shutdown or periodically
- */
- private async persistFS() {
- console.log('Persisting filesystem: Start');
- this.markSynchingFS();
- this.syncFS(false);
- await this.synchingFSAwait;
- console.log('Persisting filesystem: End');
- }
+ // setup & prepare the filesystem
+ this.emscriptenFS.mkdir(WORKSPACE_PATH);
- /**
- * Used to sync the filesystem from memory to IndexedDB or vice versa:
- * populate fs = true; persist fs = false
- * @param readOrWrite Whether to read or write the filesystem
- */
- private syncFS(readOrWrite: boolean) {
- if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
-
- this.emscriptenFS.syncfs(readOrWrite, (err) => {
- if (err !== null) {
- console.error(`Error syncing filesystem: ${err}`);
- }
- this.markSynchingFSDone();
- });
+ // Mounting IndexedDB filesystem
+ // oxlint-disable-next-line @typescript-eslint/no-explicit-any
+ this.emscriptenFS.mount((this.emscriptenFS as any).filesystems.IDBFS, {}, WORKSPACE_PATH);
+
+ // Synchronize the filesystem from IndexedDB to memory
+ await this.populateFS();
+
+ // Determines whether the workspace is already loaded from IndexedDB
+ let isWorkspaceLoaded = true;
+ try {
+ this.emscriptenFS.lookupPath(`${WORKSPACE_PATH}/.clangd`, { parent: false });
+ console.log('Workspace FOUND');
+ } catch (e) {
+ console.warn('Workspace NOT found: ' + e);
+ isWorkspaceLoaded = false;
}
- private async updateWorkerFilesystem(requiredResurces: RequiredResources) {
- if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
-
- const t0 = performance.now();
- console.log('Updating Worker FS');
-
- // Clear the IndexedDB filesystem if requested
- if (this.clearIndexedDb) {
- indexedDB.deleteDatabase(WORKSPACE_PATH);
+ if (!isWorkspaceLoaded) {
+ let mainFiles: Record Promise> = {};
+ if (this.useCompressedWorkspace && this.compressedWorkspaceUrl !== undefined) {
+ // Fetches a compressed workspace from a given URL (zip file)
+ // The additional conversion to array buffer is necessary for JSZip to work correctly
+ // It is expected that there is a workspace directory at top level in the zip file
+ const compressedWorkspace = await (await fetch(this.compressedWorkspaceUrl)).arrayBuffer();
+ const zip = await JSZip.loadAsync(compressedWorkspace);
+
+ for (const [relativePath, file] of Object.entries(zip.files)) {
+ if (/\.(cpp|c|h|hpp|)|.clangd$/.test(relativePath)) {
+ // trim off the leading 'workspace' directory part of the path, the rest is okay to have
+ const rpath = relativePath.replace(/^workspace/, '');
+ mainFiles[rpath] = () => file.async('string');
+ }
}
- this.emscriptenFS.createPreloadedFile('/', 'clangd.wasm', requiredResurces.wasmDataUrl, true, true);
-
- await this.loadWorkspaceFiles();
+ await this.processInputFiles(mainFiles, '../../../resources/clangd/workspace');
+ } else {
+ // write clang config
+ this.emscriptenFS.writeFile(`${WORKSPACE_PATH}/.clangd`, clangdConfig);
- const t1 = performance.now();
- const msg = `Worker FS: File loading completed in ${t1 - t0}ms.`;
- console.log(msg);
+ mainFiles = import.meta.glob('../../../resources/clangd/workspace/*.{cpp,c,h,hpp}', { query: '?raw' });
+ await this.processInputFiles(mainFiles, '../../../resources/clangd/workspace');
+ }
}
- /**
- * Loads workspace files separately or the compressed workspace from a zip archive
- */
- private async loadWorkspaceFiles() {
- if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
-
- // setup & prepare the filesystem
- this.emscriptenFS.mkdir(WORKSPACE_PATH);
-
- // Mounting IndexedDB filesystem
- // oxlint-disable-next-line @typescript-eslint/no-explicit-any
- this.emscriptenFS.mount((this.emscriptenFS as any).filesystems.IDBFS, {}, WORKSPACE_PATH);
-
- // Synchronize the filesystem from IndexedDB to memory
- await this.populateFS();
-
- // Determines whether the workspace is already loaded from IndexedDB
- let isWorkspaceLoaded = true;
- try {
- this.emscriptenFS.lookupPath(`${WORKSPACE_PATH}/.clangd`, { parent: false });
- console.log('Workspace FOUND');
- } catch (e) {
- console.warn('Workspace NOT found: ' + e);
- isWorkspaceLoaded = false;
+ // save the workspace to IndexedDB
+ await this.persistFS();
+ }
+
+ private async processInputFiles(files: Record Promise>, dirReplacer: string) {
+ if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
+
+ const dirsToCreate = new Set();
+ const filesToUse: Record Promise> = {};
+ for (const [sourceFile, content] of Object.entries(files)) {
+ let shortSourceFile = sourceFile.replace(dirReplacer, '');
+ if (!shortSourceFile.startsWith('//')) {
+ shortSourceFile = shortSourceFile.substring(1);
+ }
+ const targetFile = `${WORKSPACE_PATH}/${shortSourceFile}`;
+ const targetDir = targetFile.substring(0, targetFile.lastIndexOf('/'));
+
+ // store only un-ignore target files
+ filesToUse[targetFile] = content;
+
+ // List all parent directories
+ let dirToCreate = '';
+ const targetDirParts = targetDir.split('/');
+ for (const part of targetDirParts) {
+ if (part.length > 0) {
+ dirToCreate = `${dirToCreate}/${part}`;
+ // set reduces to unique directories
+ dirsToCreate.add(dirToCreate);
}
-
- if (!isWorkspaceLoaded) {
- let mainFiles: Record Promise> = {};
- if (this.useCompressedWorkspace && this.compressedWorkspaceUrl !== undefined) {
-
- // Fetches a compressed workspace from a given URL (zip file)
- // The additional conversion to array buffer is necessary for JSZip to work correctly
- // It is expected that there is a workspace directory at top level in the zip file
- const compressedWorkspace = await (await fetch(this.compressedWorkspaceUrl)).arrayBuffer();
- const zip = await JSZip.loadAsync(compressedWorkspace);
-
- for (const [relativePath, file] of Object.entries(zip.files)) {
- if (/\.(cpp|c|h|hpp|)|.clangd$/.test(relativePath)) {
- // trim off the leading 'workspace' directory part of the path, the rest is okay to have
- const rpath = relativePath.replace(/^workspace/, '');
- mainFiles[rpath] = () => file.async('string');
- }
- }
-
- await this.processInputFiles(mainFiles, '../../../resources/clangd/workspace');
- } else {
- // write clang config
- this.emscriptenFS.writeFile(`${WORKSPACE_PATH}/.clangd`, clangdConfig);
-
- mainFiles = import.meta.glob('../../../resources/clangd/workspace/*.{cpp,c,h,hpp}', { query: '?raw' });
- await this.processInputFiles(mainFiles, '../../../resources/clangd/workspace');
- }
- }
-
- // save the workspace to IndexedDB
- await this.persistFS();
+ }
}
- private async processInputFiles(files: Record Promise>, dirReplacer: string) {
- if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
-
- const dirsToCreate = new Set();
- const filesToUse: Record Promise> = {};
- for (const [sourceFile, content] of Object.entries(files)) {
-
- let shortSourceFile = sourceFile.replace(dirReplacer, '');
- if (!shortSourceFile.startsWith('//')) {
- shortSourceFile = shortSourceFile.substring(1);
- }
- const targetFile = `${WORKSPACE_PATH}/${shortSourceFile}`;
- const targetDir = targetFile.substring(0, targetFile.lastIndexOf('/'));
-
- // store only un-ignore target files
- filesToUse[targetFile] = content;
-
- // List all parent directories
- let dirToCreate = '';
- const targetDirParts = targetDir.split('/');
- for (const part of targetDirParts) {
-
- if (part.length > 0) {
- dirToCreate = `${dirToCreate}/${part}`;
- // set reduces to unique directories
- dirsToCreate.add(dirToCreate);
- }
- }
+ // create unique directories
+ for (const dirToCreate of dirsToCreate) {
+ try {
+ this.emscriptenFS.mkdir(dirToCreate);
+ const { mode } = this.emscriptenFS.lookupPath(dirToCreate, { parent: false }).node;
+ if (this.emscriptenFS.isDir(mode)) {
+ console.log(`Create dir: ${dirToCreate} mode: ${mode}`);
}
-
- // create unique directories
- for (const dirToCreate of dirsToCreate) {
- try {
- this.emscriptenFS.mkdir(dirToCreate);
- const { mode } = this.emscriptenFS.lookupPath(dirToCreate, { parent: false }).node;
- if (this.emscriptenFS.isDir(mode)) {
- console.log(`Create dir: ${dirToCreate} mode: ${mode}`);
- }
- } catch (e) {
- if (e instanceof Object && (e as { code: string }).code === 'EEXIST') {
- console.log(`Directory already exists: ${dirToCreate}`);
- }
- }
- }
-
- // write out files
- type RawContent = { default: string };
- for (const [targetFile, content] of Object.entries(filesToUse)) {
- try {
- let contentAsString: string;
- if (this.useCompressedWorkspace) {
- contentAsString = await content() as string;
- } else {
- contentAsString = (await content() as RawContent).default;
- }
- this.emscriptenFS.writeFile(targetFile, contentAsString);
- console.log(`Wrote file: ${targetFile}`);
- } catch (e) {
- console.error(`Error writing ${targetFile}: ${String(e)}`);
- }
+ } catch (e) {
+ if (e instanceof Object && (e as { code: string }).code === 'EEXIST') {
+ console.log(`Directory already exists: ${dirToCreate}`);
}
+ }
}
- private async updateRemoteFilesystem() {
- if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
- if (this.fsMessagePort === undefined) throw new Error('MessagePort is not available! Aborting ...');
-
- const t0 = performance.now();
-
- console.log('Updating Remote FS');
- const allFilesAndDirectories = fsReadAllFiles(this.emscriptenFS, '/');
-
- this.remoteFs = new WorkerRemoteMessageChannelFs(this.fsMessagePort, this.emscriptenFS);
- await this.remoteFs.init();
-
- const allPromises = [];
- for (const filename of allFilesAndDirectories.files) {
- try {
- // just push the binary content to the client
- const content = this.emscriptenFS.readFile(filename, { encoding: 'binary' });
- allPromises.push(this.remoteFs.syncFile({
- resourceUri: filename,
- content: content as unknown as ArrayBufferLike
- }));
-
- } catch (e) {
- console.error(`Unexpected error when reading file ${filename}: ${String(e)}`);
- }
+ // write out files
+ type RawContent = { default: string };
+ for (const [targetFile, content] of Object.entries(filesToUse)) {
+ try {
+ let contentAsString: string;
+ if (this.useCompressedWorkspace) {
+ contentAsString = (await content()) as string;
+ } else {
+ contentAsString = ((await content()) as RawContent).default;
}
+ this.emscriptenFS.writeFile(targetFile, contentAsString);
+ console.log(`Wrote file: ${targetFile}`);
+ } catch (e) {
+ console.error(`Error writing ${targetFile}: ${String(e)}`);
+ }
+ }
+ }
+
+ private async updateRemoteFilesystem() {
+ if (this.emscriptenFS === undefined) throw new Error('Emscripten FS is not available! Aborting ...');
+ if (this.fsMessagePort === undefined) throw new Error('MessagePort is not available! Aborting ...');
+
+ const t0 = performance.now();
+
+ console.log('Updating Remote FS');
+ const allFilesAndDirectories = fsReadAllFiles(this.emscriptenFS, '/');
+
+ this.remoteFs = new WorkerRemoteMessageChannelFs(this.fsMessagePort, this.emscriptenFS);
+ await this.remoteFs.init();
+
+ const allPromises = [];
+ for (const filename of allFilesAndDirectories.files) {
+ try {
+ // just push the binary content to the client
+ const content = this.emscriptenFS.readFile(filename, { encoding: 'binary' });
+ allPromises.push(
+ this.remoteFs.syncFile({
+ resourceUri: filename,
+ content: content as unknown as ArrayBufferLike
+ })
+ );
+ } catch (e) {
+ console.error(`Unexpected error when reading file ${filename}: ${String(e)}`);
+ }
+ }
- await Promise.all(allPromises);
+ await Promise.all(allPromises);
- // signal the client everything is ready
- await this.remoteFs.ready();
+ // signal the client everything is ready
+ await this.remoteFs.ready();
- const t1 = performance.now();
- const msg = `Remote FS: File loading completed in ${t1 - t0}ms.`;
- console.log(msg);
- }
+ const t1 = performance.now();
+ const msg = `Remote FS: File loading completed in ${t1 - t0}ms.`;
+ console.log(msg);
+ }
}
new ComChannelEndpoint({
- endpointId: 2000,
- endpointConfig: {
- $type: 'DirectImplConfig',
- impl: self
- },
- verbose: true,
- endpointName: 'clangd_main'
+ endpointId: 2000,
+ endpointConfig: {
+ $type: 'DirectImplConfig',
+ impl: self
+ },
+ verbose: true,
+ endpointName: 'clangd_main'
}).connect(new ClangdInteractionWorker());
diff --git a/packages/examples/src/clangd/worker/json_stream.ts b/packages/examples/src/clangd/worker/json_stream.ts
index 1924b868c..fdf2871a5 100644
--- a/packages/examples/src/clangd/worker/json_stream.ts
+++ b/packages/examples/src/clangd/worker/json_stream.ts
@@ -9,56 +9,56 @@ const RBRACE = 125;
const BACKSLASH = 92;
export class JsonStream {
- #inJson = false;
- #rawText: number[] = [];
- #unbalancedBraces = 0;
- #inString = false;
- #inEscape = 0;
- readonly #textDecoder = new TextDecoder();
+ #inJson = false;
+ #rawText: number[] = [];
+ #unbalancedBraces = 0;
+ #inString = false;
+ #inEscape = 0;
+ readonly #textDecoder = new TextDecoder();
- constructor() { }
+ constructor() {}
- /**
- * Insert a char into current partial JSON
- * @param charCode
- * @returns Complete JSON string if the inserted char makes the JSON complete, otherwise null
- */
- insert(charCode: number): string | null {
- if (!this.#inJson && charCode === LBRACE) {
- this.#inJson = true;
- this.#rawText = [];
+ /**
+ * Insert a char into current partial JSON
+ * @param charCode
+ * @returns Complete JSON string if the inserted char makes the JSON complete, otherwise null
+ */
+ insert(charCode: number): string | null {
+ if (!this.#inJson && charCode === LBRACE) {
+ this.#inJson = true;
+ this.#rawText = [];
+ }
+ if (!this.#inJson) {
+ return null;
+ }
+ this.#rawText.push(charCode);
+ if (this.#inString) {
+ if (this.#inEscape > 0) {
+ if (charCode === 75) {
+ // \uxxxx
+ this.#inEscape += 4;
}
- if (!this.#inJson) {
- return null;
+ this.#inEscape--;
+ } else {
+ if (charCode === BACKSLASH) {
+ this.#inEscape = 1;
+ } else if (charCode === QUOT) {
+ this.#inString = false;
}
- this.#rawText.push(charCode);
- if (this.#inString) {
- if (this.#inEscape > 0) {
- if (charCode === 75) {
- // \uxxxx
- this.#inEscape += 4;
- }
- this.#inEscape--;
- } else {
- if (charCode === BACKSLASH) {
- this.#inEscape = 1;
- } else if (charCode === QUOT) {
- this.#inString = false;
- }
- }
- } else {
- if (charCode === LBRACE) {
- this.#unbalancedBraces++;
- } else if (charCode === RBRACE) {
- this.#unbalancedBraces--;
- if (this.#unbalancedBraces === 0) {
- this.#inJson = false;
- return this.#textDecoder.decode(new Uint8Array(this.#rawText));
- }
- } else if (charCode === QUOT) {
- this.#inString = true;
- }
+ }
+ } else {
+ if (charCode === LBRACE) {
+ this.#unbalancedBraces++;
+ } else if (charCode === RBRACE) {
+ this.#unbalancedBraces--;
+ if (this.#unbalancedBraces === 0) {
+ this.#inJson = false;
+ return this.#textDecoder.decode(new Uint8Array(this.#rawText));
}
- return null;
+ } else if (charCode === QUOT) {
+ this.#inString = true;
+ }
}
+ return null;
+ }
}
diff --git a/packages/examples/src/clangd/worker/memfs-tools.ts b/packages/examples/src/clangd/worker/memfs-tools.ts
index 8aacb9f1d..18af38b83 100644
--- a/packages/examples/src/clangd/worker/memfs-tools.ts
+++ b/packages/examples/src/clangd/worker/memfs-tools.ts
@@ -4,40 +4,40 @@
* ------------------------------------------------------------------------------------------ */
export const fsReadAllFiles = (emscriptenFs: typeof FS, baseFolder: string) => {
- const files: string[] = [];
- const directories: string[] = [];
+ const files: string[] = [];
+ const directories: string[] = [];
- const crawlFolder = (folder: string) => {
- const folderListing = emscriptenFs.readdir(folder);
- for (const name of folderListing) {
- // do not process the current and parent directory
- if (name === '.' || name === '..') {
- continue;
- }
+ const crawlFolder = (folder: string) => {
+ const folderListing = emscriptenFs.readdir(folder);
+ for (const name of folderListing) {
+ // do not process the current and parent directory
+ if (name === '.' || name === '..') {
+ continue;
+ }
- const path = `${folder}/${name}`.replaceAll('//', '/');
- try {
- const { mode } = emscriptenFs.lookupPath(path, { parent: false }).node;
- if (emscriptenFs.isFile(mode)) {
- files.push(path);
- } else if (emscriptenFs.isDir(mode)) {
- directories.push(path);
- crawlFolder(path);
- } else {
- console.log(`Ignored: ${path}`);
- }
- } catch (error) {
- console.error(`${path} provoked an error: ${String(error)}`);
- }
+ const path = `${folder}/${name}`.replaceAll('//', '/');
+ try {
+ const { mode } = emscriptenFs.lookupPath(path, { parent: false }).node;
+ if (emscriptenFs.isFile(mode)) {
+ files.push(path);
+ } else if (emscriptenFs.isDir(mode)) {
+ directories.push(path);
+ crawlFolder(path);
+ } else {
+ console.log(`Ignored: ${path}`);
}
- };
+ } catch (error) {
+ console.error(`${path} provoked an error: ${String(error)}`);
+ }
+ }
+ };
- crawlFolder(baseFolder);
+ crawlFolder(baseFolder);
- // files.forEach((file) => { console.log(file); });
- console.log(`Found ${files.length} files.`);
- return {
- files,
- directories
- };
+ // files.forEach((file) => { console.log(file); });
+ console.log(`Found ${files.length} files.`);
+ return {
+ files,
+ directories
+ };
};
diff --git a/packages/examples/src/clangd/worker/workerRemoteMessageChannelFs.ts b/packages/examples/src/clangd/worker/workerRemoteMessageChannelFs.ts
index a9bf27bc6..ca7cdf2eb 100644
--- a/packages/examples/src/clangd/worker/workerRemoteMessageChannelFs.ts
+++ b/packages/examples/src/clangd/worker/workerRemoteMessageChannelFs.ts
@@ -3,111 +3,125 @@
* Licensed under the MIT License. See LICENSE in the package root for license information.
* ------------------------------------------------------------------------------------------ */
-import type { DirectoryListingRequest, DirectoryListingRequestResult, EndpointType, FileReadRequest, FileReadRequestResult, FileSystemEndpoint, FileUpdate, FileUpdateResult, StatsRequest, StatsRequestResult } from 'monaco-languageclient/fs';
+import type {
+ DirectoryListingRequest,
+ DirectoryListingRequestResult,
+ EndpointType,
+ FileReadRequest,
+ FileReadRequestResult,
+ FileSystemEndpoint,
+ FileUpdate,
+ FileUpdateResult,
+ StatsRequest,
+ StatsRequestResult
+} from 'monaco-languageclient/fs';
import { ComChannelEndpoint, type ComRouter, RawPayload, WorkerMessage } from 'wtd-core';
class FileHandlerWorker implements ComRouter {
-
- private portClandFsEndpoint: ComChannelEndpoint;
-
- setComChannelEndpoint(comChannelEndpoint: ComChannelEndpoint): void {
- this.portClandFsEndpoint = comChannelEndpoint;
- }
-
- async fs_follower_init(message: WorkerMessage) {
- await this.portClandFsEndpoint.sentAnswer({
- message: WorkerMessage.createFromExisting(message, {
- overrideCmd: 'fs_follower_init_confirm'
- })
- });
- }
+ private portClandFsEndpoint: ComChannelEndpoint;
+
+ setComChannelEndpoint(comChannelEndpoint: ComChannelEndpoint): void {
+ this.portClandFsEndpoint = comChannelEndpoint;
+ }
+
+ async fs_follower_init(message: WorkerMessage) {
+ await this.portClandFsEndpoint.sentAnswer({
+ message: WorkerMessage.createFromExisting(message, {
+ overrideCmd: 'fs_follower_init_confirm'
+ })
+ });
+ }
}
export class WorkerRemoteMessageChannelFs implements FileSystemEndpoint {
-
- private clangdFsEndpoint?: ComChannelEndpoint;
- private emscriptenFS: typeof FS;
-
- constructor(port: MessagePort, emscriptenFS: typeof FS) {
- this.emscriptenFS = emscriptenFS;
- this.clangdFsEndpoint = new ComChannelEndpoint({
- endpointId: 22,
- endpointName: 'port_clangd_fs',
- endpointConfig: {
- $type: 'DirectImplConfig',
- impl: port
- },
- verbose: false
- });
- this.clangdFsEndpoint.connect(new FileHandlerWorker());
- }
-
- getEndpointType(): EndpointType {
- return 'DRIVER';
- }
-
- async init() {
- await this.clangdFsEndpoint?.sentMessage({
- message: WorkerMessage.fromPayload(new RawPayload({
- hello: 'main',
- }), 'fs_driver_init'),
- awaitAnswer: true,
- expectedAnswer: 'fs_driver_init_confirm'
- });
- }
-
- async ready() {
- await this.clangdFsEndpoint?.sentMessage({
- message: WorkerMessage.createNew({
- cmd: 'fs_driver_ready'
- }),
- awaitAnswer: true,
- expectedAnswer: 'fs_driver_ready_confirm'
- });
- }
-
- getFileSystemInfo(): string {
- return 'This file system sends all requests to the remote end of the message channel.';
- }
-
- readFile(_params: FileReadRequest): Promise {
- return Promise.resolve({
- status: 'denied',
- content: ''
- });
- }
-
- writeFile(_params: FileUpdate): Promise {
- return Promise.resolve({ status: 'denied' });
- }
-
- async syncFile(params: FileUpdate): Promise {
- const content = this.emscriptenFS.readFile(params.resourceUri, { encoding: 'binary' });
- const result = await this.clangdFsEndpoint?.sentMessage({
- message: WorkerMessage.fromPayload(new RawPayload({
- resourceUri: params.resourceUri,
- content: content
- }), 'syncFile'),
- transferables: [content.buffer],
- awaitAnswer: true,
- expectedAnswer: 'syncFile_confirm'
- });
-
- const rawPayload = result?.payloads[0] as RawPayload;
- // console.log(rawPayload);
-
- return Promise.resolve({
- status: rawPayload.message.raw?.status,
- message: rawPayload.message.raw?.message
- });
- }
-
- getFileStats(_params: StatsRequest): Promise {
- return Promise.reject('No stats available.');
- }
-
- listFiles(_params: DirectoryListingRequest): Promise {
- return Promise.reject('No file listing possible.');
- }
-
+ private clangdFsEndpoint?: ComChannelEndpoint;
+ private emscriptenFS: typeof FS;
+
+ constructor(port: MessagePort, emscriptenFS: typeof FS) {
+ this.emscriptenFS = emscriptenFS;
+ this.clangdFsEndpoint = new ComChannelEndpoint({
+ endpointId: 22,
+ endpointName: 'port_clangd_fs',
+ endpointConfig: {
+ $type: 'DirectImplConfig',
+ impl: port
+ },
+ verbose: false
+ });
+ this.clangdFsEndpoint.connect(new FileHandlerWorker());
+ }
+
+ getEndpointType(): EndpointType {
+ return 'DRIVER';
+ }
+
+ async init() {
+ await this.clangdFsEndpoint?.sentMessage({
+ message: WorkerMessage.fromPayload(
+ new RawPayload({
+ hello: 'main'
+ }),
+ 'fs_driver_init'
+ ),
+ awaitAnswer: true,
+ expectedAnswer: 'fs_driver_init_confirm'
+ });
+ }
+
+ async ready() {
+ await this.clangdFsEndpoint?.sentMessage({
+ message: WorkerMessage.createNew({
+ cmd: 'fs_driver_ready'
+ }),
+ awaitAnswer: true,
+ expectedAnswer: 'fs_driver_ready_confirm'
+ });
+ }
+
+ getFileSystemInfo(): string {
+ return 'This file system sends all requests to the remote end of the message channel.';
+ }
+
+ readFile(_params: FileReadRequest): Promise {
+ return Promise.resolve({
+ status: 'denied',
+ content: ''
+ });
+ }
+
+ writeFile(_params: FileUpdate): Promise {
+ return Promise.resolve({ status: 'denied' });
+ }
+
+ async syncFile(params: FileUpdate): Promise {
+ const content = this.emscriptenFS.readFile(params.resourceUri, { encoding: 'binary' });
+ const result = await this.clangdFsEndpoint?.sentMessage({
+ message: WorkerMessage.fromPayload(
+ new RawPayload({
+ resourceUri: params.resourceUri,
+ content: content
+ }),
+ 'syncFile'
+ ),
+ transferables: [content.buffer],
+ awaitAnswer: true,
+ expectedAnswer: 'syncFile_confirm'
+ });
+
+ const rawPayload = result?.payloads[0] as RawPayload;
+ // console.log(rawPayload);
+
+ return Promise.resolve({
+ status: rawPayload.message.raw?.status,
+ message: rawPayload.message.raw?.message
+ });
+ }
+
+ getFileStats(_params: StatsRequest): Promise {
+ return Promise.reject('No stats available.');
+ }
+
+ listFiles(_params: DirectoryListingRequest): Promise {
+ return Promise.reject('No file listing possible.');
+ }
}
diff --git a/packages/examples/src/common/client/extendedClient.ts b/packages/examples/src/common/client/extendedClient.ts
index 611eebd54..e57b1d6f1 100644
--- a/packages/examples/src/common/client/extendedClient.ts
+++ b/packages/examples/src/common/client/extendedClient.ts
@@ -3,7 +3,11 @@
* Licensed under the MIT License. See LICENSE in the package root for license information.
* ------------------------------------------------------------------------------------------ */
-import { RegisteredFileSystemProvider, RegisteredMemoryFile, registerFileSystemOverlay } from '@codingame/monaco-vscode-files-service-override';
+import {
+ RegisteredFileSystemProvider,
+ RegisteredMemoryFile,
+ registerFileSystemOverlay
+} from '@codingame/monaco-vscode-files-service-override';
import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
import * as vscode from 'vscode';
// this is required syntax highlighting
@@ -15,126 +19,126 @@ import { configureDefaultWorkerFactory } from 'monaco-languageclient/workerFacto
import { createUrl, type ConnectionConfigOptions, type WebSocketConfigOptionsDirect } from 'monaco-languageclient/common';
export const runExtendedClient = async (lsConfig: ExampleLsConfig, helloCode: string) => {
- const helloUri = vscode.Uri.file(`${lsConfig.basePath}/workspace/hello.${lsConfig.languageId}`);
- const fileSystemProvider = new RegisteredFileSystemProvider(false);
- fileSystemProvider.registerFile(new RegisteredMemoryFile(helloUri, helloCode));
- registerFileSystemOverlay(1, fileSystemProvider);
+ const helloUri = vscode.Uri.file(`${lsConfig.basePath}/workspace/hello.${lsConfig.languageId}`);
+ const fileSystemProvider = new RegisteredFileSystemProvider(false);
+ fileSystemProvider.registerFile(new RegisteredMemoryFile(helloUri, helloCode));
+ registerFileSystemOverlay(1, fileSystemProvider);
- const htmlContainer = document.getElementById('monaco-editor-root')!;
- const vscodeApiConfig: MonacoVscodeApiConfig = {
- $type: 'extended',
- viewsConfig: {
- $type: 'EditorService',
- htmlContainer
- },
- logLevel: LogLevel.Debug,
- serviceOverrides: {
- ...getKeybindingsServiceOverride(),
- },
- userConfiguration: {
- json: JSON.stringify({
- 'workbench.colorTheme': 'Default Dark Modern',
- 'editor.guides.bracketPairsHorizontal': 'active',
- 'editor.lightbulb.enabled': 'On',
- 'editor.wordBasedSuggestions': 'off',
- 'editor.experimental.asyncTokenization': true
- })
- },
- monacoWorkerFactory: configureDefaultWorkerFactory
- };
+ const htmlContainer = document.getElementById('monaco-editor-root')!;
+ const vscodeApiConfig: MonacoVscodeApiConfig = {
+ $type: 'extended',
+ viewsConfig: {
+ $type: 'EditorService',
+ htmlContainer
+ },
+ logLevel: LogLevel.Debug,
+ serviceOverrides: {
+ ...getKeybindingsServiceOverride()
+ },
+ userConfiguration: {
+ json: JSON.stringify({
+ 'workbench.colorTheme': 'Default Dark Modern',
+ 'editor.guides.bracketPairsHorizontal': 'active',
+ 'editor.lightbulb.enabled': 'On',
+ 'editor.wordBasedSuggestions': 'off',
+ 'editor.experimental.asyncTokenization': true
+ })
+ },
+ monacoWorkerFactory: configureDefaultWorkerFactory
+ };
+
+ const startOptions = {
+ onCall: () => {
+ console.log('Connected to socket.');
+ },
+ reportStatus: true
+ };
+ const stopOptions = {
+ onCall: () => {
+ console.log('Disconnected from socket.');
+ },
+ reportStatus: true
+ };
- const startOptions = {
- onCall: () => {
- console.log('Connected to socket.');
- },
- reportStatus: true
+ let webSocket: WebSocket | undefined;
+ let connectionConfigOptions: ConnectionConfigOptions;
+ const webSocketUrl = `ws://localhost:${lsConfig.port}${lsConfig.path}`;
+ if (lsConfig.useExternalWebSocket) {
+ webSocket = new WebSocket(createUrl({ url: webSocketUrl }));
+ connectionConfigOptions = {
+ $type: 'WebSocketDirect',
+ webSocket,
+ startOptions,
+ stopOptions
};
- const stopOptions = {
- onCall: () => {
- console.log('Disconnected from socket.');
- },
- reportStatus: true
+ } else {
+ connectionConfigOptions = {
+ $type: 'WebSocketUrl',
+ url: webSocketUrl,
+ startOptions,
+ stopOptions
};
+ }
- let webSocket: WebSocket | undefined;
- let connectionConfigOptions: ConnectionConfigOptions;
- const webSocketUrl = `ws://localhost:${lsConfig.port}${lsConfig.path}`;
- if (lsConfig.useExternalWebSocket) {
- webSocket = new WebSocket(createUrl({ url: webSocketUrl }));
- connectionConfigOptions = {
- $type: 'WebSocketDirect',
- webSocket,
- startOptions,
- stopOptions
- };
- } else {
- connectionConfigOptions = {
- $type: 'WebSocketUrl',
- url: webSocketUrl,
- startOptions,
- stopOptions
- };
+ const languageClientConfig: LanguageClientConfig = {
+ languageId: lsConfig.languageId,
+ connection: {
+ options: connectionConfigOptions
+ },
+ clientOptions: {
+ documentSelector: [lsConfig.languageId],
+ workspaceFolder: {
+ index: 0,
+ name: 'workspace',
+ uri: vscode.Uri.parse(`${lsConfig.basePath}/workspace`)
+ }
}
+ };
- const languageClientConfig: LanguageClientConfig = {
- languageId: lsConfig.languageId,
- connection: {
- options: connectionConfigOptions
- },
- clientOptions: {
- documentSelector: [lsConfig.languageId],
- workspaceFolder: {
- index: 0,
- name: 'workspace',
- uri: vscode.Uri.parse(`${lsConfig.basePath}/workspace`)
- }
- }
- };
-
- const editorAppConfig: EditorAppConfig = {
- codeResources: {
- modified: {
- text: helloCode,
- uri: helloUri.path
- }
- }
- };
+ const editorAppConfig: EditorAppConfig = {
+ codeResources: {
+ modified: {
+ text: helloCode,
+ uri: helloUri.path
+ }
+ }
+ };
- // perform global init
- const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
- await apiWrapper.start();
+ // perform global init
+ const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
+ await apiWrapper.start();
- const lcWrapper = new LanguageClientWrapper(languageClientConfig);
- const editorApp = new EditorApp(editorAppConfig);
+ const lcWrapper = new LanguageClientWrapper(languageClientConfig);
+ const editorApp = new EditorApp(editorAppConfig);
- try {
- document.querySelector('#button-start')?.addEventListener('click', async () => {
- if (lsConfig.useExternalWebSocket && webSocket === undefined) {
- webSocket = new WebSocket(createUrl({ url: webSocketUrl }));
- (connectionConfigOptions as WebSocketConfigOptionsDirect).webSocket = webSocket;
- }
- await editorApp.start(htmlContainer);
- await lcWrapper.start();
+ try {
+ document.querySelector('#button-start')?.addEventListener('click', async () => {
+ if (lsConfig.useExternalWebSocket && webSocket === undefined) {
+ webSocket = new WebSocket(createUrl({ url: webSocketUrl }));
+ (connectionConfigOptions as WebSocketConfigOptionsDirect).webSocket = webSocket;
+ }
+ await editorApp.start(htmlContainer);
+ await lcWrapper.start();
- // open files, so the LS can pick it up
- await vscode.workspace.openTextDocument(helloUri);
- });
- document.querySelector('#button-dispose')?.addEventListener('click', async () => {
- await editorApp.dispose();
- await lcWrapper.dispose();
+ // open files, so the LS can pick it up
+ await vscode.workspace.openTextDocument(helloUri);
+ });
+ document.querySelector('#button-dispose')?.addEventListener('click', async () => {
+ await editorApp.dispose();
+ await lcWrapper.dispose();
- webSocket?.close();
- webSocket = undefined;
- });
- } catch (e) {
- console.error(e);
- }
+ webSocket?.close();
+ webSocket = undefined;
+ });
+ } catch (e) {
+ console.error(e);
+ }
};
export type ExampleLsConfig = {
- port: number;
- path: string;
- basePath: string;
- languageId: string;
- useExternalWebSocket: boolean;
+ port: number;
+ path: string;
+ basePath: string;
+ languageId: string;
+ useExternalWebSocket: boolean;
};
diff --git a/packages/examples/src/common/client/utils.ts b/packages/examples/src/common/client/utils.ts
index 4463b76de..0d94cc96f 100644
--- a/packages/examples/src/common/client/utils.ts
+++ b/packages/examples/src/common/client/utils.ts
@@ -8,28 +8,28 @@ import type { LanguageClientConfig } from 'monaco-languageclient/lcwrapper';
import type { MonacoVscodeApiConfig } from 'monaco-languageclient/vscodeApiWrapper';
export const disableElement = (id: string, disabled: boolean) => {
- const button = document.getElementById(id) as HTMLButtonElement | HTMLInputElement | null;
- if (button !== null) {
- button.disabled = disabled;
- }
+ const button = document.getElementById(id) as HTMLButtonElement | HTMLInputElement | null;
+ if (button !== null) {
+ button.disabled = disabled;
+ }
};
export const createDefaultWorkspaceContent = (workspacePath: string) => {
- return JSON.stringify(
+ return JSON.stringify(
+ {
+ folders: [
{
- folders: [
- {
- path: workspacePath
- }
- ]
- },
- null,
- 2
- );
+ path: workspacePath
+ }
+ ]
+ },
+ null,
+ 2
+ );
};
export type ExampleAppConfig = {
- vscodeApiConfig: MonacoVscodeApiConfig;
- languageClientConfig: LanguageClientConfig;
- editorAppConfig: EditorAppConfig;
+ vscodeApiConfig: MonacoVscodeApiConfig;
+ languageClientConfig: LanguageClientConfig;
+ editorAppConfig: EditorAppConfig;
};
diff --git a/packages/examples/src/common/node/language-server-runner.ts b/packages/examples/src/common/node/language-server-runner.ts
index 0c330e7fa..29fd1e6d5 100644
--- a/packages/examples/src/common/node/language-server-runner.ts
+++ b/packages/examples/src/common/node/language-server-runner.ts
@@ -9,27 +9,25 @@ import express from 'express';
import { getLocalDirectory, type LanguageServerRunConfig, upgradeWsServer } from './server-commons.js';
/** LSP server runner */
-export const runLanguageServer = (
- languageServerRunConfig: LanguageServerRunConfig
-) => {
- process.on('uncaughtException', err => {
- console.error('Uncaught Exception: ', err.toString());
- if (err.stack !== undefined) {
- console.error(err.stack);
- }
- });
+export const runLanguageServer = (languageServerRunConfig: LanguageServerRunConfig) => {
+ process.on('uncaughtException', (err) => {
+ console.error('Uncaught Exception: ', err.toString());
+ if (err.stack !== undefined) {
+ console.error(err.stack);
+ }
+ });
- // create the express application
- const app = express();
- // server the static content, i.e. index.html
- const dir = getLocalDirectory(import.meta.url);
- app.use(express.static(dir));
- // start the http server
- const httpServer: Server = app.listen(languageServerRunConfig.serverPort);
- const wss = new WebSocketServer(languageServerRunConfig.wsServerOptions);
- // create the web socket
- upgradeWsServer(languageServerRunConfig, {
- server: httpServer,
- wss
- });
+ // create the express application
+ const app = express();
+ // server the static content, i.e. index.html
+ const dir = getLocalDirectory(import.meta.url);
+ app.use(express.static(dir));
+ // start the http server
+ const httpServer: Server = app.listen(languageServerRunConfig.serverPort);
+ const wss = new WebSocketServer(languageServerRunConfig.wsServerOptions);
+ // create the web socket
+ upgradeWsServer(languageServerRunConfig, {
+ server: httpServer,
+ wss
+ });
};
diff --git a/packages/examples/src/common/node/server-commons.ts b/packages/examples/src/common/node/server-commons.ts
index cf441b3de..f6818a93f 100644
--- a/packages/examples/src/common/node/server-commons.ts
+++ b/packages/examples/src/common/node/server-commons.ts
@@ -10,101 +10,111 @@ import { fileURLToPath, URL } from 'node:url';
import * as cp from 'node:child_process';
import { type IWebSocket, WebSocketMessageReader, WebSocketMessageWriter } from 'vscode-ws-jsonrpc';
import { createConnection, createServerProcess, forward } from 'vscode-ws-jsonrpc/server';
-import { Message, InitializeRequest, type InitializeParams, type RequestMessage, type ResponseMessage } from 'vscode-languageserver-protocol';
+import {
+ Message,
+ InitializeRequest,
+ type InitializeParams,
+ type RequestMessage,
+ type ResponseMessage
+} from 'vscode-languageserver-protocol';
export interface LanguageServerRunConfig {
- serverName: string;
- pathName: string;
- serverPort: number;
- runCommand: string;
- runCommandArgs: string[];
- wsServerOptions: ServerOptions,
- spawnOptions?: cp.SpawnOptions;
- logMessages?: boolean;
- requestMessageHandler?: (message: RequestMessage) => RequestMessage;
- responseMessageHandler?: (message: ResponseMessage) => ResponseMessage;
+ serverName: string;
+ pathName: string;
+ serverPort: number;
+ runCommand: string;
+ runCommandArgs: string[];
+ wsServerOptions: ServerOptions;
+ spawnOptions?: cp.SpawnOptions;
+ logMessages?: boolean;
+ requestMessageHandler?: (message: RequestMessage) => RequestMessage;
+ responseMessageHandler?: (message: ResponseMessage) => ResponseMessage;
}
/**
* start the language server inside the current process
*/
export const launchLanguageServer = (runconfig: LanguageServerRunConfig, socket: IWebSocket) => {
- const { serverName, runCommand, runCommandArgs, spawnOptions } = runconfig;
- // start the language server as an external process
- const reader = new WebSocketMessageReader(socket);
- const writer = new WebSocketMessageWriter(socket);
- const socketConnection = createConnection(reader, writer, () => socket.dispose());
- const serverConnection = createServerProcess(serverName, runCommand, runCommandArgs, spawnOptions);
- if (serverConnection !== undefined) {
- forward(socketConnection, serverConnection, message => {
- if (Message.isRequest(message)) {
- if (message.method === InitializeRequest.type.method) {
- const initializeParams = message.params as InitializeParams;
- initializeParams.processId = process.pid;
- }
+ const { serverName, runCommand, runCommandArgs, spawnOptions } = runconfig;
+ // start the language server as an external process
+ const reader = new WebSocketMessageReader(socket);
+ const writer = new WebSocketMessageWriter(socket);
+ const socketConnection = createConnection(reader, writer, () => socket.dispose());
+ const serverConnection = createServerProcess(serverName, runCommand, runCommandArgs, spawnOptions);
+ if (serverConnection !== undefined) {
+ forward(socketConnection, serverConnection, (message) => {
+ if (Message.isRequest(message)) {
+ if (message.method === InitializeRequest.type.method) {
+ const initializeParams = message.params as InitializeParams;
+ initializeParams.processId = process.pid;
+ }
- if (runconfig.logMessages ?? false) {
- console.log(`${serverName} Server received: ${message.method}`);
- console.log(message);
- }
- if (runconfig.requestMessageHandler !== undefined) {
- return runconfig.requestMessageHandler(message);
- }
- }
- if (Message.isResponse(message)) {
- if (runconfig.logMessages ?? false) {
- console.log(`${serverName} Server sent:`);
- console.log(message);
- }
- if (runconfig.responseMessageHandler !== undefined) {
- return runconfig.responseMessageHandler(message);
- }
- }
- return message;
- });
- }
+ if (runconfig.logMessages ?? false) {
+ console.log(`${serverName} Server received: ${message.method}`);
+ console.log(message);
+ }
+ if (runconfig.requestMessageHandler !== undefined) {
+ return runconfig.requestMessageHandler(message);
+ }
+ }
+ if (Message.isResponse(message)) {
+ if (runconfig.logMessages ?? false) {
+ console.log(`${serverName} Server sent:`);
+ console.log(message);
+ }
+ if (runconfig.responseMessageHandler !== undefined) {
+ return runconfig.responseMessageHandler(message);
+ }
+ }
+ return message;
+ });
+ }
};
-export const upgradeWsServer = (runconfig: LanguageServerRunConfig,
- config: {
- server: Server,
- wss: WebSocketServer
- }) => {
- config.server.on('upgrade', (request: IncomingMessage, socket: Socket, head: Buffer) => {
- const baseURL = `http://${request.headers.host}/`;
- const pathName = request.url !== undefined ? new URL(request.url, baseURL).pathname : undefined;
- if (pathName === runconfig.pathName) {
- config.wss.handleUpgrade(request, socket, head, webSocket => {
- const socket: IWebSocket = {
- send: content => webSocket.send(content, error => {
- if (error !== undefined) {
- throw error;
- }
- }),
- onMessage: cb => webSocket.on('message', (data) => {
- cb(data);
- }),
- onError: cb => webSocket.on('error', cb),
- onClose: cb => webSocket.on('close', cb),
- dispose: () => webSocket.close()
- };
- // launch the server when the web socket is opened
- if (webSocket.readyState === webSocket.OPEN) {
- launchLanguageServer(runconfig, socket);
- } else {
- webSocket.on('open', () => {
- launchLanguageServer(runconfig, socket);
- });
- }
- });
+export const upgradeWsServer = (
+ runconfig: LanguageServerRunConfig,
+ config: {
+ server: Server;
+ wss: WebSocketServer;
+ }
+) => {
+ config.server.on('upgrade', (request: IncomingMessage, socket: Socket, head: Buffer) => {
+ const baseURL = `http://${request.headers.host}/`;
+ const pathName = request.url !== undefined ? new URL(request.url, baseURL).pathname : undefined;
+ if (pathName === runconfig.pathName) {
+ config.wss.handleUpgrade(request, socket, head, (webSocket) => {
+ const socket: IWebSocket = {
+ send: (content) =>
+ webSocket.send(content, (error) => {
+ if (error !== undefined) {
+ throw error;
+ }
+ }),
+ onMessage: (cb) =>
+ webSocket.on('message', (data) => {
+ cb(data);
+ }),
+ onError: (cb) => webSocket.on('error', cb),
+ onClose: (cb) => webSocket.on('close', cb),
+ dispose: () => webSocket.close()
+ };
+ // launch the server when the web socket is opened
+ if (webSocket.readyState === webSocket.OPEN) {
+ launchLanguageServer(runconfig, socket);
+ } else {
+ webSocket.on('open', () => {
+ launchLanguageServer(runconfig, socket);
+ });
}
- });
+ });
+ }
+ });
};
/**
* Solves: __dirname is not defined in ES module scope
*/
export const getLocalDirectory = (referenceUrl: string | URL) => {
- const __filename = fileURLToPath(referenceUrl);
- return dirname(__filename);
+ const __filename = fileURLToPath(referenceUrl);
+ return dirname(__filename);
};
diff --git a/packages/examples/src/debugger/server/DAPSocket.ts b/packages/examples/src/debugger/server/DAPSocket.ts
index 656d53f87..9abf4d2e0 100644
--- a/packages/examples/src/debugger/server/DAPSocket.ts
+++ b/packages/examples/src/debugger/server/DAPSocket.ts
@@ -13,59 +13,56 @@ const HEADER_LINESEPARATOR = /\r?\n/;
const HEADER_FIELDSEPARATOR = /: */;
export class DAPSocket {
- private socket: net.Socket;
- private rawData = Buffer.allocUnsafe(0);
- private contentLength = -1;
- private onMessage: (message: string) => void;
+ private socket: net.Socket;
+ private rawData = Buffer.allocUnsafe(0);
+ private contentLength = -1;
+ private onMessage: (message: string) => void;
- constructor(onMessage: (message: string) => void) {
- this.onMessage = onMessage;
- this.socket = new net.Socket();
- this.socket.on('data', this.onData);
- }
+ constructor(onMessage: (message: string) => void) {
+ this.onMessage = onMessage;
+ this.socket = new net.Socket();
+ this.socket.on('data', this.onData);
+ }
- private onData = (data: Buffer) => {
- this.rawData = Buffer.concat([this.rawData, data]);
- // oxlint-disable-next-line @typescript-eslint/no-unnecessary-condition
- while (true) {
- if (this.contentLength >= 0) {
- if (this.rawData.length >= this.contentLength) {
- const message = this.rawData.toString('utf8', 0, this.contentLength);
- this.rawData = this.rawData.subarray(this.contentLength);
- this.contentLength = -1;
- if (message.length > 0) {
- this.onMessage(message);
- }
- continue;
- }
- } else {
- const idx = this.rawData.indexOf(TWO_CRLF);
- if (idx !== -1) {
- const header = this.rawData.toString('utf8', 0, idx);
- const lines = header.split(HEADER_LINESEPARATOR);
- for (const h of lines) {
- const kvPair = h.split(HEADER_FIELDSEPARATOR);
- if (kvPair[0] === 'Content-Length') {
- this.contentLength = Number(kvPair[1]);
- }
- }
- this.rawData = this.rawData.subarray(idx + TWO_CRLF.length);
- continue;
- }
+ private onData = (data: Buffer) => {
+ this.rawData = Buffer.concat([this.rawData, data]);
+ // oxlint-disable-next-line @typescript-eslint/no-unnecessary-condition
+ while (true) {
+ if (this.contentLength >= 0) {
+ if (this.rawData.length >= this.contentLength) {
+ const message = this.rawData.toString('utf8', 0, this.contentLength);
+ this.rawData = this.rawData.subarray(this.contentLength);
+ this.contentLength = -1;
+ if (message.length > 0) {
+ this.onMessage(message);
+ }
+ continue;
+ }
+ } else {
+ const idx = this.rawData.indexOf(TWO_CRLF);
+ if (idx !== -1) {
+ const header = this.rawData.toString('utf8', 0, idx);
+ const lines = header.split(HEADER_LINESEPARATOR);
+ for (const h of lines) {
+ const kvPair = h.split(HEADER_FIELDSEPARATOR);
+ if (kvPair[0] === 'Content-Length') {
+ this.contentLength = Number(kvPair[1]);
}
- break;
+ }
+ this.rawData = this.rawData.subarray(idx + TWO_CRLF.length);
+ continue;
}
- };
-
- public connect(port: number) {
- this.socket.connect(port);
+ }
+ break;
}
+ };
- public sendMessage(message: string) {
- console.log(`Client->DAP: ${message}`);
- this.socket.write(
- `Content-Length: ${Buffer.byteLength(message, 'utf8')}${TWO_CRLF}${message}`,
- 'utf8'
- );
- }
+ public connect(port: number) {
+ this.socket.connect(port);
+ }
+
+ public sendMessage(message: string) {
+ console.log(`Client->DAP: ${message}`);
+ this.socket.write(`Content-Length: ${Buffer.byteLength(message, 'utf8')}${TWO_CRLF}${message}`, 'utf8');
+ }
}
diff --git a/packages/examples/src/debugger/server/debugServer.ts b/packages/examples/src/debugger/server/debugServer.ts
index 6bc2f87a1..c271f1d75 100644
--- a/packages/examples/src/debugger/server/debugServer.ts
+++ b/packages/examples/src/debugger/server/debugServer.ts
@@ -16,7 +16,7 @@ import { DAPSocket } from './DAPSocket.js';
// the major difference is that the debug server runs already inside the container
const exitHandler = async () => {
- console.log('Exiting...');
+ console.log('Exiting...');
};
process.on('exit', exitHandler);
process.on('SIGINT', exitHandler);
@@ -30,93 +30,91 @@ const app = express();
const server = http.createServer(app);
const wss = new WebSocketServer({ server });
-const sequential = (
- fn: (...params: P) => Promise
-): (...params: P) => Promise => {
- let promise = Promise.resolve();
- return (...params: P) => {
- const result = promise.then(() => {
- return fn(...params);
- });
+const sequential = (fn: (...params: P) => Promise): ((...params: P) => Promise) => {
+ let promise = Promise.resolve();
+ return (...params: P) => {
+ const result = promise.then(() => {
+ return fn(...params);
+ });
- promise = result.then(
- () => { },
- () => { }
- );
- return result;
- };
+ promise = result.then(
+ () => {},
+ () => {}
+ );
+ return result;
+ };
};
wss.on('connection', (ws) => {
- const onWsMessage = (message: string) => {
- console.log(`DAP->Client: ${message}`);
- ws.send(message);
- };
- const socket = new DAPSocket(onWsMessage);
+ const onWsMessage = (message: string) => {
+ console.log(`DAP->Client: ${message}`);
+ ws.send(message);
+ };
+ const socket = new DAPSocket(onWsMessage);
- let initialized = false;
+ let initialized = false;
- ws.on(
- 'message',
- sequential(async (message: string) => {
- if (!initialized) {
- try {
- const parsed = JSON.parse(message);
- if (parsed.id === 'init') {
- const initMesssage = parsed as InitMessage;
- const defaultFile = initMesssage.defaultFile;
- const debuggerExecCall = initMesssage.debuggerExecCall;
- for (const [name, fileDef] of Object.entries(initMesssage.files)) {
- console.log(`Found file: ${name} path: ${fileDef.path}`);
- await fs.promises.writeFile(fileDef.path, fileDef.code);
- }
- initialized = true;
+ ws.on(
+ 'message',
+ sequential(async (message: string) => {
+ if (!initialized) {
+ try {
+ const parsed = JSON.parse(message);
+ if (parsed.id === 'init') {
+ const initMesssage = parsed as InitMessage;
+ const defaultFile = initMesssage.defaultFile;
+ const debuggerExecCall = initMesssage.debuggerExecCall;
+ for (const [name, fileDef] of Object.entries(initMesssage.files)) {
+ console.log(`Found file: ${name} path: ${fileDef.path}`);
+ await fs.promises.writeFile(fileDef.path, fileDef.code);
+ }
+ initialized = true;
- console.log(`Using default file "${defaultFile}" for debugging.`);
+ console.log(`Using default file "${defaultFile}" for debugging.`);
- const sendOutput = (category: 'stdout' | 'stderr', output: string | null | undefined) => {
- onWsMessage(
- JSON.stringify({
- type: 'event',
- event: 'output',
- body: {
- category,
- output
- }
- })
- );
- };
+ const sendOutput = (category: 'stdout' | 'stderr', output: string | null | undefined) => {
+ onWsMessage(
+ JSON.stringify({
+ type: 'event',
+ event: 'output',
+ body: {
+ category,
+ output
+ }
+ })
+ );
+ };
- const cmd = `${debuggerExecCall} ${defaultFile} 2>&1 | tee /home/mlc/server/debugger.log`;
- console.log(`Executing the debugger: ${cmd}`);
- const execGraalpy = exec(cmd);
- execGraalpy.stdout?.on('data', (data) => {
- sendOutput('stdout', data);
- });
- execGraalpy.stderr?.on('data', (data) => {
- sendOutput('stderr', data);
- });
- execGraalpy.on('error', (err) => {
- sendOutput('stderr', err.message);
- });
- execGraalpy.on('end', () => {
- ws.close();
- });
+ const cmd = `${debuggerExecCall} ${defaultFile} 2>&1 | tee /home/mlc/server/debugger.log`;
+ console.log(`Executing the debugger: ${cmd}`);
+ const execGraalpy = exec(cmd);
+ execGraalpy.stdout?.on('data', (data) => {
+ sendOutput('stdout', data);
+ });
+ execGraalpy.stderr?.on('data', (data) => {
+ sendOutput('stderr', data);
+ });
+ execGraalpy.on('error', (err) => {
+ sendOutput('stderr', err.message);
+ });
+ execGraalpy.on('end', () => {
+ ws.close();
+ });
- await new Promise((resolve) => setTimeout(resolve, 1000));
- // 4711 is the default port of the GraalPy debugger
- socket.connect(4711);
- return;
- }
- } catch (err) {
- console.error('Failed to initialize', err);
- }
- }
- socket.sendMessage(message);
- })
- );
+ await new Promise((resolve) => setTimeout(resolve, 1000));
+ // 4711 is the default port of the GraalPy debugger
+ socket.connect(4711);
+ return;
+ }
+ } catch (err) {
+ console.error('Failed to initialize', err);
+ }
+ }
+ socket.sendMessage(message);
+ })
+ );
});
server.listen(PORT, () => {
- console.log(`Server started on port ${PORT}!`);
+ console.log(`Server started on port ${PORT}!`);
});
diff --git a/packages/examples/src/eclipse.jdt.ls/client/main.ts b/packages/examples/src/eclipse.jdt.ls/client/main.ts
index 8e20cc3c9..6471f8527 100644
--- a/packages/examples/src/eclipse.jdt.ls/client/main.ts
+++ b/packages/examples/src/eclipse.jdt.ls/client/main.ts
@@ -10,5 +10,5 @@ import { runExtendedClient } from '../../common/client/extendedClient.js';
import { eclipseJdtLsConfig } from '../config.js';
export const runEclipseJdtLsClient = async () => {
- await runExtendedClient(eclipseJdtLsConfig, helloJavaCode);
+ await runExtendedClient(eclipseJdtLsConfig, helloJavaCode);
};
diff --git a/packages/examples/src/eclipse.jdt.ls/config.ts b/packages/examples/src/eclipse.jdt.ls/config.ts
index a6da551f1..95ebccf5b 100644
--- a/packages/examples/src/eclipse.jdt.ls/config.ts
+++ b/packages/examples/src/eclipse.jdt.ls/config.ts
@@ -6,9 +6,9 @@
import type { ExampleLsConfig } from '../common/client/extendedClient.js';
export const eclipseJdtLsConfig: ExampleLsConfig = {
- port: 30003,
- path: '/jdtls',
- basePath: '/home/mlc/packages/examples/resources/eclipse.jdt.ls',
- languageId: 'java',
- useExternalWebSocket: false
+ port: 30003,
+ path: '/jdtls',
+ basePath: '/home/mlc/packages/examples/resources/eclipse.jdt.ls',
+ languageId: 'java',
+ useExternalWebSocket: false
};
diff --git a/packages/examples/src/eclipse.jdt.ls/server/main.ts b/packages/examples/src/eclipse.jdt.ls/server/main.ts
index 027ed2579..acb25a043 100644
--- a/packages/examples/src/eclipse.jdt.ls/server/main.ts
+++ b/packages/examples/src/eclipse.jdt.ls/server/main.ts
@@ -7,32 +7,32 @@ import { runLanguageServer } from '../../common/node/language-server-runner.js';
import { eclipseJdtLsConfig } from '../config.js';
export const runEclipseJdtLs = () => {
- runLanguageServer({
- serverName: 'Eclipse JDT LS',
- pathName: eclipseJdtLsConfig.path,
- serverPort: eclipseJdtLsConfig.port,
- runCommand: 'java',
- runCommandArgs: [
- '-Declipse.application=org.eclipse.jdt.ls.core.id1',
- '-Dosgi.bundles.defaultStartLevel=4',
- '-Declipse.product=org.eclipse.jdt.ls.core.product',
- '-Dlog.level=ALL',
- '-Xmx1G',
- '--add-modules=ALL-SYSTEM',
- '--add-opens',
- 'java.base/java.util=ALL-UNNAMED',
- '--add-opens',
- 'java.base/java.lang=ALL-UNNAMED',
- '-jar',
- `${eclipseJdtLsConfig.basePath}/ls/plugins/org.eclipse.equinox.launcher_1.6.900.v20240613-2009.jar`,
- '-configuration',
- `${eclipseJdtLsConfig.basePath}/ls/config_linux`,
- '-data',
- `${eclipseJdtLsConfig.basePath}/workspace`
- ],
- wsServerOptions: {
- noServer: true,
- perMessageDeflate: false
- }
- });
+ runLanguageServer({
+ serverName: 'Eclipse JDT LS',
+ pathName: eclipseJdtLsConfig.path,
+ serverPort: eclipseJdtLsConfig.port,
+ runCommand: 'java',
+ runCommandArgs: [
+ '-Declipse.application=org.eclipse.jdt.ls.core.id1',
+ '-Dosgi.bundles.defaultStartLevel=4',
+ '-Declipse.product=org.eclipse.jdt.ls.core.product',
+ '-Dlog.level=ALL',
+ '-Xmx1G',
+ '--add-modules=ALL-SYSTEM',
+ '--add-opens',
+ 'java.base/java.util=ALL-UNNAMED',
+ '--add-opens',
+ 'java.base/java.lang=ALL-UNNAMED',
+ '-jar',
+ `${eclipseJdtLsConfig.basePath}/ls/plugins/org.eclipse.equinox.launcher_1.6.900.v20240613-2009.jar`,
+ '-configuration',
+ `${eclipseJdtLsConfig.basePath}/ls/config_linux`,
+ '-data',
+ `${eclipseJdtLsConfig.basePath}/workspace`
+ ],
+ wsServerOptions: {
+ noServer: true,
+ perMessageDeflate: false
+ }
+ });
};
diff --git a/packages/examples/src/groovy/client/main.ts b/packages/examples/src/groovy/client/main.ts
index 2c25e8a5b..5d744fe87 100644
--- a/packages/examples/src/groovy/client/main.ts
+++ b/packages/examples/src/groovy/client/main.ts
@@ -10,5 +10,5 @@ import { runExtendedClient } from '../../common/client/extendedClient.js';
import { groovyConfig } from '../config.js';
export const runGroovyClient = async () => {
- await runExtendedClient(groovyConfig, helloGroovyCode);
+ await runExtendedClient(groovyConfig, helloGroovyCode);
};
diff --git a/packages/examples/src/groovy/config.ts b/packages/examples/src/groovy/config.ts
index 8a7759553..a96d3aa0a 100644
--- a/packages/examples/src/groovy/config.ts
+++ b/packages/examples/src/groovy/config.ts
@@ -6,9 +6,9 @@
import type { ExampleLsConfig } from '../common/client/extendedClient.js';
export const groovyConfig: ExampleLsConfig = {
- port: 30002,
- path: '/groovy',
- basePath: '/home/gradle/mlc/packages/examples/resources/groovy',
- languageId: 'groovy',
- useExternalWebSocket: false
+ port: 30002,
+ path: '/groovy',
+ basePath: '/home/gradle/mlc/packages/examples/resources/groovy',
+ languageId: 'groovy',
+ useExternalWebSocket: false
};
diff --git a/packages/examples/src/groovy/server/main.ts b/packages/examples/src/groovy/server/main.ts
index 997fd6798..fbf073fc6 100644
--- a/packages/examples/src/groovy/server/main.ts
+++ b/packages/examples/src/groovy/server/main.ts
@@ -7,18 +7,15 @@ import { runLanguageServer } from '../../common/node/language-server-runner.js';
import { groovyConfig } from '../config.js';
export const runGroovyLanguageServer = () => {
- runLanguageServer({
- serverName: 'GROOVY',
- pathName: groovyConfig.path,
- serverPort: groovyConfig.port,
- runCommand: 'java',
- runCommandArgs: [
- '-jar',
- `${groovyConfig.basePath}/lib/groovy-language-server-all.jar`
- ],
- wsServerOptions: {
- noServer: true,
- perMessageDeflate: false
- }
- });
+ runLanguageServer({
+ serverName: 'GROOVY',
+ pathName: groovyConfig.path,
+ serverPort: groovyConfig.port,
+ runCommand: 'java',
+ runCommandArgs: ['-jar', `${groovyConfig.basePath}/lib/groovy-language-server-all.jar`],
+ wsServerOptions: {
+ noServer: true,
+ perMessageDeflate: false
+ }
+ });
};
diff --git a/packages/examples/src/json/client/classic.ts b/packages/examples/src/json/client/classic.ts
index 527dca895..2e71e39d7 100644
--- a/packages/examples/src/json/client/classic.ts
+++ b/packages/examples/src/json/client/classic.ts
@@ -11,73 +11,73 @@ import { MonacoVscodeApiWrapper, type MonacoVscodeApiConfig } from 'monaco-langu
import { defineDefaultWorkerLoaders, useWorkerFactory } from 'monaco-languageclient/workerFactory';
export const runClient = async () => {
- const htmlContainer = document.getElementById('monaco-editor-root')!;
- const vscodeApiConfig: MonacoVscodeApiConfig = {
- $type: 'classic',
- viewsConfig: {
- $type: 'EditorService',
- htmlContainer
- },
- logLevel: LogLevel.Debug,
- userConfiguration: {
- json: JSON.stringify({
- 'editor.experimental.asyncTokenization': true
- })
- },
- monacoWorkerFactory: configureClassicWorkerFactory
- };
+ const htmlContainer = document.getElementById('monaco-editor-root')!;
+ const vscodeApiConfig: MonacoVscodeApiConfig = {
+ $type: 'classic',
+ viewsConfig: {
+ $type: 'EditorService',
+ htmlContainer
+ },
+ logLevel: LogLevel.Debug,
+ userConfiguration: {
+ json: JSON.stringify({
+ 'editor.experimental.asyncTokenization': true
+ })
+ },
+ monacoWorkerFactory: configureClassicWorkerFactory
+ };
- const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
- await apiWrapper.start();
+ const apiWrapper = new MonacoVscodeApiWrapper(vscodeApiConfig);
+ await apiWrapper.start();
- const languageId = 'json';
- const code = `{
+ const languageId = 'json';
+ const code = `{
"$schema": "http://json.schemastore.org/coffeelint",
"line_endings": "unix"
}`;
- const codeUri = '/workspace/model.json';
- const editorAppConfig: EditorAppConfig = {
- codeResources: {
- modified: {
- text: code,
- uri: codeUri
- }
- },
- languageDef: {
- languageExtensionConfig: {
- id: languageId,
- extensions: ['.json', '.jsonc'],
- aliases: ['JSON', 'json'],
- mimetypes: ['application/json']
- }
- }
- };
- const editorApp = new EditorApp(editorAppConfig);
- await editorApp.start(htmlContainer);
+ const codeUri = '/workspace/model.json';
+ const editorAppConfig: EditorAppConfig = {
+ codeResources: {
+ modified: {
+ text: code,
+ uri: codeUri
+ }
+ },
+ languageDef: {
+ languageExtensionConfig: {
+ id: languageId,
+ extensions: ['.json', '.jsonc'],
+ aliases: ['JSON', 'json'],
+ mimetypes: ['application/json']
+ }
+ }
+ };
+ const editorApp = new EditorApp(editorAppConfig);
+ await editorApp.start(htmlContainer);
- const languageClientConfig: LanguageClientConfig = {
- languageId,
- clientOptions: {
- documentSelector: [languageId]
- },
- connection: {
- options: {
- $type: 'WebSocketUrl',
- url: 'ws://localhost:30000/sampleServer'
- }
- }
- };
- const languageClientWrapper = new LanguageClientWrapper(languageClientConfig);
- await languageClientWrapper.start();
+ const languageClientConfig: LanguageClientConfig = {
+ languageId,
+ clientOptions: {
+ documentSelector: [languageId]
+ },
+ connection: {
+ options: {
+ $type: 'WebSocketUrl',
+ url: 'ws://localhost:30000/sampleServer'
+ }
+ }
+ };
+ const languageClientWrapper = new LanguageClientWrapper(languageClientConfig);
+ await languageClientWrapper.start();
};
export const configureClassicWorkerFactory = (logger?: ILogger) => {
- const defaultworkerLoaders = defineDefaultWorkerLoaders();
- // remove textmate worker as it is not compatible with classic mode
- defaultworkerLoaders.TextMateWorker = undefined;
- defaultworkerLoaders.extensionHostWorkerMain = undefined;
- useWorkerFactory({
- workerLoaders: defaultworkerLoaders,
- logger
- });
+ const defaultworkerLoaders = defineDefaultWorkerLoaders();
+ // remove textmate worker as it is not compatible with classic mode
+ defaultworkerLoaders.TextMateWorker = undefined;
+ defaultworkerLoaders.extensionHostWorkerMain = undefined;
+ useWorkerFactory({
+ workerLoaders: defaultworkerLoaders,
+ logger
+ });
};
diff --git a/packages/examples/src/json/client/config.ts b/packages/examples/src/json/client/config.ts
index 184cf0ce3..23e79b961 100644
--- a/packages/examples/src/json/client/config.ts
+++ b/packages/examples/src/json/client/config.ts
@@ -6,9 +6,9 @@
import type { ExampleLsConfig } from '../../common/client/extendedClient.js';
export const jsontLsConfig: ExampleLsConfig = {
- port: 30000,
- path: '/sampleServer',
- basePath: '/home/mlc/packages/examples/resources/json',
- languageId: 'json',
- useExternalWebSocket: true
+ port: 30000,
+ path: '/sampleServer',
+ basePath: '/home/mlc/packages/examples/resources/json',
+ languageId: 'json',
+ useExternalWebSocket: true
};
diff --git a/packages/examples/src/json/client/extended.ts b/packages/examples/src/json/client/extended.ts
index f05f0fba9..225f49828 100644
--- a/packages/examples/src/json/client/extended.ts
+++ b/packages/examples/src/json/client/extended.ts
@@ -9,9 +9,9 @@ import { runExtendedClient } from '../../common/client/extendedClient.js';
import { jsontLsConfig } from './config.js';
export const runJsonWrapper = async () => {
- const helloJsonCode = `{
+ const helloJsonCode = `{
"$schema": "http://json.schemastore.org/coffeelint",
"line_endings": {"value": "unix"}
}`;
- await runExtendedClient(jsontLsConfig, helloJsonCode);
+ await runExtendedClient(jsontLsConfig, helloJsonCode);
};
diff --git a/packages/examples/src/json/server/json-server.ts b/packages/examples/src/json/server/json-server.ts
index 7d66964a0..eb8c0810d 100644
--- a/packages/examples/src/json/server/json-server.ts
+++ b/packages/examples/src/json/server/json-server.ts
@@ -6,279 +6,292 @@ import { readFile } from 'node:fs';
import requestLight, { type XHRResponse } from 'request-light';
import * as URI from 'vscode-uri';
import 'vscode-ws-jsonrpc';
-import { createConnection, type _Connection, TextDocuments, type DocumentSymbolParams, ProposedFeatures } from 'vscode-languageserver/lib/node/main.js';
import {
- Diagnostic, Command, CompletionList, CompletionItem, Hover,
- SymbolInformation, TextEdit, FoldingRange, ColorInformation, ColorPresentation
+ createConnection,
+ type _Connection,
+ TextDocuments,
+ type DocumentSymbolParams,
+ ProposedFeatures
+} from 'vscode-languageserver/lib/node/main.js';
+import {
+ Diagnostic,
+ Command,
+ CompletionList,
+ CompletionItem,
+ Hover,
+ SymbolInformation,
+ TextEdit,
+ FoldingRange,
+ ColorInformation,
+ ColorPresentation
} from 'vscode-languageserver-types';
-import type { TextDocumentPositionParams, DocumentRangeFormattingParams, ExecuteCommandParams, CodeActionParams, FoldingRangeParams, DocumentColorParams, ColorPresentationParams } from 'vscode-languageserver-protocol';
+import type {
+ TextDocumentPositionParams,
+ DocumentRangeFormattingParams,
+ ExecuteCommandParams,
+ CodeActionParams,
+ FoldingRangeParams,
+ DocumentColorParams,
+ ColorPresentationParams
+} from 'vscode-languageserver-protocol';
import { TextDocumentSyncKind } from 'vscode-languageserver-protocol';
import { getLanguageService, type LanguageService, type JSONDocument } from 'vscode-json-languageservice';
import { TextDocument } from 'vscode-languageserver-textdocument';
import { Deferred } from 'monaco-languageclient/common';
export class JsonServer {
- protected readonly connection: _Connection;
- protected workspaceRoot: URI.URI | undefined;
- protected readonly documents = new TextDocuments(TextDocument);
-
- protected readonly jsonService: LanguageService = getLanguageService({
- schemaRequestService: this.resolveSchema.bind(this)
- });
+ protected readonly connection: _Connection;
+ protected workspaceRoot: URI.URI | undefined;
+ protected readonly documents = new TextDocuments(TextDocument);
- protected readonly pendingValidationRequests = new Map();
-
- constructor(connection: _Connection) {
- this.connection = connection;
- this.documents.listen(this.connection);
- this.documents.onDidChangeContent(change =>
- this.validate(change.document)
- );
- this.documents.onDidClose(event => {
- this.cleanPendingValidation(event.document);
- this.cleanDiagnostics(event.document).catch(error => {
- this.connection.console.error(`Error while cleaning diagnostics: ${String(error)}`);
- });
- });
+ protected readonly jsonService: LanguageService = getLanguageService({
+ schemaRequestService: this.resolveSchema.bind(this)
+ });
- this.connection.onInitialize(params => {
- if (params.rootPath !== null && params.rootPath !== undefined) {
- this.workspaceRoot = URI.URI.file(params.rootPath);
- } else if (params.rootUri !== null) {
- this.workspaceRoot = URI.URI.parse(params.rootUri);
- }
- this.connection.console.log('The server is initialized.');
- return {
- capabilities: {
- textDocumentSync: TextDocumentSyncKind.Incremental,
- codeActionProvider: true,
- completionProvider: {
- resolveProvider: true,
- triggerCharacters: ['"', ':']
- },
- hoverProvider: true,
- documentSymbolProvider: true,
- documentRangeFormattingProvider: true,
- executeCommandProvider: {
- commands: ['json.documentUpper']
- },
- colorProvider: true,
- foldingRangeProvider: true
- }
- };
- });
- this.connection.onCodeAction(params =>
- this.codeAction(params)
- );
- this.connection.onCompletion(params =>
- this.completion(params)
- );
- this.connection.onCompletionResolve(item =>
- this.resolveCompletion(item)
- );
- this.connection.onExecuteCommand(params =>
- this.executeCommand(params)
- );
- this.connection.onHover(params =>
- this.hover(params)
- );
- this.connection.onDocumentSymbol(params =>
- this.findDocumentSymbols(params)
- );
- this.connection.onDocumentRangeFormatting(params =>
- this.format(params)
- );
- this.connection.onDocumentColor(params =>
- this.findDocumentColors(params)
- );
- this.connection.onColorPresentation(params =>
- this.getColorPresentations(params)
- );
- this.connection.onFoldingRanges(params =>
- this.getFoldingRanges(params)
- );
- }
+ protected readonly pendingValidationRequests = new Map();
- start() {
- this.connection.listen();
- }
+ constructor(connection: _Connection) {
+ this.connection = connection;
+ this.documents.listen(this.connection);
+ this.documents.onDidChangeContent((change) => this.validate(change.document));
+ this.documents.onDidClose((event) => {
+ this.cleanPendingValidation(event.document);
+ this.cleanDiagnostics(event.document).catch((error) => {
+ this.connection.console.error(`Error while cleaning diagnostics: ${String(error)}`);
+ });
+ });
- protected getFoldingRanges(params: FoldingRangeParams): FoldingRange[] {
- const document = this.documents.get(params.textDocument.uri);
- if (document === undefined) {
- return [];
+ this.connection.onInitialize((params) => {
+ if (params.rootPath !== null && params.rootPath !== undefined) {
+ this.workspaceRoot = URI.URI.file(params.rootPath);
+ } else if (params.rootUri !== null) {
+ this.workspaceRoot = URI.URI.parse(params.rootUri);
+ }
+ this.connection.console.log('The server is initialized.');
+ return {
+ capabilities: {
+ textDocumentSync: TextDocumentSyncKind.Incremental,
+ codeActionProvider: true,
+ completionProvider: {
+ resolveProvider: true,
+ triggerCharacters: ['"', ':']
+ },
+ hoverProvider: true,
+ documentSymbolProvider: true,
+ documentRangeFormattingProvider: true,
+ executeCommandProvider: {
+ commands: ['json.documentUpper']
+ },
+ colorProvider: true,
+ foldingRangeProvider: true
}
- return this.jsonService.getFoldingRanges(document);
- }
+ };
+ });
+ this.connection.onCodeAction((params) => this.codeAction(params));
+ this.connection.onCompletion((params) => this.completion(params));
+ this.connection.onCompletionResolve((item) => this.resolveCompletion(item));
+ this.connection.onExecuteCommand((params) => this.executeCommand(params));
+ this.connection.onHover((params) => this.hover(params));
+ this.connection.onDocumentSymbol((params) => this.findDocumentSymbols(params));
+ this.connection.onDocumentRangeFormatting((params) => this.format(params));
+ this.connection.onDocumentColor((params) => this.findDocumentColors(params));
+ this.connection.onColorPresentation((params) => this.getColorPresentations(params));
+ this.connection.onFoldingRanges((params) => this.getFoldingRanges(params));
+ }
- protected findDocumentColors(params: DocumentColorParams): Thenable {
- const document = this.documents.get(params.textDocument.uri);
- if (document === undefined) {
- return Promise.resolve([]);
- }
- const jsonDocument = this.getJSONDocument(document);
- return this.jsonService.findDocumentColors(document, jsonDocument);
- }
+ start() {
+ this.connection.listen();
+ }
- protected getColorPresentations(params: ColorPresentationParams): ColorPresentation[] {
- const document = this.documents.get(params.textDocument.uri);
- if (document === undefined) {
- return [];
- }
- const jsonDocument = this.getJSONDocument(document);
- return this.jsonService.getColorPresentations(document, jsonDocument, params.color, params.range);
+ protected getFoldingRanges(params: FoldingRangeParams): FoldingRange[] {
+ const document = this.documents.get(params.textDocument.uri);
+ if (document === undefined) {
+ return [];
}
+ return this.jsonService.getFoldingRanges(document);
+ }
- protected codeAction(params: CodeActionParams): Command[] {
- const document = this.documents.get(params.textDocument.uri);
- if (document === undefined) {
- return [];
- }
- return [{
- title: 'Upper Case Document',
- command: 'json.documentUpper',
- // Send a VersionedTextDocumentIdentifier
- arguments: [{
- ...params.textDocument,
- version: document.version
- }]
- }];
+ protected findDocumentColors(params: DocumentColorParams): Thenable {
+ const document = this.documents.get(params.textDocument.uri);
+ if (document === undefined) {
+ return Promise.resolve([]);
}
+ const jsonDocument = this.getJSONDocument(document);
+ return this.jsonService.findDocumentColors(document, jsonDocument);
+ }
- protected format(params: DocumentRangeFormattingParams): TextEdit[] {
- const document = this.documents.get(params.textDocument.uri);
- return document === undefined ? [] : this.jsonService.format(document, params.range, params.options);
+ protected getColorPresentations(params: ColorPresentationParams): ColorPresentation[] {
+ const document = this.documents.get(params.textDocument.uri);
+ if (document === undefined) {
+ return [];
}
+ const jsonDocument = this.getJSONDocument(document);
+ return this.jsonService.getColorPresentations(document, jsonDocument, params.color, params.range);
+ }
- protected findDocumentSymbols(params: DocumentSymbolParams): SymbolInformation[] {
- const document = this.documents.get(params.textDocument.uri);
- if (document === undefined) {
- return [];
- }
- const jsonDocument = this.getJSONDocument(document);
- return this.jsonService.findDocumentSymbols(document, jsonDocument);
+ protected codeAction(params: CodeActionParams): Command[] {
+ const document = this.documents.get(params.textDocument.uri);
+ if (document === undefined) {
+ return [];
}
+ return [
+ {
+ title: 'Upper Case Document',
+ command: 'json.documentUpper',
+ // Send a VersionedTextDocumentIdentifier
+ arguments: [
+ {
+ ...params.textDocument,
+ version: document.version
+ }
+ ]
+ }
+ ];
+ }
- // oxlint-disable-next-line @typescript-eslint/no-explicit-any
- protected async executeCommand(params: ExecuteCommandParams): Promise {
- if (params.command === 'json.documentUpper' && params.arguments !== undefined) {
- const versionedTextDocumentIdentifier = params.arguments[0];
- const document = this.documents.get(versionedTextDocumentIdentifier.uri);
- if (document !== undefined) {
- await this.connection.workspace.applyEdit({
- documentChanges: [{
- textDocument: versionedTextDocumentIdentifier,
- edits: [{
- range: {
- start: { line: 0, character: 0 },
- end: { line: Number.MAX_SAFE_INTEGER, character: Number.MAX_SAFE_INTEGER }
- },
- newText: document.getText().toUpperCase()
- }]
- }]
- });
- }
- }
- }
+ protected format(params: DocumentRangeFormattingParams): TextEdit[] {
+ const document = this.documents.get(params.textDocument.uri);
+ return document === undefined ? [] : this.jsonService.format(document, params.range, params.options);
+ }
- protected hover(params: TextDocumentPositionParams): Thenable {
- const document = this.documents.get(params.textDocument.uri);
- if (document === undefined) {
- return Promise.resolve(null);
- }
- const jsonDocument = this.getJSONDocument(document);
- return this.jsonService.doHover(document, params.position, jsonDocument);
+ protected findDocumentSymbols(params: DocumentSymbolParams): SymbolInformation[] {
+ const document = this.documents.get(params.textDocument.uri);
+ if (document === undefined) {
+ return [];
}
+ const jsonDocument = this.getJSONDocument(document);
+ return this.jsonService.findDocumentSymbols(document, jsonDocument);
+ }
- protected async resolveSchema(url: string): Promise {
- const uri = URI.URI.parse(url);
- if (uri.scheme === 'file') {
- return new Promise((resolve, reject) => {
- readFile(uri.fsPath, { encoding: 'utf8' }, (err, result) => {
- if (err === null) {
- resolve(result.toString());
- } else {
- reject(err);
- }
- });
- });
- }
-
- const deferred = new Deferred();
- requestLight.xhr({ url, followRedirects: 5 }).then(response => {
- deferred.resolve(response.responseText);
- }).catch((error: Error | XHRResponse) => {
- let errorMessage: string;
- if (error instanceof Error) {
- errorMessage = `Schema resolution failed: ${error.message}`;
- } else {
- const xhrResponse = error as XHRResponse;
- errorMessage = `Schema resolution failed: ${requestLight.getErrorStatusDescription(xhrResponse.status)} ocurred: ${xhrResponse.responseText}`;
+ // oxlint-disable-next-line @typescript-eslint/no-explicit-any
+ protected async executeCommand(params: ExecuteCommandParams): Promise {
+ if (params.command === 'json.documentUpper' && params.arguments !== undefined) {
+ const versionedTextDocumentIdentifier = params.arguments[0];
+ const document = this.documents.get(versionedTextDocumentIdentifier.uri);
+ if (document !== undefined) {
+ await this.connection.workspace.applyEdit({
+ documentChanges: [
+ {
+ textDocument: versionedTextDocumentIdentifier,
+ edits: [
+ {
+ range: {
+ start: { line: 0, character: 0 },
+ end: { line: Number.MAX_SAFE_INTEGER, character: Number.MAX_SAFE_INTEGER }
+ },
+ newText: document.getText().toUpperCase()
+ }
+ ]
}
- deferred.reject(errorMessage);
+ ]
});
+ }
+ }
+ }
- return deferred.promise;
+ protected hover(params: TextDocumentPositionParams): Thenable {
+ const document = this.documents.get(params.textDocument.uri);
+ if (document === undefined) {
+ return Promise.resolve(null);
}
+ const jsonDocument = this.getJSONDocument(document);
+ return this.jsonService.doHover(document, params.position, jsonDocument);
+ }
- protected resolveCompletion(item: CompletionItem): Thenable {
- return this.jsonService.doResolve(item);
+ protected async resolveSchema(url: string): Promise {
+ const uri = URI.URI.parse(url);
+ if (uri.scheme === 'file') {
+ return new Promise((resolve, reject) => {
+ readFile(uri.fsPath, { encoding: 'utf8' }, (err, result) => {
+ if (err === null) {
+ resolve(result.toString());
+ } else {
+ reject(err);
+ }
+ });
+ });
}
- protected completion(params: TextDocumentPositionParams): Thenable {
- const document = this.documents.get(params.textDocument.uri);
- if (document === undefined) {
- return Promise.resolve(null);
+ const deferred = new Deferred();
+ requestLight
+ .xhr({ url, followRedirects: 5 })
+ .then((response) => {
+ deferred.resolve(response.responseText);
+ })
+ .catch((error: Error | XHRResponse) => {
+ let errorMessage: string;
+ if (error instanceof Error) {
+ errorMessage = `Schema resolution failed: ${error.message}`;
+ } else {
+ const xhrResponse = error as XHRResponse;
+ errorMessage = `Schema resolution failed: ${requestLight.getErrorStatusDescription(xhrResponse.status)} ocurred: ${xhrResponse.responseText}`;
}
- const jsonDocument = this.getJSONDocument(document);
- return this.jsonService.doComplete(document, params.position, jsonDocument);
- }
+ deferred.reject(errorMessage);
+ });
- protected validate(document: TextDocument): void {
- this.cleanPendingValidation(document);
- this.pendingValidationRequests.set(document.uri, setTimeout(async () => {
- this.pendingValidationRequests.delete(document.uri);
- await this.doValidate(document);
- }));
- }
+ return deferred.promise;
+ }
- protected cleanPendingValidation(document: TextDocument): void {
- const request = this.pendingValidationRequests.get(document.uri);
- if (request !== undefined) {
- clearTimeout(request);
- this.pendingValidationRequests.delete(document.uri);
- }
- }
+ protected resolveCompletion(item: CompletionItem): Thenable {
+ return this.jsonService.doResolve(item);
+ }
- protected async doValidate(document: TextDocument): Promise {
- if (document.getText().length === 0) {
- await this.cleanDiagnostics(document);
- return;
- }
- const jsonDocument = this.getJSONDocument(document);
- this.jsonService.doValidation(document, jsonDocument).then(diagnostics =>
- this.sendDiagnostics(document, diagnostics)
- );
+ protected completion(params: TextDocumentPositionParams): Thenable {
+ const document = this.documents.get(params.textDocument.uri);
+ if (document === undefined) {
+ return Promise.resolve(null);
}
+ const jsonDocument = this.getJSONDocument(document);
+ return this.jsonService.doComplete(document, params.position, jsonDocument);
+ }
- protected async cleanDiagnostics(document: TextDocument): Promise {
- await this.sendDiagnostics(document, []);
- }
+ protected validate(document: TextDocument): void {
+ this.cleanPendingValidation(document);
+ this.pendingValidationRequests.set(
+ document.uri,
+ setTimeout(async () => {
+ this.pendingValidationRequests.delete(document.uri);
+ await this.doValidate(document);
+ })
+ );
+ }
- protected async sendDiagnostics(document: TextDocument, diagnostics: Diagnostic[]): Promise {
- await this.connection.sendDiagnostics({
- uri: document.uri, diagnostics
- });
+ protected cleanPendingValidation(document: TextDocument): void {
+ const request = this.pendingValidationRequests.get(document.uri);
+ if (request !== undefined) {
+ clearTimeout(request);
+ this.pendingValidationRequests.delete(document.uri);
}
+ }
- protected getJSONDocument(document: TextDocument): JSONDocument {
- return this.jsonService.parseJSONDocument(document);
+ protected async doValidate(document: TextDocument): Promise {
+ if (document.getText().length === 0) {
+ await this.cleanDiagnostics(document);
+ return;
}
+ const jsonDocument = this.getJSONDocument(document);
+ this.jsonService.doValidation(document, jsonDocument).then((diagnostics) => this.sendDiagnostics(document, diagnostics));
+ }
+
+ protected async cleanDiagnostics(document: TextDocument): Promise {
+ await this.sendDiagnostics(document, []);
+ }
+
+ protected async sendDiagnostics(document: TextDocument, diagnostics: Diagnostic[]): Promise {
+ await this.connection.sendDiagnostics({
+ uri: document.uri,
+ diagnostics
+ });
+ }
+
+ protected getJSONDocument(document: TextDocument): JSONDocument {
+ return this.jsonService.parseJSONDocument(document);
+ }
}
const scriptExec = process.argv[2];
if (scriptExec === '--stdio') {
- const connection = createConnection(ProposedFeatures.all);
- const ls = new JsonServer(connection);
- ls.start();
+ const connection = createConnection(ProposedFeatures.all);
+ const ls = new JsonServer(connection);
+ ls.start();
}
diff --git a/packages/examples/src/json/server/main.ts b/packages/examples/src/json/server/main.ts
index 62d25d951..bae42eeb0 100644
--- a/packages/examples/src/json/server/main.ts
+++ b/packages/examples/src/json/server/main.ts
@@ -9,37 +9,34 @@ import { resolve } from 'node:path';
import { runLanguageServer } from '../../common/node/language-server-runner.js';
export const runJsonServer = (baseDir: string, relativeDir: string) => {
- const processRunPath = resolve(baseDir, relativeDir);
- runLanguageServer({
- serverName: 'JSON',
- pathName: '/sampleServer',
- serverPort: 30000,
- runCommand: 'node',
- runCommandArgs: [
- processRunPath,
- '--stdio'
- ],
- wsServerOptions: {
- noServer: true,
- perMessageDeflate: false
- }
- });
+ const processRunPath = resolve(baseDir, relativeDir);
+ runLanguageServer({
+ serverName: 'JSON',
+ pathName: '/sampleServer',
+ serverPort: 30000,
+ runCommand: 'node',
+ runCommandArgs: [processRunPath, '--stdio'],
+ wsServerOptions: {
+ noServer: true,
+ perMessageDeflate: false
+ }
+ });
- startMockHttpServerForSavingCodeFromEditor();
+ startMockHttpServerForSavingCodeFromEditor();
};
export const startMockHttpServerForSavingCodeFromEditor = () => {
- const app = express();
- app.use(cors());
- app.use(express.json());
- app.post('/save-code', (req, res) => {
- const { code } = req.body;
- console.log('Received code:', code);
- res.json({ success: true, message: code });
- });
+ const app = express();
+ app.use(cors());
+ app.use(express.json());
+ app.post('/save-code', (req, res) => {
+ const { code } = req.body;
+ console.log('Received code:', code);
+ res.json({ success: true, message: code });
+ });
- const PORT = 3003;
- app.listen(PORT, () => {
- console.log(`JSON server running on port ${PORT}`);
- });
+ const PORT = 3003;
+ app.listen(PORT, () => {
+ console.log(`JSON server running on port ${PORT}`);
+ });
};
diff --git a/packages/examples/src/langium/langium-dsl/config/langium.configuration.json b/packages/examples/src/langium/langium-dsl/config/langium.configuration.json
index d871c4b41..91326769b 100644
--- a/packages/examples/src/langium/langium-dsl/config/langium.configuration.json
+++ b/packages/examples/src/langium/langium-dsl/config/langium.configuration.json
@@ -1,134 +1,106 @@
{
- "comments": {
- "lineComment": "//",
- "blockComment": ["/*", "*/"]
+ "comments": {
+ "lineComment": "//",
+ "blockComment": ["/*", "*/"]
+ },
+ "brackets": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"]
+ ],
+ "autoClosingPairs": [
+ { "open": "{", "close": "}" },
+ { "open": "[", "close": "]" },
+ { "open": "(", "close": ")" },
+ {
+ "open": "'",
+ "close": "'",
+ "notIn": ["string", "comment"]
},
- "brackets": [
- ["{", "}"],
- ["[", "]"],
- ["(", ")"]
- ],
- "autoClosingPairs": [
- { "open": "{", "close": "}" },
- { "open": "[", "close": "]" },
- { "open": "(", "close": ")" },
- {
- "open": "'",
- "close": "'",
- "notIn": [
- "string",
- "comment"
- ]
- },
- {
- "open": "\"",
- "close": "\"",
- "notIn": [
- "string"
- ]
- },
- {
- "open": "/**",
- "close": " */",
- "notIn": [
- "string"
- ]
- }
- ],
- "autoCloseBefore": "}])`\n\t",
- "surroundingPairs": [
- ["{", "}"],
- ["[", "]"],
- ["(", ")"]
- ],
- "colorizedBracketPairs": [
- [
- "(",
- ")"
- ],
- [
- "[",
- "]"
- ],
- [
- "{",
- "}"
- ],
- [
- "<",
- ">"
- ],
- [
- "'",
- "'"
- ],
- [
- "\"",
- "\""
- ],
- [
- "<",
- ">"
- ]
- ],
- "onEnterRules": [
- {
- "": "// e.g. /** | */",
- "beforeText": {
- "pattern": "^\\s*/\\*\\*(?!/)([^\\*]|\\*(?!/))*$"
- },
- "afterText": {
- "pattern": "^\\s*\\*/$"
- },
- "action": {
- "indent": "indentOutdent",
- "appendText": " * "
- }
- },
- {
- "": "// e.g. /** ...|",
- "beforeText": {
- "pattern": "^\\s*/\\*\\*(?!/)([^\\*]|\\*(?!/))*$"
- },
- "action": {
- "indent": "none",
- "appendText": " * "
- }
- },
- {
- "": "// e.g. * ...|",
- "beforeText": {
- "pattern": "^(\\t|[ ])*[ ]\\*([ ]([^\\*]|\\*(?!/))*)?$"
- },
- "previousLineText": {
- "pattern": "(?=^(\\s*(/\\*\\*|\\*)).*)(?=(?!(\\s*\\*/)))"
- },
- "action": {
- "indent": "none",
- "appendText": "* "
- }
- },
- {
- "": "// e.g. */|",
- "beforeText": {
- "pattern": "^(\\t|[ ])*[ ]\\*/\\s*$"
- },
- "action": {
- "indent": "none",
- "removeText": 1
- }
- },
- {
- "beforeText": ":\\s*$",
- "action": {
- "indent": "indent"
- }
- },
- {
- "beforeText": ";\\s*$",
- "action": {
- "indent": "outdent"
- }
- }
- ]
+ {
+ "open": "\"",
+ "close": "\"",
+ "notIn": ["string"]
+ },
+ {
+ "open": "/**",
+ "close": " */",
+ "notIn": ["string"]
+ }
+ ],
+ "autoCloseBefore": "}])`\n\t",
+ "surroundingPairs": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"]
+ ],
+ "colorizedBracketPairs": [
+ ["(", ")"],
+ ["[", "]"],
+ ["{", "}"],
+ ["<", ">"],
+ ["'", "'"],
+ ["\"", "\""],
+ ["<", ">"]
+ ],
+ "onEnterRules": [
+ {
+ "": "// e.g. /** | */",
+ "beforeText": {
+ "pattern": "^\\s*/\\*\\*(?!/)([^\\*]|\\*(?!/))*$"
+ },
+ "afterText": {
+ "pattern": "^\\s*\\*/$"
+ },
+ "action": {
+ "indent": "indentOutdent",
+ "appendText": " * "
+ }
+ },
+ {
+ "": "// e.g. /** ...|",
+ "beforeText": {
+ "pattern": "^\\s*/\\*\\*(?!/)([^\\*]|\\*(?!/))*$"
+ },
+ "action": {
+ "indent": "none",
+ "appendText": " * "
+ }
+ },
+ {
+ "": "// e.g. * ...|",
+ "beforeText": {
+ "pattern": "^(\\t|[ ])*[ ]\\*([ ]([^\\*]|\\*(?!/))*)?$"
+ },
+ "previousLineText": {
+ "pattern": "(?=^(\\s*(/\\*\\*|\\*)).*)(?=(?!(\\s*\\*/)))"
+ },
+ "action": {
+ "indent": "none",
+ "appendText": "* "
+ }
+ },
+ {
+ "": "// e.g. */|",
+ "beforeText": {
+ "pattern": "^(\\t|[ ])*[ ]\\*/\\s*$"
+ },
+ "action": {
+ "indent": "none",
+ "removeText": 1
+ }
+ },
+ {
+ "beforeText": ":\\s*$",
+ "action": {
+ "indent": "indent"
+ }
+ },
+ {
+ "beforeText": ";\\s*$",
+ "action": {
+ "indent": "outdent"
+ }
+ }
+ ]
}
diff --git a/packages/examples/src/langium/langium-dsl/config/langium.monarch.ts b/packages/examples/src/langium/langium-dsl/config/langium.monarch.ts
index 6f11bb2c3..c587dc2c8 100644
--- a/packages/examples/src/langium/langium-dsl/config/langium.monarch.ts
+++ b/packages/examples/src/langium/langium-dsl/config/langium.monarch.ts
@@ -4,89 +4,68 @@
* ------------------------------------------------------------------------------------------ */
export const LangiumMonarchContent = {
- keywords: [
- 'bigint',
- 'boolean',
- 'current',
- 'Date',
- 'entry',
- 'extends',
- 'false',
- 'fragment',
- 'grammar',
- 'hidden',
- 'import',
- 'infer',
- 'infers',
- 'interface',
- 'number',
- 'returns',
- 'string',
- 'terminal',
- 'true',
- 'type',
- 'with',
+ keywords: [
+ 'bigint',
+ 'boolean',
+ 'current',
+ 'Date',
+ 'entry',
+ 'extends',
+ 'false',
+ 'fragment',
+ 'grammar',
+ 'hidden',
+ 'import',
+ 'infer',
+ 'infers',
+ 'interface',
+ 'number',
+ 'returns',
+ 'string',
+ 'terminal',
+ 'true',
+ 'type',
+ 'with'
+ ],
+ operators: ['->', ',', ';', ':', '!', '?', '?=', '.', '..', '@', '*', '&', '+', '+=', '<', '=', '=>', '>', '|'],
+ symbols: /->|,|;|:|!|\?|\?=|\.|\.\.|\(|\)|\[|\[\]|\]|\{|\}|@|\*|&|\+|\+=|<|=|=>|>|\|/,
+
+ tokenizer: {
+ initial: [
+ {
+ regex: /\/(?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+\//,
+ action: { token: 'string' }
+ },
+ {
+ regex: /\^?[_a-zA-Z][\w_]*/,
+ action: {
+ cases: {
+ '@keywords': { token: 'keyword' },
+ '@default': { token: 'ID' }
+ }
+ }
+ },
+ { regex: /"[^"]*"|'[^']*'/, action: { token: 'string' } },
+ { include: '@whitespace' },
+ {
+ regex: /@symbols/,
+ action: {
+ cases: {
+ '@operators': { token: 'operator' },
+ '@default': { token: '' }
+ }
+ }
+ }
],
- operators: [
- '->',
- ',',
- ';',
- ':',
- '!',
- '?',
- '?=',
- '.',
- '..',
- '@',
- '*',
- '&',
- '+',
- '+=',
- '<',
- '=',
- '=>',
- '>',
- '|',
+ whitespace: [
+ { regex: /\s+/, action: { token: 'white' } },
+ { regex: /\/\*/, action: { token: 'comment', next: '@comment' } },
+ { regex: /\/\/[^\n\r]*/, action: { token: 'comment' } }
],
- symbols:
- /->|,|;|:|!|\?|\?=|\.|\.\.|\(|\)|\[|\[\]|\]|\{|\}|@|\*|&|\+|\+=|<|=|=>|>|\|/,
-
- tokenizer: {
- initial: [
- {
- regex: /\/(?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+\//,
- action: { token: 'string' },
- },
- {
- regex: /\^?[_a-zA-Z][\w_]*/,
- action: {
- cases: {
- '@keywords': { token: 'keyword' },
- '@default': { token: 'ID' },
- },
- },
- },
- { regex: /"[^"]*"|'[^']*'/, action: { token: 'string' } },
- { include: '@whitespace' },
- {
- regex: /@symbols/,
- action: {
- cases: {
- '@operators': { token: 'operator' },
- '@default': { token: '' },
- },
- },
- },
- ],
- whitespace: [
- { regex: /\s+/, action: { token: 'white' } },
- { regex: /\/\*/, action: { token: 'comment', next: '@comment' } },
- { regex: /\/\/[^\n\r]*/, action: { token: 'comment' } },
- ],
- comment: [
- { regex: /[^/*]+/, action: { token: 'comment' } },
- { regex: /\*\//, action: { token: 'comment', next: '@pop' } },
- { regex: /[/*]/, action: { token: 'comment' } },
- ],
- },
+ comment: [
+ { regex: /[^/*]+/, action: { token: 'comment' } },
+ { regex: /\*\//, action: { token: 'comment', next: '@pop' } },
+ { regex: /[/*]/, action: { token: 'comment' } }
+ ]
+ }
};
diff --git a/packages/examples/src/langium/langium-dsl/config/langium.tmLanguage.json b/packages/examples/src/langium/langium-dsl/config/langium.tmLanguage.json
index 256e47386..764f78328 100644
--- a/packages/examples/src/langium/langium-dsl/config/langium.tmLanguage.json
+++ b/packages/examples/src/langium/langium-dsl/config/langium.tmLanguage.json
@@ -1,290 +1,288 @@
{
- "name": "Langium",
- "scopeName": "source.langium",
- "fileTypes": [
- "langium"
- ],
- "patterns": [
+ "name": "Langium",
+ "scopeName": "source.langium",
+ "fileTypes": ["langium"],
+ "patterns": [
+ {
+ "include": "#regex"
+ },
+ {
+ "include": "#comments"
+ },
+ {
+ "name": "keyword.control.langium",
+ "match": "\\b(left|right|assoc|current|entry|extends|fragment|grammar|hidden|import|infer|infers|infix|interface|returns|terminal|type|with|on)\\b"
+ },
+ {
+ "name": "constant.language.langium",
+ "match": "\\b(?i:true|false)\\b"
+ },
+ {
+ "name": "keyword.symbol.langium",
+ "match": "(\\{|\\}|\\:|\\]|\\[|\\(|\\)|(\\??|\\+?)\\=|->|\\=>|<|>|\\,|\\*|\\+|\\@|\\||\\&|\\?|\\!|\\;)"
+ },
+ {
+ "name": "string.quoted.double.langium",
+ "begin": "\"",
+ "end": "\"",
+ "patterns": [
{
- "include": "#regex"
+ "include": "#string-character-escape"
+ }
+ ]
+ },
+ {
+ "name": "string.quoted.single.langium",
+ "begin": "'",
+ "end": "'",
+ "patterns": [
+ {
+ "include": "#string-character-escape"
+ }
+ ]
+ }
+ ],
+ "repository": {
+ "comments": {
+ "patterns": [
+ {
+ "name": "comment.block.langium",
+ "begin": "/\\*",
+ "beginCaptures": {
+ "0": {
+ "name": "punctuation.definition.comment.langium"
+ }
+ },
+ "end": "\\*/",
+ "endCaptures": {
+ "0": {
+ "name": "punctuation.definition.comment.langium"
+ }
+ }
+ },
+ {
+ "begin": "(^\\s+)?(?=//)",
+ "beginCaptures": {
+ "1": {
+ "name": "punctuation.whitespace.comment.leading.cs"
+ }
+ },
+ "end": "(?=$)",
+ "name": "comment.line.langium"
+ }
+ ]
+ },
+ "string-character-escape": {
+ "name": "constant.character.escape.langium",
+ "match": "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\\{[0-9A-Fa-f]+\\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)"
+ },
+ "regex": {
+ "patterns": [
+ {
+ "name": "string.regexp.ts",
+ "begin": "(?|&&|\\|\\||\\*\\/)\\s*(\\/)(?![\\/*])(?=(?:[^\\/\\\\\\[\\()]|\\\\.|\\[([^\\]\\\\]|\\\\.)+\\]|\\(([^\\)\\\\]|\\\\.)+\\))+\\/([a-z]+|(?![\\/\\*])|(?=\\/\\*))(?!\\s*[a-zA-Z0-9_$]))",
+ "beginCaptures": {
+ "1": {
+ "name": "punctuation.definition.string.begin.ts"
+ }
+ },
+ "end": "(/)([a-z]*)",
+ "endCaptures": {
+ "1": {
+ "name": "punctuation.definition.string.end.ts"
+ },
+ "2": {
+ "name": "keyword.other.ts"
+ }
+ },
+ "patterns": [
+ {
+ "include": "#regexp"
+ }
+ ]
},
{
- "include": "#comments"
+ "name": "string.regexp.ts",
+ "begin": "((?",
+ "captures": {
+ "0": {
+ "name": "keyword.other.back-reference.regexp"
+ },
+ "1": {
+ "name": "variable.other.regexp"
+ }
+ }
},
{
- "name": "constant.language.langium",
- "match": "\\b(?i:true|false)\\b"
+ "name": "keyword.operator.quantifier.regexp",
+ "match": "[?+*]|\\{(\\d+,\\d+|\\d+,|,\\d+|\\d+)\\}\\??"
},
{
- "name": "keyword.symbol.langium",
- "match": "(\\{|\\}|\\:|\\]|\\[|\\(|\\)|(\\??|\\+?)\\=|->|\\=>|<|>|\\,|\\*|\\+|\\@|\\||\\&|\\?|\\!|\\;)"
+ "name": "keyword.operator.or.regexp",
+ "match": "\\|"
},
{
- "name": "string.quoted.double.langium",
- "begin": "\"",
- "end": "\"",
- "patterns": [
- {
- "include": "#string-character-escape"
- }
- ]
+ "name": "meta.group.assertion.regexp",
+ "begin": "(\\()((\\?=)|(\\?!)|(\\?<=)|(\\?))?",
+ "beginCaptures": {
+ "0": {
+ "name": "punctuation.definition.group.regexp"
+ },
+ "1": {
+ "name": "punctuation.definition.group.no-capture.regexp"
+ },
+ "2": {
+ "name": "variable.other.regexp"
+ }
+ },
+ "end": "\\)",
+ "endCaptures": {
+ "0": {
+ "name": "punctuation.definition.group.regexp"
+ }
+ },
+ "patterns": [
+ {
+ "include": "#regexp"
+ }
+ ]
+ },
+ {
+ "name": "constant.other.character-class.set.regexp",
+ "begin": "(\\[)(\\^)?",
+ "beginCaptures": {
+ "1": {
+ "name": "punctuation.definition.character-class.regexp"
+ },
+ "2": {
+ "name": "keyword.operator.negation.regexp"
+ }
+ },
+ "end": "(\\])",
+ "endCaptures": {
+ "1": {
+ "name": "punctuation.definition.character-class.regexp"
+ }
+ },
+ "patterns": [
+ {
+ "name": "constant.other.character-class.range.regexp",
+ "match": "(?:.|(\\\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\\\c[A-Z])|(\\\\.))\\-(?:[^\\]\\\\]|(\\\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\\\c[A-Z])|(\\\\.))",
+ "captures": {
+ "1": {
+ "name": "constant.character.numeric.regexp"
},
- {
- "begin": "(^\\s+)?(?=//)",
- "beginCaptures": {
- "1": {
- "name": "punctuation.whitespace.comment.leading.cs"
- }
- },
- "end": "(?=$)",
- "name": "comment.line.langium"
+ "2": {
+ "name": "constant.character.control.regexp"
+ },
+ "3": {
+ "name": "constant.character.escape.backslash.regexp"
+ },
+ "4": {
+ "name": "constant.character.numeric.regexp"
+ },
+ "5": {
+ "name": "constant.character.control.regexp"
+ },
+ "6": {
+ "name": "constant.character.escape.backslash.regexp"
}
- ]
+ }
+ },
+ {
+ "include": "#regex-character-class"
+ }
+ ]
},
- "string-character-escape": {
- "name": "constant.character.escape.langium",
- "match": "\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|u\\{[0-9A-Fa-f]+\\}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.|$)"
+ {
+ "include": "#regex-character-class"
+ }
+ ]
+ },
+ "regex-character-class": {
+ "patterns": [
+ {
+ "name": "constant.other.character-class.regexp",
+ "match": "\\\\[wWsSdDtrnvf]|\\."
},
- "regex": {
- "patterns": [
- {
- "name": "string.regexp.ts",
- "begin": "(?|&&|\\|\\||\\*\\/)\\s*(\\/)(?![\\/*])(?=(?:[^\\/\\\\\\[\\()]|\\\\.|\\[([^\\]\\\\]|\\\\.)+\\]|\\(([^\\)\\\\]|\\\\.)+\\))+\\/([a-z]+|(?![\\/\\*])|(?=\\/\\*))(?!\\s*[a-zA-Z0-9_$]))",
- "beginCaptures": {
- "1": {
- "name": "punctuation.definition.string.begin.ts"
- }
- },
- "end": "(/)([a-z]*)",
- "endCaptures": {
- "1": {
- "name": "punctuation.definition.string.end.ts"
- },
- "2": {
- "name": "keyword.other.ts"
- }
- },
- "patterns": [
- {
- "include": "#regexp"
- }
- ]
- },
- {
- "name": "string.regexp.ts",
- "begin": "((?",
- "captures": {
- "0": {
- "name": "keyword.other.back-reference.regexp"
- },
- "1": {
- "name": "variable.other.regexp"
- }
- }
- },
- {
- "name": "keyword.operator.quantifier.regexp",
- "match": "[?+*]|\\{(\\d+,\\d+|\\d+,|,\\d+|\\d+)\\}\\??"
- },
- {
- "name": "keyword.operator.or.regexp",
- "match": "\\|"
- },
- {
- "name": "meta.group.assertion.regexp",
- "begin": "(\\()((\\?=)|(\\?!)|(\\?<=)|(\\?))?",
- "beginCaptures": {
- "0": {
- "name": "punctuation.definition.group.regexp"
- },
- "1": {
- "name": "punctuation.definition.group.no-capture.regexp"
- },
- "2": {
- "name": "variable.other.regexp"
- }
- },
- "end": "\\)",
- "endCaptures": {
- "0": {
- "name": "punctuation.definition.group.regexp"
- }
- },
- "patterns": [
- {
- "include": "#regexp"
- }
- ]
- },
- {
- "name": "constant.other.character-class.set.regexp",
- "begin": "(\\[)(\\^)?",
- "beginCaptures": {
- "1": {
- "name": "punctuation.definition.character-class.regexp"
- },
- "2": {
- "name": "keyword.operator.negation.regexp"
- }
- },
- "end": "(\\])",
- "endCaptures": {
- "1": {
- "name": "punctuation.definition.character-class.regexp"
- }
- },
- "patterns": [
- {
- "name": "constant.other.character-class.range.regexp",
- "match": "(?:.|(\\\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\\\c[A-Z])|(\\\\.))\\-(?:[^\\]\\\\]|(\\\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\\\c[A-Z])|(\\\\.))",
- "captures": {
- "1": {
- "name": "constant.character.numeric.regexp"
- },
- "2": {
- "name": "constant.character.control.regexp"
- },
- "3": {
- "name": "constant.character.escape.backslash.regexp"
- },
- "4": {
- "name": "constant.character.numeric.regexp"
- },
- "5": {
- "name": "constant.character.control.regexp"
- },
- "6": {
- "name": "constant.character.escape.backslash.regexp"
- }
- }
- },
- {
- "include": "#regex-character-class"
- }
- ]
- },
- {
- "include": "#regex-character-class"
- }
- ]
- },
- "regex-character-class": {
- "patterns": [
- {
- "name": "constant.other.character-class.regexp",
- "match": "\\\\[wWsSdDtrnvf]|\\."
- },
- {
- "name": "constant.character.numeric.regexp",
- "match": "\\\\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})"
- },
- {
- "name": "constant.character.control.regexp",
- "match": "\\\\c[A-Z]"
- },
- {
- "name": "constant.character.escape.backslash.regexp",
- "match": "\\\\."
- }
- ]
- }
+ {
+ "name": "constant.character.numeric.regexp",
+ "match": "\\\\([0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4})"
+ },
+ {
+ "name": "constant.character.control.regexp",
+ "match": "\\\\c[A-Z]"
+ },
+ {
+ "name": "constant.character.escape.backslash.regexp",
+ "match": "\\\\."
+ }
+ ]
}
+ }
}
diff --git a/packages/examples/src/langium/langium-dsl/config/langiumDslConfig.ts b/packages/examples/src/langium/langium-dsl/config/langiumDslConfig.ts
index b2514f133..f8dbfcf87 100644
--- a/packages/examples/src/langium/langium-dsl/config/langiumDslConfig.ts
+++ b/packages/examples/src/langium/langium-dsl/config/langiumDslConfig.ts
@@ -4,7 +4,11 @@
* ------------------------------------------------------------------------------------------ */
import { LogLevel } from '@codingame/monaco-vscode-api';
-import { InMemoryFileSystemProvider, registerFileSystemOverlay, type IFileWriteOptions } from '@codingame/monaco-vscode-files-service-override';
+import {
+ InMemoryFileSystemProvider,
+ registerFileSystemOverlay,
+ type IFileWriteOptions
+} from '@codingame/monaco-vscode-files-service-override';
import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
import type { EditorAppConfig } from 'monaco-languageclient/editorApp';
import type { LanguageClientConfig } from 'monaco-languageclient/lcwrapper';
@@ -19,135 +23,139 @@ import langiumLanguageConfig from './langium.configuration.json?raw';
import langiumTextmateGrammar from './langium.tmLanguage.json?raw';
export const setupLangiumClientExtended = async (): Promise => {
- const overallConfigType: OverallConfigType = 'extended';
- const extensionFilesOrContents = new Map();
- // vite build is easier with string content
- extensionFilesOrContents.set('/workspace/langium-configuration.json', langiumLanguageConfig);
- extensionFilesOrContents.set('/workspace/langium-grammar.json', langiumTextmateGrammar);
+ const overallConfigType: OverallConfigType = 'extended';
+ const extensionFilesOrContents = new Map();
+ // vite build is easier with string content
+ extensionFilesOrContents.set('/workspace/langium-configuration.json', langiumLanguageConfig);
+ extensionFilesOrContents.set('/workspace/langium-grammar.json', langiumTextmateGrammar);
- const loadLangiumWorker = () => {
- return new Worker(new URL('../worker/langium-server.ts', import.meta.url), {
- type: 'module',
- name: 'Langium LS',
- });
- };
-
- const worker = loadLangiumWorker();
- const reader = new BrowserMessageReader(worker);
- const writer = new BrowserMessageWriter(worker);
- reader.listen((message) => {
- console.log('Received message from worker:', message);
+ const loadLangiumWorker = () => {
+ return new Worker(new URL('../worker/langium-server.ts', import.meta.url), {
+ type: 'module',
+ name: 'Langium LS'
});
+ };
+
+ const worker = loadLangiumWorker();
+ const reader = new BrowserMessageReader(worker);
+ const writer = new BrowserMessageWriter(worker);
+ reader.listen((message) => {
+ console.log('Received message from worker:', message);
+ });
- // prepare all resources that should be preloaded
- const workspaceUri = vscode.Uri.file('/workspace');
- const langiumGrammarLangiumUri = vscode.Uri.file('/workspace/langium-grammar.langium');
- const langiumTypesLangiumUri = vscode.Uri.file('/workspace/langium-types.langium');
- const fileSystemProvider = new InMemoryFileSystemProvider();
- const textEncoder = new TextEncoder();
+ // prepare all resources that should be preloaded
+ const workspaceUri = vscode.Uri.file('/workspace');
+ const langiumGrammarLangiumUri = vscode.Uri.file('/workspace/langium-grammar.langium');
+ const langiumTypesLangiumUri = vscode.Uri.file('/workspace/langium-types.langium');
+ const fileSystemProvider = new InMemoryFileSystemProvider();
+ const textEncoder = new TextEncoder();
- const options: IFileWriteOptions = {
- atomic: false,
- unlock: false,
- create: true,
- overwrite: true
- };
- await fileSystemProvider.mkdir(workspaceUri);
- await fileSystemProvider.writeFile(langiumGrammarLangiumUri, textEncoder.encode(langiumGrammarLangium), options);
- await fileSystemProvider.writeFile(langiumTypesLangiumUri, textEncoder.encode(langiumTypesLangium), options);
- registerFileSystemOverlay(1, fileSystemProvider);
+ const options: IFileWriteOptions = {
+ atomic: false,
+ unlock: false,
+ create: true,
+ overwrite: true
+ };
+ await fileSystemProvider.mkdir(workspaceUri);
+ await fileSystemProvider.writeFile(langiumGrammarLangiumUri, textEncoder.encode(langiumGrammarLangium), options);
+ await fileSystemProvider.writeFile(langiumTypesLangiumUri, textEncoder.encode(langiumTypesLangium), options);
+ registerFileSystemOverlay(1, fileSystemProvider);
- const editorAppConfig: EditorAppConfig = {};
+ const editorAppConfig: EditorAppConfig = {};
- const innerHtml = `
+ const innerHtml = `
`;
- const viewsInit = async () => {
- const { Parts, onPartVisibilityChange, isPartVisibile, attachPart, } = await import('@codingame/monaco-vscode-views-service-override');
+ const viewsInit = async () => {
+ const { Parts, onPartVisibilityChange, isPartVisibile, attachPart } = await import('@codingame/monaco-vscode-views-service-override');
- for (const config of [
- { part: Parts.EDITOR_PART, element: '#editors' },
- ]) {
- attachPart(config.part, document.querySelector
(config.element)!);
+ for (const config of [{ part: Parts.EDITOR_PART, element: '#editors' }]) {
+ attachPart(config.part, document.querySelector(config.element)!);
- if (!isPartVisibile(config.part)) {
- document.querySelector(config.element)!.style.display = 'none';
- }
+ if (!isPartVisibile(config.part)) {
+ document.querySelector(config.element)!.style.display = 'none';
+ }
- onPartVisibilityChange(config.part, visible => {
- document.querySelector(config.element)!.style.display = visible ? 'block' : 'none';
- });
- }
- };
- const vscodeApiConfig: MonacoVscodeApiConfig = {
- $type: overallConfigType,
- logLevel: LogLevel.Debug,
- serviceOverrides: {
- ...getKeybindingsServiceOverride()
- },
- viewsConfig: {
- $type: 'ViewsService',
- htmlContainer: document.body,
- htmlAugmentationInstructions: (htmlElement: HTMLElement | null | undefined) => {
- const htmlContainer = document.createElement('div', { is: 'app' });
- htmlContainer.innerHTML = innerHtml;
- htmlElement?.append(htmlContainer);
- },
- viewsInitFunc: viewsInit
+ onPartVisibilityChange(config.part, (visible) => {
+ document.querySelector(config.element)!.style.display = visible ? 'block' : 'none';
+ });
+ }
+ };
+ const vscodeApiConfig: MonacoVscodeApiConfig = {
+ $type: overallConfigType,
+ logLevel: LogLevel.Debug,
+ serviceOverrides: {
+ ...getKeybindingsServiceOverride()
+ },
+ viewsConfig: {
+ $type: 'ViewsService',
+ htmlContainer: document.body,
+ htmlAugmentationInstructions: (htmlElement: HTMLElement | null | undefined) => {
+ const htmlContainer = document.createElement('div', { is: 'app' });
+ htmlContainer.innerHTML = innerHtml;
+ htmlElement?.append(htmlContainer);
+ },
+ viewsInitFunc: viewsInit
+ },
+ userConfiguration: {
+ json: JSON.stringify({
+ 'workbench.colorTheme': 'Default Dark Modern',
+ 'editor.guides.bracketPairsHorizontal': 'active',
+ 'editor.wordBasedSuggestions': 'off',
+ 'editor.experimental.asyncTokenization': true,
+ 'vitest.disableWorkspaceWarning': true
+ })
+ },
+ monacoWorkerFactory: configureDefaultWorkerFactory,
+ extensions: [
+ {
+ config: {
+ name: 'langium-example',
+ publisher: 'TypeFox',
+ version: '1.0.0',
+ engines: {
+ vscode: '*'
+ },
+ contributes: {
+ languages: [
+ {
+ id: 'langium',
+ extensions: ['.langium'],
+ aliases: ['langium', 'LANGIUM'],
+ configuration: '/workspace/langium-configuration.json'
+ }
+ ],
+ grammars: [
+ {
+ language: 'langium',
+ scopeName: 'source.langium',
+ path: '/workspace/langium-grammar.json'
+ }
+ ]
+ }
},
- userConfiguration: {
- json: JSON.stringify({
- 'workbench.colorTheme': 'Default Dark Modern',
- 'editor.guides.bracketPairsHorizontal': 'active',
- 'editor.wordBasedSuggestions': 'off',
- 'editor.experimental.asyncTokenization': true,
- 'vitest.disableWorkspaceWarning': true
- })
- },
- monacoWorkerFactory: configureDefaultWorkerFactory,
- extensions: [{
- config: {
- name: 'langium-example',
- publisher: 'TypeFox',
- version: '1.0.0',
- engines: {
- vscode: '*'
- },
- contributes: {
- languages: [{
- id: 'langium',
- extensions: ['.langium'],
- aliases: ['langium', 'LANGIUM'],
- configuration: '/workspace/langium-configuration.json'
- }],
- grammars: [{
- language: 'langium',
- scopeName: 'source.langium',
- path: '/workspace/langium-grammar.json'
- }]
- }
- },
- filesOrContents: extensionFilesOrContents
- }]
- };
+ filesOrContents: extensionFilesOrContents
+ }
+ ]
+ };
- const languageClientConfig: LanguageClientConfig = {
- languageId: 'langium',
- clientOptions: {
- documentSelector: ['langium']
- },
- connection: {
- options: {
- $type: 'WorkerDirect',
- worker
- },
- messageTransports: { reader, writer }
- }
- };
+ const languageClientConfig: LanguageClientConfig = {
+ languageId: 'langium',
+ clientOptions: {
+ documentSelector: ['langium']
+ },
+ connection: {
+ options: {
+ $type: 'WorkerDirect',
+ worker
+ },
+ messageTransports: { reader, writer }
+ }
+ };
- return {
- editorAppConfig,
- vscodeApiConfig,
- languageClientConfig
- };
+ return {
+ editorAppConfig,
+ vscodeApiConfig,
+ languageClientConfig
+ };
};
diff --git a/packages/examples/src/langium/langium-dsl/main.ts b/packages/examples/src/langium/langium-dsl/main.ts
index 94f6c8841..5b9646d3d 100644
--- a/packages/examples/src/langium/langium-dsl/main.ts
+++ b/packages/examples/src/langium/langium-dsl/main.ts
@@ -10,22 +10,21 @@ import type { ExampleAppConfig } from '../../common/client/utils.js';
import { setupLangiumClientExtended } from './config/langiumDslConfig.js';
export const runLangiumGrammarDsl = async () => {
- try {
- const appConfig: ExampleAppConfig = await setupLangiumClientExtended();
+ try {
+ const appConfig: ExampleAppConfig = await setupLangiumClientExtended();
- // perform global init
- const apiWrapper = new MonacoVscodeApiWrapper(appConfig.vscodeApiConfig);
- await apiWrapper.start();
+ // perform global init
+ const apiWrapper = new MonacoVscodeApiWrapper(appConfig.vscodeApiConfig);
+ await apiWrapper.start();
- // init language client
- const lcWrapper = new LanguageClientWrapper(appConfig.languageClientConfig);
- await lcWrapper.start();
+ // init language client
+ const lcWrapper = new LanguageClientWrapper(appConfig.languageClientConfig);
+ await lcWrapper.start();
- await vscode.workspace.openTextDocument('/workspace/langium-types.langium');
- await vscode.workspace.openTextDocument('/workspace/langium-grammar.langium');
- await vscode.window.showTextDocument(vscode.Uri.file('/workspace/langium-grammar.langium'));
- } catch (e) {
- console.error(e);
- }
+ await vscode.workspace.openTextDocument('/workspace/langium-types.langium');
+ await vscode.workspace.openTextDocument('/workspace/langium-grammar.langium');
+ await vscode.window.showTextDocument(vscode.Uri.file('/workspace/langium-grammar.langium'));
+ } catch (e) {
+ console.error(e);
+ }
};
-
diff --git a/packages/examples/src/langium/langium-dsl/worker/langium-server.ts b/packages/examples/src/langium/langium-dsl/worker/langium-server.ts
index 8144b3179..0b01c1915 100644
--- a/packages/examples/src/langium/langium-dsl/worker/langium-server.ts
+++ b/packages/examples/src/langium/langium-dsl/worker/langium-server.ts
@@ -14,13 +14,13 @@ const messageReader = new BrowserMessageReader(self as DedicatedWorkerGlobalScop
const messageWriter = new BrowserMessageWriter(self as DedicatedWorkerGlobalScope);
messageReader.listen((message) => {
- console.log('Received message from main thread:', message);
+ console.log('Received message from main thread:', message);
});
// Inject the shared services and language-specific services
const context = {
- connection: createConnection(messageReader, messageWriter),
- ...EmptyFileSystem
+ connection: createConnection(messageReader, messageWriter),
+ ...EmptyFileSystem
} as unknown as DefaultSharedModuleContext;
const { shared } = createLangiumGrammarServices(context);
diff --git a/packages/examples/src/langium/statemachine/config/langium-config.json b/packages/examples/src/langium/statemachine/config/langium-config.json
index f0b694217..4fca71e84 100644
--- a/packages/examples/src/langium/statemachine/config/langium-config.json
+++ b/packages/examples/src/langium/statemachine/config/langium-config.json
@@ -5,9 +5,7 @@
{
"id": "statemachine",
"grammar": "../ls/statemachine.langium",
- "fileExtensions": [
- ".statemachine"
- ],
+ "fileExtensions": [".statemachine"],
"textMate": {
"out": "../syntaxes/statemachine.tmLanguage.json"
}
diff --git a/packages/examples/src/langium/statemachine/config/language-configuration.json b/packages/examples/src/langium/statemachine/config/language-configuration.json
index 6b619d0cf..2b1e4e94f 100644
--- a/packages/examples/src/langium/statemachine/config/language-configuration.json
+++ b/packages/examples/src/langium/statemachine/config/language-configuration.json
@@ -1,30 +1,30 @@
{
- "comments": {
- // symbol used for single line comment. Remove this entry if your language does not support line comments
- "lineComment": "//",
- // symbols used for start and end a block comment. Remove this entry if your language does not support block comments
- "blockComment": [ "/*", "*/" ]
- },
- // symbols used as brackets
- "brackets": [
- ["{", "}"],
- ["[", "]"],
- ["(", ")"]
- ],
- // symbols that are auto closed when typing
- "autoClosingPairs": [
- ["{", "}"],
- ["[", "]"],
- ["(", ")"],
- ["\"", "\""],
- ["'", "'"]
- ],
- // symbols that can be used to surround a selection
- "surroundingPairs": [
- ["{", "}"],
- ["[", "]"],
- ["(", ")"],
- ["\"", "\""],
- ["'", "'"]
- ]
+ "comments": {
+ // symbol used for single line comment. Remove this entry if your language does not support line comments
+ "lineComment": "//",
+ // symbols used for start and end a block comment. Remove this entry if your language does not support block comments
+ "blockComment": ["/*", "*/"]
+ },
+ // symbols used as brackets
+ "brackets": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"]
+ ],
+ // symbols that are auto closed when typing
+ "autoClosingPairs": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"],
+ ["\"", "\""],
+ ["'", "'"]
+ ],
+ // symbols that can be used to surround a selection
+ "surroundingPairs": [
+ ["{", "}"],
+ ["[", "]"],
+ ["(", ")"],
+ ["\"", "\""],
+ ["'", "'"]
+ ]
}
diff --git a/packages/examples/src/langium/statemachine/config/statemachineConfig.ts b/packages/examples/src/langium/statemachine/config/statemachineConfig.ts
index 740f8b533..b375a72d9 100644
--- a/packages/examples/src/langium/statemachine/config/statemachineConfig.ts
+++ b/packages/examples/src/langium/statemachine/config/statemachineConfig.ts
@@ -20,90 +20,96 @@ import responseStatemachineTm from '../syntaxes/statemachine.tmLanguage.json?raw
import type { ExampleAppConfig } from '../../../common/client/utils.js';
export const createLangiumGlobalConfig = (params: {
- languageServerId: string,
- codeContent: CodeContent,
- worker: Worker,
- messagePort?: MessagePort,
- messageTransports?: MessageTransports,
- htmlContainer?: HTMLElement
+ languageServerId: string;
+ codeContent: CodeContent;
+ worker: Worker;
+ messagePort?: MessagePort;
+ messageTransports?: MessageTransports;
+ htmlContainer?: HTMLElement;
}): ExampleAppConfig => {
- const extensionFilesOrContents = new Map();
- extensionFilesOrContents.set(`/${params.languageServerId}-statemachine-configuration.json`, statemachineLanguageConfig);
- extensionFilesOrContents.set(`/${params.languageServerId}-statemachine-grammar.json`, responseStatemachineTm);
+ const extensionFilesOrContents = new Map();
+ extensionFilesOrContents.set(`/${params.languageServerId}-statemachine-configuration.json`, statemachineLanguageConfig);
+ extensionFilesOrContents.set(`/${params.languageServerId}-statemachine-grammar.json`, responseStatemachineTm);
- const languageClientConfig: LanguageClientConfig = {
- languageId: 'statemachine',
- clientOptions: {
- documentSelector: ['statemachine']
- },
- connection: {
- options: {
- $type: 'WorkerDirect',
- worker: params.worker,
- messagePort: params.messagePort,
- },
- messageTransports: params.messageTransports
- },
- logLevel: LogLevel.Off
- };
+ const languageClientConfig: LanguageClientConfig = {
+ languageId: 'statemachine',
+ clientOptions: {
+ documentSelector: ['statemachine']
+ },
+ connection: {
+ options: {
+ $type: 'WorkerDirect',
+ worker: params.worker,
+ messagePort: params.messagePort
+ },
+ messageTransports: params.messageTransports
+ },
+ logLevel: LogLevel.Off
+ };
- const vscodeApiConfig: MonacoVscodeApiConfig = {
- $type: 'extended',
- viewsConfig: {
- $type: 'EditorService',
- htmlContainer: params.htmlContainer
- },
- logLevel: LogLevel.Off,
- serviceOverrides: {
- ...getKeybindingsServiceOverride(),
- ...getLifecycleServiceOverride(),
- ...getLocalizationServiceOverride(createDefaultLocaleConfiguration()),
+ const vscodeApiConfig: MonacoVscodeApiConfig = {
+ $type: 'extended',
+ viewsConfig: {
+ $type: 'EditorService',
+ htmlContainer: params.htmlContainer
+ },
+ logLevel: LogLevel.Off,
+ serviceOverrides: {
+ ...getKeybindingsServiceOverride(),
+ ...getLifecycleServiceOverride(),
+ ...getLocalizationServiceOverride(createDefaultLocaleConfiguration())
+ },
+ monacoWorkerFactory: configureDefaultWorkerFactory,
+ userConfiguration: {
+ json: JSON.stringify({
+ 'workbench.colorTheme': 'Default Dark Modern',
+ 'editor.guides.bracketPairsHorizontal': 'active',
+ 'editor.wordBasedSuggestions': 'off',
+ 'editor.experimental.asyncTokenization': true
+ })
+ },
+ extensions: [
+ {
+ config: {
+ name: 'statemachine-example',
+ publisher: 'TypeFox',
+ version: '1.0.0',
+ engines: {
+ vscode: '*'
+ },
+ contributes: {
+ languages: [
+ {
+ id: 'statemachine',
+ extensions: ['.statemachine'],
+ aliases: ['statemachine', 'Statemachine'],
+ configuration: `./${params.languageServerId}-statemachine-configuration.json`
+ }
+ ],
+ grammars: [
+ {
+ language: 'statemachine',
+ scopeName: 'source.statemachine',
+ path: `./${params.languageServerId}-statemachine-grammar.json`
+ }
+ ]
+ }
},
- monacoWorkerFactory: configureDefaultWorkerFactory,
- userConfiguration: {
- json: JSON.stringify({
- 'workbench.colorTheme': 'Default Dark Modern',
- 'editor.guides.bracketPairsHorizontal': 'active',
- 'editor.wordBasedSuggestions': 'off',
- 'editor.experimental.asyncTokenization': true
- })
- },
- extensions: [{
- config: {
- name: 'statemachine-example',
- publisher: 'TypeFox',
- version: '1.0.0',
- engines: {
- vscode: '*'
- },
- contributes: {
- languages: [{
- id: 'statemachine',
- extensions: ['.statemachine'],
- aliases: ['statemachine', 'Statemachine'],
- configuration: `./${params.languageServerId}-statemachine-configuration.json`
- }],
- grammars: [{
- language: 'statemachine',
- scopeName: 'source.statemachine',
- path: `./${params.languageServerId}-statemachine-grammar.json`
- }]
- }
- },
- filesOrContents: extensionFilesOrContents
- }]
- };
+ filesOrContents: extensionFilesOrContents
+ }
+ ]
+ };
- const editorAppConfig: EditorAppConfig = {
- codeResources: {
- modified: params.codeContent
- },
- logLevel: LogLevel.Debug
- };
+ const editorAppConfig: EditorAppConfig = {
+ codeResources: {
+ modified: params.codeContent
+ },
+ logLevel: LogLevel.Debug
+ };
- return {
- editorAppConfig,
- vscodeApiConfig,
- languageClientConfig
- };
+ return {
+ editorAppConfig,
+ vscodeApiConfig,
+ languageClientConfig
+ };
};
diff --git a/packages/examples/src/langium/statemachine/ls/generated/ast.ts b/packages/examples/src/langium/statemachine/ls/generated/ast.ts
index 692430b60..4811f23e2 100644
--- a/packages/examples/src/langium/statemachine/ls/generated/ast.ts
+++ b/packages/examples/src/langium/statemachine/ls/generated/ast.ts
@@ -7,213 +7,213 @@
import * as langium from 'langium';
export const StatemachineTerminals = {
- WS: /\s+/,
- ID: /[_a-zA-Z][\w_]*/,
- ML_COMMENT: /\/\*[\s\S]*?\*\//,
- SL_COMMENT: /\/\/[^\n\r]*/,
+ WS: /\s+/,
+ ID: /[_a-zA-Z][\w_]*/,
+ ML_COMMENT: /\/\*[\s\S]*?\*\//,
+ SL_COMMENT: /\/\/[^\n\r]*/
};
export type StatemachineTerminalNames = keyof typeof StatemachineTerminals;
export type StatemachineKeywordNames =
- | "=>"
- | "actions"
- | "commands"
- | "end"
- | "events"
- | "initialState"
- | "state"
- | "statemachine"
- | "{"
- | "}";
+ | '=>'
+ | 'actions'
+ | 'commands'
+ | 'end'
+ | 'events'
+ | 'initialState'
+ | 'state'
+ | 'statemachine'
+ | '{'
+ | '}';
export type StatemachineTokenNames = StatemachineTerminalNames | StatemachineKeywordNames;
export interface Command extends langium.AstNode {
- readonly $container: Statemachine;
- readonly $type: 'Command';
- name: string;
+ readonly $container: Statemachine;
+ readonly $type: 'Command';
+ name: string;
}
export const Command = {
- $type: 'Command',
- name: 'name'
+ $type: 'Command',
+ name: 'name'
} as const;
export function isCommand(item: unknown): item is Command {
- return reflection.isInstance(item, Command.$type);
+ return reflection.isInstance(item, Command.$type);
}
/** An event is the trigger for a transition */
export interface Event extends langium.AstNode {
- readonly $container: Statemachine;
- readonly $type: 'Event';
- name: string;
+ readonly $container: Statemachine;
+ readonly $type: 'Event';
+ name: string;
}
export const Event = {
- $type: 'Event',
- name: 'name'
+ $type: 'Event',
+ name: 'name'
} as const;
export function isEvent(item: unknown): item is Event {
- return reflection.isInstance(item, Event.$type);
+ return reflection.isInstance(item, Event.$type);
}
/** A description of the status of a system */
export interface State extends langium.AstNode {
- readonly $container: Statemachine;
- readonly $type: 'State';
- actions: Array>;
- name: string;
- /** The transitions to other states that can take place from the current one */
- transitions: Array;
+ readonly $container: Statemachine;
+ readonly $type: 'State';
+ actions: Array>;
+ name: string;
+ /** The transitions to other states that can take place from the current one */
+ transitions: Array;
}
export const State = {
- $type: 'State',
- actions: 'actions',
- name: 'name',
- transitions: 'transitions'
+ $type: 'State',
+ actions: 'actions',
+ name: 'name',
+ transitions: 'transitions'
} as const;
export function isState(item: unknown): item is State {
- return reflection.isInstance(item, State.$type);
+ return reflection.isInstance(item, State.$type);
}
/** A textual representation of a state machine */
export interface Statemachine extends langium.AstNode {
- readonly $type: 'Statemachine';
- commands: Array;
- /** The list of recognized event names */
- events: Array;
- /** The starting state for the machine */
- init: langium.Reference;
- /** The name of the machine */
- name: string;
- /** Definitions of available states */
- states: Array;
+ readonly $type: 'Statemachine';
+ commands: Array;
+ /** The list of recognized event names */
+ events: Array;
+ /** The starting state for the machine */
+ init: langium.Reference;
+ /** The name of the machine */
+ name: string;
+ /** Definitions of available states */
+ states: Array;
}
export const Statemachine = {
- $type: 'Statemachine',
- commands: 'commands',
- events: 'events',
- init: 'init',
- name: 'name',
- states: 'states'
+ $type: 'Statemachine',
+ commands: 'commands',
+ events: 'events',
+ init: 'init',
+ name: 'name',
+ states: 'states'
} as const;
export function isStatemachine(item: unknown): item is Statemachine {
- return reflection.isInstance(item, Statemachine.$type);
+ return reflection.isInstance(item, Statemachine.$type);
}
/** A change from one state to another */
export interface Transition extends langium.AstNode {
- readonly $container: State;
- readonly $type: 'Transition';
- /** The event triggering the transition */
- event: langium.Reference;
- /** The target state */
- state: langium.Reference;
+ readonly $container: State;
+ readonly $type: 'Transition';
+ /** The event triggering the transition */
+ event: langium.Reference;
+ /** The target state */
+ state: langium.Reference;
}
export const Transition = {
- $type: 'Transition',
- event: 'event',
- state: 'state'
+ $type: 'Transition',
+ event: 'event',
+ state: 'state'
} as const;
export function isTransition(item: unknown): item is Transition {
- return reflection.isInstance(item, Transition.$type);
+ return reflection.isInstance(item, Transition.$type);
}
export type StatemachineAstType = {
- Command: Command
- Event: Event
- State: State
- Statemachine: Statemachine
- Transition: Transition
-}
+ Command: Command;
+ Event: Event;
+ State: State;
+ Statemachine: Statemachine;
+ Transition: Transition;
+};
export class StatemachineAstReflection extends langium.AbstractAstReflection {
- override readonly types = {
- Command: {
- name: Command.$type,
- properties: {
- name: {
- name: Command.name
- }
- },
- superTypes: []
+ override readonly types = {
+ Command: {
+ name: Command.$type,
+ properties: {
+ name: {
+ name: Command.name
+ }
+ },
+ superTypes: []
+ },
+ Event: {
+ name: Event.$type,
+ properties: {
+ name: {
+ name: Event.name
+ }
+ },
+ superTypes: []
+ },
+ State: {
+ name: State.$type,
+ properties: {
+ actions: {
+ name: State.actions,
+ defaultValue: [],
+ referenceType: Command.$type
},
- Event: {
- name: Event.$type,
- properties: {
- name: {
- name: Event.name
- }
- },
- superTypes: []
+ name: {
+ name: State.name
},
- State: {
- name: State.$type,
- properties: {
- actions: {
- name: State.actions,
- defaultValue: [],
- referenceType: Command.$type
- },
- name: {
- name: State.name
- },
- transitions: {
- name: State.transitions,
- defaultValue: []
- }
- },
- superTypes: []
+ transitions: {
+ name: State.transitions,
+ defaultValue: []
+ }
+ },
+ superTypes: []
+ },
+ Statemachine: {
+ name: Statemachine.$type,
+ properties: {
+ commands: {
+ name: Statemachine.commands,
+ defaultValue: []
},
- Statemachine: {
- name: Statemachine.$type,
- properties: {
- commands: {
- name: Statemachine.commands,
- defaultValue: []
- },
- events: {
- name: Statemachine.events,
- defaultValue: []
- },
- init: {
- name: Statemachine.init,
- referenceType: State.$type
- },
- name: {
- name: Statemachine.name
- },
- states: {
- name: Statemachine.states,
- defaultValue: []
- }
- },
- superTypes: []
+ events: {
+ name: Statemachine.events,
+ defaultValue: []
+ },
+ init: {
+ name: Statemachine.init,
+ referenceType: State.$type
+ },
+ name: {
+ name: Statemachine.name
+ },
+ states: {
+ name: Statemachine.states,
+ defaultValue: []
+ }
+ },
+ superTypes: []
+ },
+ Transition: {
+ name: Transition.$type,
+ properties: {
+ event: {
+ name: Transition.event,
+ referenceType: Event.$type
},
- Transition: {
- name: Transition.$type,
- properties: {
- event: {
- name: Transition.event,
- referenceType: Event.$type
- },
- state: {
- name: Transition.state,
- referenceType: State.$type
- }
- },
- superTypes: []
+ state: {
+ name: Transition.state,
+ referenceType: State.$type
}
- } as const satisfies langium.AstMetaData
+ },
+ superTypes: []
+ }
+ } as const satisfies langium.AstMetaData;
}
export const reflection = new StatemachineAstReflection();
diff --git a/packages/examples/src/langium/statemachine/ls/generated/grammar.ts b/packages/examples/src/langium/statemachine/ls/generated/grammar.ts
index 95d81e4d8..111739aab 100644
--- a/packages/examples/src/langium/statemachine/ls/generated/grammar.ts
+++ b/packages/examples/src/langium/statemachine/ls/generated/grammar.ts
@@ -7,7 +7,9 @@ import type { Grammar } from 'langium';
import { loadGrammarFromJson } from 'langium';
let loadedStatemachineModelGrammar: Grammar | undefined;
-export const StatemachineModelGrammar = (): Grammar => loadedStatemachineModelGrammar ?? (loadedStatemachineModelGrammar = loadGrammarFromJson(`{
+export const StatemachineModelGrammar = (): Grammar =>
+ loadedStatemachineModelGrammar ??
+ (loadedStatemachineModelGrammar = loadGrammarFromJson(`{
"$type": "Grammar",
"isDeclared": true,
"name": "StatemachineModel",
diff --git a/packages/examples/src/langium/statemachine/ls/generated/module.ts b/packages/examples/src/langium/statemachine/ls/generated/module.ts
index 6b1233f04..ecea12659 100644
--- a/packages/examples/src/langium/statemachine/ls/generated/module.ts
+++ b/packages/examples/src/langium/statemachine/ls/generated/module.ts
@@ -3,23 +3,30 @@
* DO NOT EDIT MANUALLY!
******************************************************************************/
-import type { LangiumSharedCoreServices, LangiumCoreServices, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, LanguageMetaData, Module } from 'langium';
+import type {
+ LangiumSharedCoreServices,
+ LangiumCoreServices,
+ LangiumGeneratedCoreServices,
+ LangiumGeneratedSharedCoreServices,
+ LanguageMetaData,
+ Module
+} from 'langium';
import { StatemachineAstReflection } from './ast.js';
import { StatemachineModelGrammar } from './grammar.js';
export const StatemachineModelLanguageMetaData = {
- languageId: 'statemachine',
- fileExtensions: ['.statemachine'],
- caseInsensitive: false,
- mode: 'development'
+ languageId: 'statemachine',
+ fileExtensions: ['.statemachine'],
+ caseInsensitive: false,
+ mode: 'development'
} as const satisfies LanguageMetaData;
export const StatemachineGeneratedSharedModule: Module = {
- AstReflection: () => new StatemachineAstReflection()
+ AstReflection: () => new StatemachineAstReflection()
};
export const StatemachineModelGeneratedModule: Module