#1038 Provide Worker Label type definition for extended and classic

Author: kaisalmen

.github/workflows/verify.yml

@@ -28,6 +28,11 @@ jobs:
         run: |
           npm run report:versions
 
+      - name: Build
+        shell: bash
+        run: |
+          npm run build
+
       - name: Execute verification
         shell: bash
         run: |

packages/client/src/worker/index.ts

@@ -18,26 +18,39 @@ export class Worker {
 
 export type WorkerLoader = (() => Worker) | undefined;
 
+export type PossibleWorkerLabelsExtended =
+  | 'editorWorkerService'
+  | 'extensionHostWorkerMain'
+  | 'TextMateWorker'
+  | 'OutputLinkDetectionWorker'
+  | 'LanguageDetectionWorker'
+  | 'NotebookEditorWorker'
+  | 'LocalFileSearchWorker';
+
+export type PossibleWorkerLabelsClassic = 'editorWorkerService' | 'css' | 'html' | 'json' | 'javascript' | 'typescript';
+
 export interface WorkerFactoryConfig {
-  workerLoaders?: Partial<Record<string, WorkerLoader>>;
+  workerLoaders?: Partial<Record<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, WorkerLoader>>;
   logger?: ILogger;
 }
 
 export const useWorkerFactory = (config: WorkerFactoryConfig) => {
   const envEnhanced = getEnhancedMonacoEnvironment();
 
-  envEnhanced.getWorkerUrl = (workerId: string, label: string) => {
+  envEnhanced.getWorkerUrl = (workerId: string, label: PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic) => {
     config.logger?.info(`getWorkerUrl: workerId: ${workerId} label: ${label}`);
     return config.workerLoaders?.[label]?.().url.toString();
   };
 
-  envEnhanced.getWorkerOptions = (moduleId: string, label: string) => {
+  envEnhanced.getWorkerOptions = (moduleId: string, label: PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic) => {
     config.logger?.info(`getWorkerOptions: moduleId: ${moduleId} label: ${label}`);
     return config.workerLoaders?.[label]?.().options;
   };
 };
 
-export const defineDefaultWorkerLoaders: () => Partial<Record<string, WorkerLoader>> = () => {
+export const defineDefaultWorkerLoaders: () => Partial<
+  Record<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, WorkerLoader>
+> = () => {
   const defaultEditorWorkerService = () =>
     new Worker(new URL('@codingame/monaco-vscode-editor-api/esm/vs/editor/editor.worker.js', import.meta.url), { type: 'module' });
   const defaultExtensionHostWorkerMain = () =>

packages/client/test/support/helper-classic.ts

@@ -4,11 +4,18 @@
  * ------------------------------------------------------------------------------------------ */
 
 import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
-import { useWorkerFactory, Worker, type WorkerLoader } from 'monaco-languageclient/workerFactory';
+import {
+  useWorkerFactory,
+  Worker,
+  type PossibleWorkerLabelsClassic,
+  type PossibleWorkerLabelsExtended,
+  type WorkerLoader
+} from 'monaco-languageclient/workerFactory';
 
-const workerResolver: Map<string, (value: void | PromiseLike<void>) => void> = new Map();
-const workerPromises: Map<string, Promise<void>> = new Map();
-export const createWorkerPromises = (keys: string[]) => {
+const workerResolver: Map<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, (value: void | PromiseLike<void>) => void> =
+  new Map();
+const workerPromises: Map<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, Promise<void>> = new Map();
+export const createWorkerPromises = (keys: Array<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic>) => {
   workerResolver.clear();
   workerPromises.clear();
   for (const key of keys) {
@@ -23,46 +30,46 @@ export const awaitWorkerPromises = () => {
   return Promise.all([...workerPromises.values()]);
 };
 
-const pushAndPrintLastWorker = (lastWorker: string) => {
+const pushAndPrintLastWorker = (lastWorker: PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic) => {
   console.log(`Called: ${lastWorker}\n`);
   workerResolver.get(lastWorker)?.();
 };
 
-const defineClassicWorkers: () => Partial<Record<string, WorkerLoader>> = () => {
+const defineClassicWorkers: () => Partial<Record<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, WorkerLoader>> = () => {
   const editorWorkerServiceWorker = () => {
     const workerUrl = new URL('@codingame/monaco-vscode-editor-api/esm/vs/editor/editor.worker.js', import.meta.url);
     const worker = new Worker(workerUrl, {
       type: 'module'
     });
-    pushAndPrintLastWorker('editorWorker');
+    pushAndPrintLastWorker('editorWorkerService');
     return worker;
   };
 
   const cssWorker = () => {
     const workerUrl = new URL('@codingame/monaco-vscode-standalone-css-language-features', import.meta.url);
     const worker = new Worker(workerUrl, { type: 'module' });
-    pushAndPrintLastWorker('cssWorker');
+    pushAndPrintLastWorker('css');
     return worker;
   };
 
   const jsonWorker = () => {
     const workerUrl = new URL('@codingame/monaco-vscode-standalone-json-language-features', import.meta.url);
     const worker = new Worker(workerUrl, { type: 'module' });
-    pushAndPrintLastWorker('jsonWorker');
+    pushAndPrintLastWorker('json');
     return worker;
   };
 
   const htmlWorker = () => {
     const workerUrl = new URL('@codingame/monaco-vscode-standalone-html-language-features', import.meta.url);
     const worker = new Worker(workerUrl, { type: 'module' });
-    pushAndPrintLastWorker('htmlWorker');
+    pushAndPrintLastWorker('html');
     return worker;
   };
 
   const tsWorker = () => {
     const workerUrl = new URL('@codingame/monaco-vscode-standalone-typescript-language-features', import.meta.url);
     const worker = new Worker(workerUrl, { type: 'module' });
-    pushAndPrintLastWorker('tsWorker');
+    pushAndPrintLastWorker('typescript');
     return worker;
   };
 

packages/client/test/worker/workerLoaders.test.ts

@@ -38,7 +38,7 @@ describe.concurrent('Test WorkerLoaders', { concurrent: false, tags: ['vscode']
     console.log(`editorWorkerUrl: ${editorWorkerUrl} worker: ${editorWorkerCheck !== undefined}\n`);
 
     // default, expect editor worker to be loaded
-    createWorkerPromises(['editorWorker']);
+    createWorkerPromises(['editorWorkerService']);
     await editorApp.start(htmlContainer);
     expect(await awaitWorkerPromises()).toStrictEqual([undefined]);
     await editorApp.disposeModelRefs();
@@ -54,7 +54,7 @@ describe.concurrent('Test WorkerLoaders', { concurrent: false, tags: ['vscode']
     console.log(`jsonWorkerUrl: ${jsonWorkerUrl} worker: ${jsonWorkerCheck !== undefined}\n`);
 
     // ts worker, expect ts worker and json worker to be loaded
-    createWorkerPromises(['tsWorker', 'jsonWorker']);
+    createWorkerPromises(['typescript', 'json']);
     await editorApp.updateCodeResources({
       modified: {
         text: '',
@@ -69,7 +69,7 @@ describe.concurrent('Test WorkerLoaders', { concurrent: false, tags: ['vscode']
     expect(cssWorkerCheck).toBeUndefined();
     console.log(`cssWorkerUrl: ${cssWorkerUrl} worker: ${cssWorkerCheck !== undefined}\n`);
 
-    createWorkerPromises(['cssWorker']);
+    createWorkerPromises(['css']);
     await editorApp.updateCodeResources({
       modified: {
         text: '',
@@ -84,7 +84,7 @@ describe.concurrent('Test WorkerLoaders', { concurrent: false, tags: ['vscode']
     expect(htmlWorkerCheck).toBeUndefined();
     console.log(`htmlWorkerUrl: ${htmlWorkerUrl} worker: ${htmlWorkerCheck !== undefined}\n`);
 
-    createWorkerPromises(['htmlWorker']);
+    createWorkerPromises(['html']);
     await editorApp.updateCodeResources({
       modified: {
         text: '',

verify/next/app/page.tsx

@@ -6,7 +6,7 @@
 'use client';
 
 import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
-import type { WorkerLoader } from 'monaco-languageclient/workerFactory';
+import type { PossibleWorkerLabelsExtended, PossibleWorkerLabelsClassic, WorkerLoader } from 'monaco-languageclient/workerFactory';
 import dynamic from 'next/dynamic';
 import './views.editorOnly.css';
 
@@ -25,7 +25,7 @@ export default function Page() {
         name: 'Langium LS'
       });
 
-      const defineWorkerLoaders: () => Partial<Record<string, WorkerLoader>> = () => {
+      const defineWorkerLoaders: () => Partial<Record<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, WorkerLoader>> = () => {
         const defaultEditorWorkerService = () =>
           new mlcWFModule.Worker(new URL('../bundle/editorWorker/editor.worker.js', import.meta.url), { type: 'module' });
         // const defaultExtensionHostWorkerMain = () => new mlcWFModule.Worker(

verify/next/app/vite.tsx

@@ -4,7 +4,7 @@
  * ------------------------------------------------------------------------------------------ */
 
 import type { ILogger } from '@codingame/monaco-vscode-log-service-override';
-import type { WorkerLoader } from 'monaco-languageclient/workerFactory';
+import type { PossibleWorkerLabelsClassic, PossibleWorkerLabelsExtended, WorkerLoader } from 'monaco-languageclient/workerFactory';
 import ReactDOM from 'react-dom/client';
 
 export const createDynamicEditorComponent = async () => {
@@ -13,7 +13,7 @@ export const createDynamicEditorComponent = async () => {
 
   const { workerFactory, setupLangiumClientExtended, openDocument, showDocument } = await import('./langium-dsl/config/extendedConfig.js');
 
-  const defineWorkerLoaders: () => Partial<Record<string, WorkerLoader>> = () => {
+  const defineWorkerLoaders: () => Partial<Record<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, WorkerLoader>> = () => {
     const defaultEditorWorkerService = () =>
       new workerFactory.Worker(new URL('../bundle/editorWorker/editor.worker.js', import.meta.url), { type: 'module' });
     const defaultExtensionHostWorkerMain = () =>

verify/next/next-env.d.ts

@@ -5,7 +5,7 @@
 
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import './.next/types/routes.d.ts';
+import './.next/dev/types/routes.d.ts';
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

verify/next/package-lock.json

@@ -3,7 +3,7 @@
   "type": "module",
   "scripts": {
     "clean": "shx rm -fr .next dist lib bundle *.tsbuildinfo",
-    "verify": "npm ci && npm run dev",
+    "verify": "npm ci && npm run dev:next",
     "verify:ci": "npm ci && npm run build -d",
     "dev:next": "npm run bundle && npm run build:tsc && next dev -p 8083",
     "dev:vite": "npm run bundle && npm run build:tsc && vite --config vite.config.ts",
@@ -49,6 +49,8 @@
     "dompurify": "~3.4.11",
     "monaco-languageclient": "../../packages/client",
     "postcss": "8.5.15",
+    "vscode-languageclient": "~10.1.0",
+    "vscode-languageserver": "~10.1.0",
     "vscode-ws-jsonrpc": "../../packages/vscode-ws-jsonrpc"
   },
   "engines": {

verify/next/package.json

@@ -6,15 +6,15 @@
 import '@codingame/monaco-vscode-json-default-extension';
 import { runExtendedClient } from 'monaco-languageclient-examples';
 import { jsontLsConfig } from 'monaco-languageclient-examples/json-client';
-import { Worker, WorkerLoader } from 'monaco-languageclient/workerFactory';
+import { PossibleWorkerLabelsClassic, PossibleWorkerLabelsExtended, Worker, WorkerLoader } from 'monaco-languageclient/workerFactory';
 
 const runJsonWrapper = async () => {
   const helloJsonCode = `{
     "$schema": "http://json.schemastore.org/coffeelint",
     "line_endings": {"value": "unix"}
 }`;
 
-  const defineWorkerLoaders: () => Partial<Record<string, WorkerLoader>> = () => {
+  const defineWorkerLoaders: () => Partial<Record<PossibleWorkerLabelsExtended | PossibleWorkerLabelsClassic, WorkerLoader>> = () => {
     const defaultEditorWorkerService = () => new Worker(new URL('../../bundle/editor.worker.js', import.meta.url), { type: 'module' });
     const defaultTextMateWorker = () => new Worker(new URL('../../bundle/worker.js', import.meta.url), { type: 'module' });