monaco-languageclient-examples 2025.6.3 → 2025.8.2

package/src/langium/statemachine/ls/generated/ast.ts

@@ -1,11 +1,10 @@
 /******************************************************************************
- * This file was generated by langium-cli 3.3.0.
+ * This file was generated by langium-cli 4.0.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
 /* eslint-disable */
-import type { AstNode, Reference, ReferenceInfo, TypeMetaData } from 'langium';
-import { AbstractAstReflection } from 'langium';
+import * as langium from 'langium';
 
 export const StatemachineTerminals = {
     WS: /\s+/,
@@ -30,70 +29,103 @@ export type StatemachineKeywordNames =
 
 export type StatemachineTokenNames = StatemachineTerminalNames | StatemachineKeywordNames;
 
-export interface Command extends AstNode {
+export interface Command extends langium.AstNode {
     readonly $container: Statemachine;
     readonly $type: 'Command';
     name: string;
 }
 
-export const Command = 'Command';
+export const Command = {
+    $type: 'Command',
+    name: 'name'
+} as const;
 
 export function isCommand(item: unknown): item is Command {
-    return reflection.isInstance(item, Command);
+    return reflection.isInstance(item, Command.$type);
 }
 
-export interface Event extends AstNode {
+/** An event is the trigger for a transition */
+export interface Event extends langium.AstNode {
     readonly $container: Statemachine;
     readonly $type: 'Event';
     name: string;
 }
 
-export const Event = 'Event';
+export const Event = {
+    $type: 'Event',
+    name: 'name'
+} as const;
 
 export function isEvent(item: unknown): item is Event {
-    return reflection.isInstance(item, Event);
+    return reflection.isInstance(item, Event.$type);
 }
 
-export interface State extends AstNode {
+/** A description of the status of a system */
+export interface State extends langium.AstNode {
     readonly $container: Statemachine;
     readonly $type: 'State';
-    actions: Array<Reference<Command>>;
+    actions: Array<langium.Reference<Command>>;
     name: string;
+    /** The transitions to other states that can take place from the current one */
     transitions: Array<Transition>;
 }
 
-export const State = 'State';
+export const State = {
+    $type: 'State',
+    actions: 'actions',
+    name: 'name',
+    transitions: 'transitions'
+} as const;
 
 export function isState(item: unknown): item is State {
-    return reflection.isInstance(item, State);
+    return reflection.isInstance(item, State.$type);
 }
 
-export interface Statemachine extends AstNode {
+/** A textual representation of a state machine */
+export interface Statemachine extends langium.AstNode {
     readonly $type: 'Statemachine';
     commands: Array<Command>;
+    /** The list of recognized event names */
     events: Array<Event>;
-    init: Reference<State>;
+    /** The starting state for the machine */
+    init: langium.Reference<State>;
+    /** The name of the machine */
     name: string;
+    /** Definitions of available states */
     states: Array<State>;
 }
 
-export const Statemachine = 'Statemachine';
+export const Statemachine = {
+    $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);
+    return reflection.isInstance(item, Statemachine.$type);
 }
 
-export interface Transition extends AstNode {
+/** A change from one state to another */
+export interface Transition extends langium.AstNode {
     readonly $container: State;
     readonly $type: 'Transition';
-    event: Reference<Event>;
-    state: Reference<State>;
+    /** The event triggering the transition */
+    event: langium.Reference<Event>;
+    /** The target state */
+    state: langium.Reference<State>;
 }
 
-export const Transition = 'Transition';
+export const Transition = {
+    $type: 'Transition',
+    event: 'event',
+    state: 'state'
+} as const;
 
 export function isTransition(item: unknown): item is Transition {
-    return reflection.isInstance(item, Transition);
+    return reflection.isInstance(item, Transition.$type);
 }
 
 export type StatemachineAstType = {
@@ -104,96 +136,84 @@ export type StatemachineAstType = {
     Transition: Transition
 }
 
-export class StatemachineAstReflection extends AbstractAstReflection {
-
-    getAllTypes(): string[] {
-        return [Command, Event, State, Statemachine, Transition];
-    }
-
-    protected override computeIsSubtype(subtype: string, _supertype: string): boolean {
-        switch (subtype) {
-            default: {
-                return false;
-            }
-        }
-    }
-
-    getReferenceType(refInfo: ReferenceInfo): string {
-        const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
-        switch (referenceId) {
-            case 'State:actions': {
-                return Command;
-            }
-            case 'Statemachine:init':
-            case 'Transition:state': {
-                return State;
-            }
-            case 'Transition:event': {
-                return Event;
-            }
-            default: {
-                throw new Error(`${referenceId} is not a valid reference id.`);
-            }
-        }
-    }
-
-    getTypeMetaData(type: string): TypeMetaData {
-        switch (type) {
-            case Command: {
-                return {
-                    name: Command,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case Event: {
-                return {
-                    name: Event,
-                    properties: [
-                        { name: 'name' }
-                    ]
-                };
-            }
-            case State: {
-                return {
-                    name: State,
-                    properties: [
-                        { name: 'actions', defaultValue: [] },
-                        { name: 'name' },
-                        { name: 'transitions', defaultValue: [] }
-                    ]
-                };
-            }
-            case Statemachine: {
-                return {
-                    name: Statemachine,
-                    properties: [
-                        { name: 'commands', defaultValue: [] },
-                        { name: 'events', defaultValue: [] },
-                        { name: 'init' },
-                        { name: 'name' },
-                        { name: 'states', defaultValue: [] }
-                    ]
-                };
-            }
-            case Transition: {
-                return {
-                    name: Transition,
-                    properties: [
-                        { name: 'event' },
-                        { name: 'state' }
-                    ]
-                };
-            }
-            default: {
-                return {
-                    name: type,
-                    properties: []
-                };
-            }
+export class StatemachineAstReflection extends langium.AbstractAstReflection {
+    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
+                },
+                name: {
+                    name: State.name
+                },
+                transitions: {
+                    name: State.transitions,
+                    defaultValue: []
+                }
+            },
+            superTypes: []
+        },
+        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: []
+        },
+        Transition: {
+            name: Transition.$type,
+            properties: {
+                event: {
+                    name: Transition.event,
+                    referenceType: Event.$type
+                },
+                state: {
+                    name: Transition.state,
+                    referenceType: State.$type
+                }
+            },
+            superTypes: []
         }
-    }
+    } as const satisfies langium.AstMetaData
 }
 
 export const reflection = new StatemachineAstReflection();

package/src/langium/statemachine/ls/generated/grammar.ts

@@ -1,21 +1,21 @@
 /******************************************************************************
- * This file was generated by langium-cli 3.3.0.
+ * This file was generated by langium-cli 4.0.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
 import type { Grammar } from 'langium';
 import { loadGrammarFromJson } from 'langium';
 
-let loadedStatemachineGrammar: Grammar | undefined;
-export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (loadedStatemachineGrammar = loadGrammarFromJson(`{
+let loadedStatemachineModelGrammar: Grammar | undefined;
+export const StatemachineModelGrammar = (): Grammar => loadedStatemachineModelGrammar ?? (loadedStatemachineModelGrammar = loadGrammarFromJson(`{
   "$type": "Grammar",
   "isDeclared": true,
-  "name": "Statemachine",
+  "name": "StatemachineModel",
   "rules": [
     {
       "$type": "ParserRule",
-      "name": "Statemachine",
       "entry": true,
+      "name": "Statemachine",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -33,7 +33,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
                 "$ref": "#/rules@6"
               },
               "arguments": []
-            }
+            },
+            "$comment": "/** The name of the machine */"
           },
           {
             "$type": "Group",
@@ -53,7 +54,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
                   },
                   "arguments": []
                 },
-                "cardinality": "+"
+                "cardinality": "+",
+                "$comment": "/** The list of recognized event names */"
               }
             ],
             "cardinality": "?"
@@ -94,8 +96,10 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
               "type": {
                 "$ref": "#/rules@3"
               },
-              "deprecatedSyntax": false
-            }
+              "deprecatedSyntax": false,
+              "isMulti": false
+            },
+            "$comment": "/** The starting state for the machine */"
           },
           {
             "$type": "Assignment",
@@ -108,15 +112,14 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
               },
               "arguments": []
             },
