How to use monaco-languageclient - 10 common examples

function createLanguageClient(connection: MessageConnection): MonacoLanguageClient {
  return new MonacoLanguageClient({
    name: 'LG Language Client',
    clientOptions: {
      // use a language id as a document selector
      documentSelector: ['botbuilderlg'],
      // disable the default error handler
      errorHandler: {
        error: () => ErrorAction.Continue,
        closed: () => CloseAction.DoNotRestart,
      },
    },
    // create a language client connection from the JSON RPC connection on demand
    connectionProvider: {
      get: (errorHandler, closeHandler) => {
        return Promise.resolve(createConnection(connection, errorHandler, closeHandler));
      },
    },

function createLanguageClient(connection: MessageConnection): MonacoLanguageClient {
    return new MonacoLanguageClient({
        name: "Sample Language Client",
        clientOptions: {
            // use a language id as a document selector
            documentSelector: ['json'],
            // disable the default error handler
            errorHandler: {
                error: () => ErrorAction.Continue,
                closed: () => CloseAction.DoNotRestart
            }
        },
        // create a language client connection from the JSON RPC connection on demand
        connectionProvider: {
            get: (errorHandler, closeHandler) => {
                return Promise.resolve(createConnection(connection, errorHandler, closeHandler))
            }
        }

function createLanguageClient(connection: MessageConnection): MonacoLanguageClient {
    return new MonacoLanguageClient({
        name: "TypeScript Language Client",
        clientOptions: {
            // use a language id as a document selector
            documentSelector: ['typescript'],
            // disable the default error handler
            errorHandler: {
                error: () => ErrorAction.Continue,
                closed: () => CloseAction.DoNotRestart
            }
        },
        // create a language client connection from the JSON RPC connection on demand
        connectionProvider: {
            get: (errorHandler, closeHandler) => {
                return Promise.resolve(createConnection(connection, errorHandler, closeHandler))
            }
        }

function createLanguageClient(connection: MessageConnection): MonacoLanguageClient {
  return new MonacoLanguageClient({
    name: 'LU Language Client',
    clientOptions: {
      // use a language id as a document selector
      documentSelector: ['bflu'],
      // disable the default error handler
      errorHandler: {
        error: () => ErrorAction.Continue,
        closed: () => CloseAction.DoNotRestart,
      },
      //middleware
    },
    // create a language client connection from the JSON RPC connection on demand
    connectionProvider: {
      get: (errorHandler, closeHandler) => {
        return Promise.resolve(createConnection(connection, errorHandler, closeHandler));
      },

})
    },
    listen(dataCallback: DataCallback) {
      callbacks.toClient = (message: Message) => dataCallback(message)
    },
    dispose() {
      if (!callbacks.onClientClose) {
        return
      }
      callbacks.onClientClose()
    }
  }

  const messageConnection = createMessageConnection(reader, writer, logger)

  return new MonacoLanguageClient({
    name: "Cadence Language Client",
    clientOptions: {
      documentSelector: ['cadence'],
      errorHandler: {
        error: () => ErrorAction.Continue,
        closed: () => CloseAction.DoNotRestart
      }
    },
    // Create a language client connection from the JSON-RPC connection on demand
    connectionProvider: {
      get: (errorHandler, closeHandler) => {
        return Promise.resolve(createConnection(messageConnection, errorHandler, closeHandler))
      }
    }
  });
}

export function createLanguageClient (connection, services) {
  return new BaseLanguageClient({
    name: 'Sample Language Client For Monaco',
    clientOptions: {
      // use a language id as a document selector
      documentSelector: ['java', 'class'],
      // disable the default error handler
      errorHandler: {
        error: () => ErrorAction.Continue,
        closed: () => CloseAction.DoNotRestart,
      },
    },
    services,
    // create a language client connection from the JSON RPC connection on demand
    connectionProvider: {
      get: (errorHandler, closeHandler) =>
        Promise.resolve(createConnection(connection, errorHandler, closeHandler)),
    },

.then((connection) => {
                // create and start the language client
                const languageClient = new BaseLanguageClient({
                    name: 'Ballerina Language Client',
                    clientOptions: {
                        // use a language id as a document selector
                        documentSelector: [BAL_LANGUAGE],
                        // disable the default error handler
                        errorHandler: {
                            error: () => ErrorAction.Continue,
                            closed: () => CloseAction.DoNotRestart,
                        },
                    },
                    services,
                    // create a language client connection from the JSON RPC connection on demand
                    connectionProvider: {
                        get: (errorHandler, closeHandler) => {
                            return Promise.resolve(createConnection(connection, errorHandler, closeHandler));
                        },

onConnection: (connection) => {
                        this.langServerConnection = connection;
                        // create and start the language client
                        const languageClient = new BaseLanguageClient({
                            name: 'Ballerina Language Client',
                            clientOptions: {
                                // use a language id as a document selector
                                documentSelector: ['ballerina-lang'],
                                // disable the default error handler
                                errorHandler: {
                                    error: () => ErrorAction.Continue,
                                    closed: () => CloseAction.DoNotRestart,
                                },
                            },
                            services: {
                                commands: {
                                    registerCommand: (...args) => {
                                        this.lsCommands.push({ ...args });
                                    },
                                },

function createLanguageClient(messageConnection) {
    return new monaco_languageclient_1.BaseLanguageClient({
        name: 'ELK Graph Language Client',
        clientOptions: {
            documentSelector: ['elkt'],
            // Disable the default error handler
            errorHandler: {
                error: function () { return monaco_languageclient_1.ErrorAction.Continue; },
                closed: function () { return monaco_languageclient_1.CloseAction.DoNotRestart; }
            }
        },
        services: services,
        // Create a language client connection from the JSON RPC connection on demand
        connectionProvider: {
            get: function (errorHandler, closeHandler) {
                var connection = monaco_languageclient_1.createConnection(messageConnection, errorHandler, closeHandler);
                diagramServer.listen(connection);
                return Promise.resolve(connection);

function createLanguageClient(messageConnection: MessageConnection): BaseLanguageClient {
    return new BaseLanguageClient({
        name: 'ELK Graph Language Client',
        clientOptions: {
            documentSelector: ['elkt'],
            // Disable the default error handler
            errorHandler: {
                error: () => ErrorAction.Continue,
                closed: () => CloseAction.DoNotRestart
            }
        },
        services,
        // Create a language client connection from the JSON RPC connection on demand
        connectionProvider: {
            get: (errorHandler, closeHandler) => {
                const connection = createConnection(messageConnection, errorHandler, closeHandler)
                diagramServer.listen(connection)
                return Promise.resolve(connection)