Merge pull request #16 from CodinGame/prepare-coderpad-project-lsp

Prepare coderpad project

Author: CGNonofr

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-languageclient-wrapper",
-  "version": "1.8.0",
+  "version": "2.0.2",
   "private": false,
   "description": "Enhanced Monaco editor with TextMate grammars and more",
   "scripts": {
@@ -21,7 +21,7 @@
   ],
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@codingame/monaco-editor-wrapper": "^1.6.0",
+    "@codingame/monaco-editor-wrapper": "^1.9.0",
     "once": "^1.4.0",
     "sweetalert": "^2.1.2"
   },
@@ -43,9 +43,9 @@
     "@rollup/plugin-typescript": "^8.3.1",
     "@types/once": "^1.4.0",
     "@types/rollup-plugin-node-builtins": "^2.1.2",
-    "@types/vscode": "^1.64.0",
-    "@typescript-eslint/eslint-plugin": "5.13.0",
-    "@typescript-eslint/parser": "5.13.0",
+    "@types/vscode": "^1.65.0",
+    "@typescript-eslint/eslint-plugin": "5.14.0",
+    "@typescript-eslint/parser": "5.14.0",
     "eslint": "8.10.0",
     "eslint-config-standard": "16.0.3",
     "eslint-config-standard-jsx": "10.0.0",
@@ -54,8 +54,8 @@
     "eslint-plugin-promise": "6.0.0",
     "eslint-plugin-unused-imports": "2.0.0",
     "proxy-polyfill": "^0.3.2",
-    "rollup": "2.68.0",
-    "rollup-plugin-dts": "^4.1.0",
+    "rollup": "2.70.0",
+    "rollup-plugin-dts": "^4.2.0",
     "rollup-plugin-node-builtins": "^2.1.2",
     "rollup-plugin-postcss": "4.0.2",
     "rollup-plugin-visualizer": "5.6.0",

package.json

@@ -1,6 +1,7 @@
 import * as rollup from 'rollup'
 import dts from 'rollup-plugin-dts'
 import pkg from './package.json'