-            "cardinality": "*"
+            "cardinality": "*",
+            "$comment": "/** Definitions of available states */"
           }
         ]
       },
-      "definesHiddenTokens": false,
       "fragment": false,
-      "hiddenTokens": [],
       "parameters": [],
-      "wildcard": false
+      "$comment": "/** A textual representation of a state machine */"
     },
     {
       "$type": "ParserRule",
@@ -133,12 +136,10 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
           "arguments": []
         }
       },
-      "definesHiddenTokens": false,
       "entry": false,
       "fragment": false,
-      "hiddenTokens": [],
       "parameters": [],
-      "wildcard": false
+      "$comment": "/** An event is the trigger for a transition */"
     },
     {
       "$type": "ParserRule",
@@ -155,12 +156,9 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
           "arguments": []
         }
       },
-      "definesHiddenTokens": false,
       "entry": false,
       "fragment": false,
-      "hiddenTokens": [],
-      "parameters": [],
-      "wildcard": false
+      "parameters": []
     },
     {
       "$type": "ParserRule",
@@ -204,7 +202,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
                   "type": {
                     "$ref": "#/rules@2"
                   },
-                  "deprecatedSyntax": false
+                  "deprecatedSyntax": false,
+                  "isMulti": false
                 },
                 "cardinality": "+"
               },
@@ -226,7 +225,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
               },
               "arguments": []
             },
-            "cardinality": "*"
+            "cardinality": "*",
+            "$comment": "/** The transitions to other states that can take place from the current one */"
           },
           {
             "$type": "Keyword",
@@ -234,12 +234,10 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
           }
         ]
       },
-      "definesHiddenTokens": false,
       "entry": false,
       "fragment": false,
-      "hiddenTokens": [],
       "parameters": [],
-      "wildcard": false
+      "$comment": "/** A description of the status of a system */"
     },
     {
       "$type": "ParserRule",
@@ -256,8 +254,10 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
               "type": {
                 "$ref": "#/rules@1"
               },
-              "deprecatedSyntax": false
-            }
+              "deprecatedSyntax": false,
+              "isMulti": false
+            },
+            "$comment": "/** The event triggering the transition */"
           },
           {
             "$type": "Keyword",
@@ -272,17 +272,18 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
               "type": {
                 "$ref": "#/rules@3"
               },
-              "deprecatedSyntax": false
-            }
+              "deprecatedSyntax": false,
+              "isMulti": false
+            },
+            "$comment": "/** The target state */"
           }
-        ]
+        ],
+        "$comment": "/** The event triggering the transition */"
       },
-      "definesHiddenTokens": false,
       "entry": false,
       "fragment": false,
-      "hiddenTokens": [],
       "parameters": [],
-      "wildcard": false
+      "$comment": "/** A change from one state to another */"
     },
     {
       "$type": "TerminalRule",
@@ -290,7 +291,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
       "name": "WS",
       "definition": {
         "$type": "RegexToken",
-        "regex": "/\\\\s+/"
+        "regex": "/\\\\s+/",
+        "parenthesized": false
       },
       "fragment": false
     },
@@ -299,7 +301,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
       "name": "ID",
       "definition": {
         "$type": "RegexToken",
-        "regex": "/[_a-zA-Z][\\\\w_]*/"
+        "regex": "/[_a-zA-Z][\\\\w_]*/",
+        "parenthesized": false
       },
       "fragment": false,
       "hidden": false
@@ -310,7 +313,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
       "name": "ML_COMMENT",
       "definition": {
         "$type": "RegexToken",
-        "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//"
+        "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//",
+        "parenthesized": false
       },
       "fragment": false
     },
@@ -320,15 +324,13 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (
       "name": "SL_COMMENT",
       "definition": {
         "$type": "RegexToken",
-        "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/"
+        "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/",
+        "parenthesized": false
       },
       "fragment": false
     }
   ],
-  "definesHiddenTokens": false,
-  "hiddenTokens": [],
   "imports": [],
   "interfaces": [],