+import removeVscodeDeclareModule from './rollup/rollup-plugin-remove-vscode-declare-module'
 
 const externals = [
   ...Object.keys(pkg.dependencies),
@@ -15,7 +16,7 @@ export default rollup.defineConfig({
       return false
     }
     // Do not include types that rollup-plugin-dts fails to parse
-    if (/^vscode$|proxy-polyfill/.test(source)) {
+    if (/^proxy-polyfill/.test(source)) {
       return true
     }
     // Force include all types from vscode-* libs (vscode-languageclient, vscode-languageserver-protocol....)
@@ -25,6 +26,7 @@ export default rollup.defineConfig({
     return externals.some(external => source.startsWith(external))
   },
   plugins: [
+    removeVscodeDeclareModule(),
     dts({
       respectExternal: true
     })

rollup.types.config.ts

@@ -0,0 +1,29 @@
+import { PluginImpl } from 'rollup'
+
+const plugin: PluginImpl<{}> = () => {
+  return {
+    // Remove "declare module 'vscode'" from vscode type
+    // Or else dts plugin is unable to extract types from it
+    name: 'remove-vscode-declare-module',
+    transform (code, id) {
+      if (id.endsWith('@types/vscode/index.d.ts')) {
+        const lines = code.split('\n')
+        let index = lines.indexOf('declare module \'vscode\' {')
+        if (index < 0) throw new Error('Module declaration not found')
+
+        lines.splice(index, 1)
+        for (; lines[index] !== '}'; index++) {
+          // unindent
+          lines[index] = lines[index].slice(4)
+        }
+        lines.splice(index, 1)
+
+        return lines.join('\n')
+      }
+      return code
+    }
+
+  }
+}
+
+export default plugin

rollup/rollup-plugin-remove-vscode-declare-module.ts

@@ -1,4 +1,4 @@
-import { createWebSocketConnection, ConsoleLogger, toSocket, MessageSignature } from '@codingame/monaco-jsonrpc'
+import { MessageSignature, MessageConnection } from '@codingame/monaco-jsonrpc'
 import { Uri } from 'monaco-editor'
 import {
   MonacoLanguageClient,
@@ -7,97 +7,81 @@ import {
 import once from 'once'
 import { registerExtensionFeatures } from './extensions'
 import { LanguageClientId } from './languageClientOptions'
+import { Infrastructure } from './infrastructure'
 
-async function openConnection (url: URL | string, errorHandler: ConnectionErrorHandler, closeHandler: () => void): Promise<IConnection> {
-  return new Promise((resolve, reject) => {
-    const webSocket = new WebSocket(url)
+async function messageConnectionToConnection (messageConnection: MessageConnection, errorHandler: ConnectionErrorHandler, closeHandler: () => void): Promise<IConnection> {
+  const connection = createConnection(messageConnection, errorHandler, closeHandler)
 
-    webSocket.onopen = () => {
-      const socket = toSocket(webSocket)
-      const webSocketConnection = createWebSocketConnection(socket, new ConsoleLogger())
-      webSocketConnection.onDispose(() => {
-        webSocket.close()
-      })
-
-      const connection = createConnection(webSocketConnection, errorHandler, closeHandler)
-
-      const existingRegistrations = new Set<string>()
-      const fixedConnection: IConnection = {
-        ...connection,
-        initialize: (params: InitializeParams) => {
-          // Hack to fix url converted from /toto/tata to \\toto\tata in windows
-          const rootPath = params.rootPath?.replace(/\\/g, '/')
-          const fixedParams: InitializeParams = {
-            ...params,
-            rootPath: rootPath,
-            rootUri: rootPath != null ? Uri.from({ scheme: 'file', path: rootPath }).toString() : null
-          }
-          return connection.initialize(fixedParams)
-        },
-        onRequest (...args: Parameters<typeof connection.onRequest>) {
-          return connection.onRequest(args[0], (...params) => {
-            // Hack for https://github.com/OmniSharp/omnisharp-roslyn/issues/2119
-            const method = (args[0] as MessageSignature).method
-            if (method === RegistrationRequest.type.method) {
-              const registrationParams = params[0] as unknown as RegistrationParams
-              registrationParams.registrations = registrationParams.registrations.filter(registration => {
-                const alreadyExisting = existingRegistrations.has(registration.id)
-                if (alreadyExisting) {
-                  console.warn('Registration already existing', registration.id, registration.method)
-                }
-                return !alreadyExisting
-              })
-              registrationParams.registrations.forEach(registration => {
-                existingRegistrations.add(registration.id)
-              })
-            }
-            if (method === UnregistrationRequest.type.method) {
-              const unregistrationParams = params[0] as unknown as UnregistrationParams
-              for (const unregistration of unregistrationParams.unregisterations) {
-                existingRegistrations.delete(unregistration.id)
-              }
+  const existingRegistrations = new Set<string>()
+  const fixedConnection: IConnection = {
+    ...connection,
+    initialize: (params: InitializeParams) => {
+      // Hack to fix url converted from /toto/tata to \\toto\tata in windows
+      const rootPath = params.rootPath?.replace(/\\/g, '/')
+      const fixedParams: InitializeParams = {
+        ...params,
+        rootPath: rootPath,
+        rootUri: rootPath != null ? Uri.from({ scheme: 'file', path: rootPath }).toString() : null
+      }
+      return connection.initialize(fixedParams)
+    },
+    onRequest (...args: Parameters<typeof connection.onRequest>) {
+      return connection.onRequest(args[0], (...params) => {
+        // Hack for https://github.com/OmniSharp/omnisharp-roslyn/issues/2119
+        const method = (args[0] as MessageSignature).method
+        if (method === RegistrationRequest.type.method) {
+          const registrationParams = params[0] as unknown as RegistrationParams
+          registrationParams.registrations = registrationParams.registrations.filter(registration => {
+            const alreadyExisting = existingRegistrations.has(registration.id)
+            if (alreadyExisting) {
+              console.warn('Registration already existing', registration.id, registration.method)
             }
-            return args[1](...params)
+            return !alreadyExisting
           })
-        },
-        dispose: () => {
-          try {
-            connection.dispose()
-          } catch (error) {
-            // The dispose should NEVER fail or the lsp client is not properly cleaned
-            // see https://github.com/microsoft/vscode-languageserver-node/blob/master/client/src/client.ts#L3105
-            console.warn('[LSP]', 'Error while disposing connection', error)
-          }
-          // Hack, when the language client is removed, the connection is disposed but the closeHandler is not always properly called
-          // The language client is then still active but without a proper connection and errors will occurs
-          closeHandler()
-        },
-        shutdown: async () => {
-          // The shutdown should NEVER fail or the connection is not closed and the lsp client is not properly cleaned
-          // see https://github.com/microsoft/vscode-languageserver-node/blob/master/client/src/client.ts#L3103
-          try {
-            await connection.shutdown()
-          } catch (error) {
-            console.warn('[LSP]', 'Error while shutdown lsp', error)
+          registrationParams.registrations.forEach(registration => {
+            existingRegistrations.add(registration.id)
+          })
+        }
+        if (method === UnregistrationRequest.type.method) {
+          const unregistrationParams = params[0] as unknown as UnregistrationParams
+          for (const unregistration of unregistrationParams.unregisterations) {
+            existingRegistrations.delete(unregistration.id)
           }
         }
+        return args[1](...params)
+      })
+    },
+    dispose: () => {
+      try {
+        connection.dispose()
+      } catch (error) {
+        // The dispose should NEVER fail or the lsp client is not properly cleaned
+        // see https://github.com/microsoft/vscode-languageserver-node/blob/master/client/src/client.ts#L3105
+        console.warn('[LSP]', 'Error while disposing connection', error)
+      }
+      // Hack, when the language client is removed, the connection is disposed but the closeHandler is not always properly called
+      // The language client is then still active but without a proper connection and errors will occurs
+      closeHandler()
+    },
+    shutdown: async () => {
+      // The shutdown should NEVER fail or the connection is not closed and the lsp client is not properly cleaned
+      // see https://github.com/microsoft/vscode-languageserver-node/blob/master/client/src/client.ts#L3103
+      try {
+        await connection.shutdown()
+      } catch (error) {
+        console.warn('[LSP]', 'Error while shutdown lsp', error)
       }
-      resolve(fixedConnection)
-    }
-    webSocket.onerror = () => {
-      reject(new Error('Unable to connect to server'))
     }
-  })
+  }
+
+  return fixedConnection
 }
 
 const RETRY_DELAY = 3000
 class CGLSPConnectionProvider implements IConnectionProvider {
   constructor (
-    private serverAddress: string,
     private id: LanguageClientId,
-    private sessionId: string | undefined,
-    private libraryUrls: string[],
-    private getSecurityToken: () => Promise<string>
+    private infrastructure: Infrastructure
   ) {
   }
 
@@ -108,12 +92,9 @@ class CGLSPConnectionProvider implements IConnectionProvider {
       }, RETRY_DELAY)
     })
     try {
-      const path = this.sessionId != null ? `run/${this.sessionId}/${this.id}` : `run/${this.id}`
-      const url = new URL(path, this.serverAddress)
-      this.libraryUrls.forEach(libraryUrl => url.searchParams.append('libraryUrl', libraryUrl))
-      url.searchParams.append('token', await this.getSecurityToken())
+      const connection = await this.infrastructure.openConnection(this.id)
 
-      return await openConnection(url, errorHandler, onceDelayedCloseHandler)
+      return await messageConnectionToConnection(connection, errorHandler, onceDelayedCloseHandler)
     } catch (err) {
       onceDelayedCloseHandler()
       throw err
@@ -123,15 +104,12 @@ class CGLSPConnectionProvider implements IConnectionProvider {
 
 function createLanguageClient (
   id: LanguageClientId,
-  sessionId: string | undefined,
+  infrastructure: Infrastructure,
   {
     documentSelector,
     synchronize,
     initializationOptions
   }: LanguageClientOptions,
-  languageServerAddress: string,
-  getSecurityToken: () => Promise<string>,
-  libraryUrls: string[],
   errorHandler: ErrorHandler,
   middleware?: Middleware
 ): MonacoLanguageClient {
@@ -147,7 +125,7 @@ function createLanguageClient (
       synchronize,
       initializationOptions
     },
-    connectionProvider: new CGLSPConnectionProvider(languageServerAddress, id, sessionId, libraryUrls, getSecurityToken)
+    connectionProvider: new CGLSPConnectionProvider(id, infrastructure)
   })
 
   client.registerProposedFeatures()

src/createLanguageClient.ts

@@ -1,7 +1,34 @@
+import { ProtocolNotificationType, ProtocolRequestType } from 'vscode-languageserver-protocol'
 import { LanguageClient } from './languageClient'
 
+export interface WillShutdownParams {
+  delay: number
+}
+export const willShutdownNotificationType = new ProtocolNotificationType<WillShutdownParams, void>('willShutdown')
+
+export interface SaveTextDocumentParams {
+  textDocument: {
+    uri: string
+    text: string
+  }
+}
+
+export const saveTextDocumentRequestType = new ProtocolRequestType<SaveTextDocumentParams, void, never, void, void>('textDocument/save')
+
+export interface GetTextDocumentParams {
+  textDocument: {
+    uri: string
+  }
+}
+
+export interface GetTextDocumentResult {
+  text: string
+}
+
+export const getTextDocumentRequestType = new ProtocolRequestType<GetTextDocumentParams, GetTextDocumentResult, never, void, void>('textDocument/get')
+
 export function updateFile (uri: string, text: string, languageClient: LanguageClient): Promise<void> {
-  return languageClient.sendRequest('textDocument/save', {
+  return languageClient.sendRequest(saveTextDocumentRequestType, {
     textDocument: {
       uri,
       text
@@ -10,7 +37,7 @@ export function updateFile (uri: string, text: string, languageClient: LanguageC
 }
 
 export function getFile (uri: string, languageClient: LanguageClient): Promise<{ text: string }> {
-  return languageClient.sendRequest('textDocument/get', {
+  return languageClient.sendRequest(getTextDocumentRequestType, {
     textDocument: {
       uri
     }

src/customRequests.ts

@@ -1,18 +1,19 @@
 import {
   Disposable,
   ServerCapabilities, DocumentSelector, MonacoLanguageClient, StaticFeature, Services,
-  TextDocumentSyncOptions, TextDocument, DidSaveTextDocumentNotification, Emitter, ProtocolNotificationType
+  TextDocumentSyncOptions, TextDocument, DidSaveTextDocumentNotification, Emitter
 } from '@codingame/monaco-languageclient'
-import { updateFile } from './customRequests'
+import { updateFile, willShutdownNotificationType, WillShutdownParams } from './customRequests'
+import { LanguageClient } from './languageClient'
 
 interface ResolvedTextDocumentSyncCapabilities {
   resolvedTextDocumentSync?: TextDocumentSyncOptions
 }
 
 // Initialize the file content into the lsp server for implementations that don't support open/close notifications
-class InitializeTextDocumentFeature implements StaticFeature {
+export class InitializeTextDocumentFeature implements StaticFeature {
   private didOpenTextDocumentDisposable: Disposable | undefined
-  constructor (private languageClient: MonacoLanguageClient) {}
+  constructor (private languageClient: LanguageClient) {}
 
   fillClientCapabilities (): void {}
 
@@ -64,7 +65,7 @@ class CobolResolveSubroutineFeature implements StaticFeature {
   initialize (capabilities: ServerCapabilities, documentSelector: DocumentSelector): void {
     this.onRequestDisposable = this.languageClient.onRequest('cobol/resolveSubroutine', (routineName: string) => {
       const constantRoutinePaths: Partial<Record<string, string>> = {
-        'assert-equals': 'file:/tmp/project/deps/assert-equals.cbl'
+        'assert-equals': `${Services.get().workspace.rootUri ?? 'file:/tmp/project'}/deps/assert-equals.cbl`
       }
       const contantRoutinePath = constantRoutinePaths[routineName.toLowerCase()]
       if (contantRoutinePath != null) {
@@ -83,17 +84,11 @@ class CobolResolveSubroutineFeature implements StaticFeature {
 }
 
 export function registerExtensionFeatures (client: MonacoLanguageClient, language: string): void {
-  client.registerFeature(new InitializeTextDocumentFeature(client))
   if (language === 'cobol') {
     client.registerFeature(new CobolResolveSubroutineFeature(client))
   }
 }
 
-export interface WillShutdownParams {
-  delay: number
-}
-export const willShutdownNotificationType = new ProtocolNotificationType<WillShutdownParams, void>('willShutdown')
-
 export class WillDisposeFeature implements StaticFeature {
   constructor (private languageClient: MonacoLanguageClient, private onWillShutdownEmitter: Emitter<WillShutdownParams>) {}
   fillClientCapabilities (): void {}