-  "types": [],
-  "usedGrammars": []
+  "types": []
 }`));

package/src/langium/statemachine/ls/generated/module.ts

@@ -1,13 +1,13 @@
 /******************************************************************************
- * This file was generated by langium-cli 3.3.0.
+ * This file was generated by langium-cli 4.0.0.
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
 import type { LangiumSharedCoreServices, LangiumCoreServices, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, LanguageMetaData, Module } from 'langium';
 import { StatemachineAstReflection } from './ast.js';
-import { StatemachineGrammar } from './grammar.js';
+import { StatemachineModelGrammar } from './grammar.js';
 
-export const StatemachineLanguageMetaData = {
+export const StatemachineModelLanguageMetaData = {
     languageId: 'statemachine',
     fileExtensions: ['.statemachine'],
     caseInsensitive: false,
@@ -18,8 +18,8 @@ export const StatemachineGeneratedSharedModule: Module<LangiumSharedCoreServices
     AstReflection: () => new StatemachineAstReflection()
 };
 
-export const StatemachineGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices> = {
-    Grammar: () => StatemachineGrammar(),
-    LanguageMetaData: () => StatemachineLanguageMetaData,
+export const StatemachineModelGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices> = {
+    Grammar: () => StatemachineModelGrammar(),
+    LanguageMetaData: () => StatemachineModelLanguageMetaData,
     parser: {}
 };

package/src/langium/statemachine/ls/statemachine-module.ts

@@ -6,7 +6,7 @@
 import { type Module, inject } from 'langium';
 import type { LangiumServices, LangiumSharedServices, PartialLangiumServices } from 'langium/lsp';
 import { createDefaultModule, createDefaultSharedModule, type DefaultSharedModuleContext } from 'langium/lsp';
-import { StatemachineGeneratedModule, StatemachineGeneratedSharedModule } from './generated/module.js';
+import { StatemachineModelGeneratedModule, StatemachineGeneratedSharedModule } from './generated/module.js';
 import { StatemachineValidator, registerValidationChecks } from './statemachine-validator.js';
 
 /**
@@ -60,7 +60,7 @@ export function createStatemachineServices(context: DefaultSharedModuleContext):
     );
     const statemachine = inject(
         createDefaultModule({ shared }),
-        StatemachineGeneratedModule,
+        StatemachineModelGeneratedModule,
         StatemachineModule
     );
     shared.ServiceRegistry.register(statemachine);

package/src/langium/statemachine/ls/statemachine.langium

@@ -1,26 +1,41 @@
-grammar Statemachine
+grammar StatemachineModel
 
+/** A textual representation of a state machine */
 entry Statemachine:
-    'statemachine' name=ID
-    ('events' events+=Event+)?
+    'statemachine'
+    /** The name of the machine */
+    name=ID
+    ('events'
+        /** The list of recognized event names */
+        events+=Event+)?
     ('commands'    commands+=Command+)?
-    'initialState' init=[State]
+    'initialState'
+    /** The starting state for the machine */
+    init=[State]
+    /** Definitions of available states */
     states+=State*;
 
+/** An event is the trigger for a transition */
 Event:
     name=ID;
 
 Command:
     name=ID;
 
+/** A description of the status of a system */
 State:
     'state' name=ID
         ('actions' '{' actions+=[Command]+ '}')?
+        /** The transitions to other states that can take place from the current one */
         transitions+=Transition*
     'end';
 
+/** A change from one state to another */
 Transition:
-    event=[Event] '=>' state=[State];
+    /** The event triggering the transition */
+    event=[Event] '=>'
+    /** The target state */
+    state=[State];
 
 hidden terminal WS: /\s+/;
 terminal ID: /[_a-zA-Z][\w_]*/;

package/src/langium/statemachine/main-react.tsx

@@ -6,7 +6,7 @@
 import React, { StrictMode, useEffect, useState } from 'react';
 import ReactDOM from 'react-dom/client';
 import { BrowserMessageReader, BrowserMessageWriter } from 'vscode-languageclient/browser.js';
-import type { TextContents } from 'monaco-languageclient/editorApp';
+import type { TextContents } from 'monaco-editor-wrapper';
 import { MonacoEditorReactComp } from '@typefox/monaco-editor-react';
 import { createLangiumGlobalConfig } from './config/wrapperStatemachineConfig.js';
 import { loadStatemachineWorkerRegular } from './main.js';
@@ -20,8 +20,9 @@ export const runStatemachineReact = async () => {
     reader.listen((message) => {
         console.log('Received message from worker:', message);
     });
-    const appConfig = createLangiumGlobalConfig({
+    const wrapperConfig = createLangiumGlobalConfig({
         languageServerId: 'react',
+        useLanguageClient: true,
         codeContent: {
             text,
             uri: '/workspace/example.statemachine'
@@ -61,8 +62,7 @@ export const runStatemachineReact = async () => {
                         <div style={{ 'height': height }} >
                             <MonacoEditorReactComp
                                 style={{ 'height': '100%' }}
-                                vscodeApiConfig={appConfig.vscodeApiConfig}
-                                editorAppConfig={appConfig.editorAppConfig}
+                                wrapperConfig={wrapperConfig}
                                 onTextChanged={onTextChanged}
                             />
                             <b>Debug:</b><br />{testState}