@volar/monaco 2.0.0-alpha.9 → 2.0.1

package/README.md

@@ -22,15 +22,22 @@ We assume you already know:
 // my-lang.worker.ts
 import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
 import type * as monaco from 'monaco-editor-core';
-import { createLanguageService } from '@volar/monaco/worker';
+import { createSimpleWorkerService, ServiceEnvironment } from '@volar/monaco/worker';
 
 self.onmessage = () => {
 	worker.initialize((ctx: monaco.worker.IWorkerContext) => {
-		return createLanguageService({
+		const env: ServiceEnvironment = {
+			workspaceFolder: 'file:///',
+		};
+		return createSimpleWorkerService({
 			workerContext: ctx,
-			config: {
-				// ...Language Service Config of my-lang language support
-			},
+			env,
+			languagePlugins: [
+				// ...
+			],
+			servicePlugins: [
+				// ...
+			],
 		});
 	});
 };
@@ -41,29 +48,80 @@ self.onmessage = () => {
 ```diff
 import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
 import type * as monaco from 'monaco-editor-core';
-import { createLanguageService } from '@volar/monaco/worker';
+-import { createSimpleWorkerService, ServiceEnvironment } from '@volar/monaco/worker';
++import {
++	createTypeScriptWorkerService,
++	ServiceEnvironment,
++} from '@volar/monaco/worker';
 +import * as ts from 'typescript';
-+import createTypeScriptService, { createJsDelivrDtsHost } from 'volar-service-typescript';
++import { create as createTypeScriptService } from 'volar-service-typescript';
 
 self.onmessage = () => {
 	worker.initialize((ctx: monaco.worker.IWorkerContext) => {
-		return createLanguageService({
-			workerContext: ctx,
-			config: {
-				// ...Language Service Config of my-lang language support
-+				services: {
-+					typescript: createTypeScriptService({
-+						// Enable auto fetch node_modules types
-+						dtsHost: createJsDelivrDtsHost({ typescript: '4.9.5' }),
-+					})
-+				},
-			},
+		const env: ServiceEnvironment = {
+			workspaceFolder: 'file:///',
 +			typescript: {
-+				module: ts,
-+				compilerOptions: {
-+					// ...tsconfig options
-+				},
++				uriToFileName: uri => uri.substring('file://'.length),
++				fileNameToUri: fileName => 'file://' + fileName,
 +			},
+		};
+-		return createSimpleWorkerService({
++		return createTypeScriptWorkerService({
++			typescript: ts,
++			compilerOptions: {
++				// ...
++			},
+			workerContext: ctx,
+			env,
+			languagePlugins: [
+				// ...
+			],
+			servicePlugins: [
+				// ...
++				createTypeScriptService(ts),
+			],
+		});
+	});
+};
+```
+
+#### Add ATA Support for TypeScript
+
+```diff
+import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
+import type * as monaco from 'monaco-editor-core';
+import {
+	createTypeScriptWorkerService,
+	ServiceEnvironment,
++	activateAutomaticTypeAcquisition,
+} from '@volar/monaco/worker';
+import * as ts from 'typescript';
+import { create as createTypeScriptService } from 'volar-service-typescript';
+
+self.onmessage = () => {
+	worker.initialize((ctx: monaco.worker.IWorkerContext) => {
+		const env: ServiceEnvironment = {
+			workspaceFolder: 'file:///',
+			typescript: {
+				uriToFileName: uri => uri.substring('file://'.length),
+				fileNameToUri: fileName => 'file://' + fileName,
+			},
+		};
++		activateAutomaticTypeAcquisition(env);
+		return createTypeScriptWorkerService({
+			typescript: ts,
+			compilerOptions: {
+				// ...
+			},
+			workerContext: ctx,
+			env,
+			languagePlugins: [
+				// ...
+			],
+			servicePlugins: [
+				// ...
+				createTypeScriptService(ts),
+			],
 		});
 	});
 };
@@ -90,7 +148,7 @@ import myWorker from './my-lang.worker?worker';
 ```ts
 import type { LanguageService } from '@volar/language-service';
 import { editor, languages, Uri } from 'monaco-editor-core';
-import * as VolarMonaco from '@volar/monaco';
+import { activateMarkers, activateAutoInsertion, registerProviders } from '@volar/monaco';
 
 languages.register({ id: 'my-lang', extensions: ['.my-lang'] });
 
@@ -99,7 +157,7 @@ languages.onLanguage('my-lang', () => {
 		moduleId: 'vs/language/my-lang/myLangWorker',
 		label: 'my-lang',
 	});
-	VolarMonaco.editor.activateMarkers(
+	activateMarkers(
 		worker,
 		['my-lang'],
 		'my-lang-markers-owner',
@@ -108,14 +166,14 @@ languages.onLanguage('my-lang', () => {
 		editor
 	);
 	// auto close tags
-	VolarMonaco.editor.activateAutoInsertion(
+	activateAutoInsertion(
 		worker,
 		['my-lang'],
 		// sync files
 		() => [Uri.file('/Foo.my-lang'), Uri.file('/Bar.my-lang')],
 		editor
 	);
-	VolarMonaco.languages.registerProviders(worker, ['my-lang'], languages)
+	registerProviders(worker, ['my-lang'], languages)
 });
 ```
 

package/lib/ata.d.ts

@@ -0,0 +1,2 @@
+import type { ServiceEnvironment } from '@volar/language-service';
+export declare function activateAutomaticTypeAcquisition(env: ServiceEnvironment, onFetch?: (path: string, content: string) => void): void;

package/lib/ata.js

@@ -0,0 +1,228 @@
+export function activateAutomaticTypeAcquisition(env, onFetch) {
+    const textCache = new Map();
+    const jsonCache = new Map();
+    const npmFs = createJsDelivrNpmFileSystem();
+    const _fs = env.fs;
+    env.fs = {
+        async stat(uri) {
+            return await npmFs.stat(uri) ?? await _fs?.stat(uri);
+        },
+        async readDirectory(uri) {
+            return [
+                ...await npmFs.readDirectory(uri),
+                ...await _fs?.readDirectory(uri) ?? [],
+            ];
+        },
+        async readFile(uri) {
+            return await npmFs.readFile(uri) ?? await _fs?.readFile(uri);
+        },
+    };
+    function createJsDelivrNpmFileSystem() {
+        const fetchResults = new Map();
+        const flatResults = new Map();
+        return {
+            async stat(uri) {
+                const fileName = env.typescript.uriToFileName(uri);
+                if (fileName === '/node_modules') {
+                    return {
+                        type: 2,
+                        size: -1,
+                        ctime: -1,
+                        mtime: -1,
+                    };
+                }
+                if (fileName.startsWith('/node_modules/')) {
+                    const path = uri.substring('/node_modules/'.length);
+                    return await _stat(path);
+                }
+            },
+            async readFile(uri) {
+                const fileName = env.typescript.uriToFileName(uri);
+                if (fileName.startsWith('/node_modules/')) {
+                    const path = uri.substring('/node_modules/'.length);
+                    return await _readFile(path);
+                }
+            },
+            async readDirectory(uri) {
+                const fileName = env.typescript.uriToFileName(uri);
+                if (fileName.startsWith('/node_modules/')) {
+                    const path = uri.substring('/node_modules/'.length);
+                    return _readDirectory(path);
+                }
+                return [];
+            },
+        };
+        async function _stat(path) {
+            const pkgName = getPackageName(path);
+            if (!pkgName || !await isValidPackageName(pkgName)) {
+                return;
+            }
+            if (!flatResults.has(pkgName)) {
+                flatResults.set(pkgName, flat(pkgName));
+            }
+            const flatResult = await flatResults.get(pkgName);
+            const filePath = path.slice(pkgName.length);
+            const file = flatResult.find(file => file.name === filePath);
+            if (file) {
+                return {
+                    type: 1,
+                    ctime: new Date(file.time).valueOf(),
+                    mtime: new Date(file.time).valueOf(),
+                    size: file.size,
+                };
+            }
+            else if (flatResult.some(file => file.name.startsWith(filePath + '/'))) {
+                return {
+                    type: 2,
+                    ctime: -1,
+                    mtime: -1,
+                    size: -1,
+                };
+            }
+        }
+        async function _readDirectory(path) {
+            const pkgName = getPackageName(path);
+            if (!pkgName || !await isValidPackageName(pkgName)) {
+                return [];
+            }
+            if (!flatResults.has(pkgName)) {
+                flatResults.set(pkgName, flat(pkgName));
+            }
+            const flatResult = await flatResults.get(pkgName);
+            const dirPath = path.slice(pkgName.length);
+            const files = flatResult
+                .filter(f => f.name.substring(0, f.name.lastIndexOf('/')) === dirPath)
+                .map(f => f.name.slice(dirPath.length + 1));
+            const dirs = flatResult
+                .filter(f => f.name.startsWith(dirPath + '/') && f.name.substring(dirPath.length + 1).split('/').length >= 2)
+                .map(f => f.name.slice(dirPath.length + 1).split('/')[0]);
+            return [
+                ...files.map(f => [f, 1]),
+                ...[...new Set(dirs)].map(f => [f, 2]),
+            ];
+        }
+        async function _readFile(path) {
+            const pkgName = getPackageName(path);
+            if (!pkgName || !await isValidPackageName(pkgName)) {
+                return;
+            }
+            if (!fetchResults.has(path)) {
+                fetchResults.set(path, (async () => {
+                    if ((await _stat(path))?.type !== 1) {
+                        return;
+                    }
+                    const text = await fetchText(`https://cdn.jsdelivr.net/npm/${path}`);
+                    if (text !== undefined) {
+                        onFetch?.(path, text);
+                    }
+                    return text;
+                })());
+            }
+            return await fetchResults.get(path);
+        }
+        async function flat(pkgNameWithVersion) {
+            let pkgName = pkgNameWithVersion;
+            let version = 'latest';
+            if (pkgNameWithVersion.substring(1).includes('@')) {
+                pkgName = pkgNameWithVersion.substring(0, pkgNameWithVersion.lastIndexOf('@'));
+                version = pkgNameWithVersion.substring(pkgNameWithVersion.lastIndexOf('@') + 1);
+            }
+            // resolve tag version
+            if (version === 'latest') {
+                const data = await fetchJson(`https://data.jsdelivr.com/v1/package/resolve/npm/${pkgName}@latest`);
+                if (!data?.version) {
+                    return [];
+                }
+                version = data.version;
+            }
+            const flat = await fetchJson(`https://data.jsdelivr.com/v1/package/npm/${pkgName}@${version}/flat`);
+            if (!flat) {
+                return [];
+            }
+            return flat.files;
+        }
+        async function isValidPackageName(pkgName) {
+            // @aaa/bbb@latest -> @aaa/bbb
+            if (pkgName.substring(1).includes('@')) {
+                pkgName = pkgName.substring(0, pkgName.lastIndexOf('@'));
+            }
+            // ignore @aaa/node_modules
+            if (pkgName.endsWith('/node_modules')) {
+                return false;
+            }
+            // hard code for known invalid package
+            if (pkgName.startsWith('@typescript/') || pkgName.startsWith('@types/typescript__')) {
+                return false;
+            }
+            // don't check @types if original package already having types
+            if (pkgName.startsWith('@types/')) {
+                let originalPkgName = pkgName.slice('@types/'.length);
+                if (originalPkgName.indexOf('__') >= 0) {
+                    originalPkgName = '@' + originalPkgName.replace('__', '/');
+                }
+                const packageJson = await _readFile(`${originalPkgName}/package.json`);
+                if (packageJson) {
+                    const packageJsonObj = JSON.parse(packageJson);
+                    if (packageJsonObj.types || packageJsonObj.typings) {
+                        return false;
+                    }
+                    const indexDts = await _stat(`${originalPkgName}/index.d.ts`);
+                    if (indexDts?.type === 1) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+    }
+    /**
+     * @example
+     * "a/b/c" -> "a"
+     * "@a/b/c" -> "@a/b"
+     * "@a/b@1.2.3/c" -> "@a/b@1.2.3"
+     */
+    function getPackageName(path) {
+        const parts = path.split('/');
+        let pkgName = parts[0];
+        if (pkgName.startsWith('@')) {
+            if (parts.length < 2 || !parts[1]) {
+                return undefined;
+            }
+            pkgName += '/' + parts[2];
+        }
+        return pkgName;
+    }
+    async function fetchText(url) {
+        if (!textCache.has(url)) {
+            textCache.set(url, (async () => {
+                try {
+                    const res = await fetch(url);
+                    if (res.status === 200) {
+                        return await res.text();
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            })());
+        }
+        return await textCache.get(url);
+    }
+    async function fetchJson(url) {
+        if (!jsonCache.has(url)) {
+            jsonCache.set(url, (async () => {
+                try {
+                    const res = await fetch(url);
+                    if (res.status === 200) {
+                        return await res.json();
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            })());
+        }
+        return await jsonCache.get(url);
+    }
+}
+//# sourceMappingURL=ata.js.map

package/lib/editor.js

@@ -3,7 +3,7 @@ import { markers } from './markers.js';
 export function activateMarkers(worker, languages, markersOwn, getSyncUris, editor) {
     const disposables = [];
     const listener = new Map();
-    disposables.push(editor.onDidCreateModel((model) => hostingMarkers(model)), editor.onWillDisposeModel(stopHostingMarkers), editor.onDidChangeModelLanguage((event) => {
+    disposables.push(editor.onDidCreateModel(model => hostingMarkers(model)), editor.onWillDisposeModel(stopHostingMarkers), editor.onDidChangeModelLanguage(event => {
         stopHostingMarkers(event.model);
         hostingMarkers(event.model);
     }), {
@@ -16,7 +16,7 @@ export function activateMarkers(worker, languages, markersOwn, getSyncUris, edit
     for (const model of editor.getModels()) {
         hostingMarkers(model);
     }
-    return { dispose: () => disposables.forEach((d) => d.dispose()) };
+    return { dispose: () => disposables.forEach(d => d.dispose()) };
     function stopHostingMarkers(model) {
         editor.setModelMarkers(model, markersOwn, []);
         const key = model.uri.toString();
@@ -76,7 +76,7 @@ export function activateAutoInsertion(worker, languages, getSyncUris, editor) {
     const disposables = [];
     const listener = new Map();
     let timeout;
-    disposables.push(editor.onDidCreateModel((model) => hostingAutoInsertion(model)), editor.onWillDisposeModel(stopHostingAutoInsertion), editor.onDidChangeModelLanguage((event) => {
+    disposables.push(editor.onDidCreateModel(model => hostingAutoInsertion(model)), editor.onWillDisposeModel(stopHostingAutoInsertion), editor.onDidChangeModelLanguage(event => {
         stopHostingAutoInsertion(event.model);
         hostingAutoInsertion(event.model);
     }), {
@@ -90,7 +90,7 @@ export function activateAutoInsertion(worker, languages, getSyncUris, editor) {
     for (const model of editor.getModels()) {
         hostingAutoInsertion(model);
     }
-    return { dispose: () => disposables.forEach((d) => d.dispose()) };
+    return { dispose: () => disposables.forEach(d => d.dispose()) };
     function stopHostingAutoInsertion(model) {
         if (listener.has(model)) {
             listener.get(model)?.dispose();
@@ -101,7 +101,7 @@ export function activateAutoInsertion(worker, languages, getSyncUris, editor) {
         if (!languages.includes(model.getLanguageId?.() ?? model.getModeId?.())) {
             return;
         }
-        listener.set(model, model.onDidChangeContent((e) => {
+        listener.set(model, model.onDidChangeContent(e => {
             if (model.isDisposed()) {
                 return;
             }
@@ -137,7 +137,7 @@ export function activateAutoInsertion(worker, languages, getSyncUris, editor) {
                 if (model.getVersionId() !== version) {
                     return;
                 }
-                const codeEditor = editor.getEditors().find((e) => e.getModel() === model);
+                const codeEditor = editor.getEditors().find(e => e.getModel() === model);
                 if (codeEditor && edit && model.getVersionId() === version) {
                     if (typeof edit === 'string') {
                         codeEditor?.getContribution('snippetController2')?.insert(edit);

package/lib/languages.js

@@ -27,6 +27,6 @@ export async function registerProviders(worker, language, getSyncUris, languages
         languages.registerDocumentSemanticTokensProvider(language, provider),
         languages.registerDocumentRangeSemanticTokensProvider(language, provider),
     ];
-    return { dispose: () => disposables.forEach((d) => d.dispose()) };
+    return { dispose: () => disposables.forEach(d => d.dispose()) };
 }
 //# sourceMappingURL=languages.js.map

package/lib/provider.js

@@ -245,8 +245,8 @@ export async function createLanguageFeaturesProvider(worker, getSyncUris) {
         },
         async provideSelectionRanges(model, positions) {
             const languageService = await worker.withSyncedResources(getSyncUris());
-            const codeResults = await Promise.all(positions.map((position) => languageService.getSelectionRanges(model.uri.toString(), [fromPosition(position)])));
-            return codeResults.map((codeResult) => codeResult?.map(toSelectionRange) ?? []);
+            const codeResults = await Promise.all(positions.map(position => languageService.getSelectionRanges(model.uri.toString(), [fromPosition(position)])));
+            return codeResults.map(codeResult => codeResult?.map(toSelectionRange) ?? []);
         },
         async provideSignatureHelp(model, position, _token, context) {
             const languageService = await worker.withSyncedResources(getSyncUris());

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/monaco",
-	"version": "2.0.0-alpha.9",
+	"version": "2.0.1",
 	"license": "MIT",
 	"type": "module",
 	"files": [
@@ -13,8 +13,8 @@
 		"directory": "packages/monaco"
 	},
 	"dependencies": {
-		"@volar/language-service": "2.0.0-alpha.9",
-		"@volar/typescript": "2.0.0-alpha.9",
+		"@volar/language-service": "2.0.1",
+		"@volar/typescript": "2.0.1",
 		"monaco-languageserver-types": "^0.3.2",
 		"monaco-types": "^0.1.0",
 		"vscode-uri": "^3.0.8"
@@ -22,5 +22,5 @@
 	"devDependencies": {
 		"monaco-editor-core": "latest"
 	},
-	"gitHead": "dcd70c78b0b6901901dc0e68223e34dd922f5fdc"
+	"gitHead": "b1fbf6eed522624ccccfb17a8999edfbc1d8d9bb"
 }

package/worker.d.ts

@@ -1,7 +1,15 @@
-import { LanguagePlugin, ServicePlugin } from '@volar/language-service';
+import { LanguagePlugin, ServicePlugin, type ServiceEnvironment } from '@volar/language-service';
 import type * as monaco from 'monaco-types';
-import type * as ts from 'typescript/lib/tsserverlibrary.js';
-export declare function createSimpleWorkerService<T = {}>(languages: LanguagePlugin[], services: ServicePlugin[], getMirrorModels: monaco.worker.IWorkerContext<any>['getMirrorModels'], extraApis?: T): {
+import type * as ts from 'typescript';
+export * from '@volar/language-service';
+export * from './lib/ata.js';
+export declare function createSimpleWorkerService<T = {}>({ env, workerContext, languagePlugins, servicePlugins, extraApis }: {
+    env: ServiceEnvironment;
+    workerContext: monaco.worker.IWorkerContext<any>;
+    languagePlugins?: LanguagePlugin[];
+    servicePlugins?: ServicePlugin[];
+    extraApis?: T;
+}): {
     getTriggerCharacters: () => string[];
     getAutoFormatTriggerCharacters: () => string[];
     getSignatureHelpTriggerCharacters: () => string[];
@@ -58,7 +66,15 @@ export declare function createSimpleWorkerService<T = {}>(languages: LanguagePlu
     dispose: () => void;
     context: import("@volar/language-service").ServiceContext;
 } & T;
-export declare function createTypeScriptWorkerService<T = {}>(ts: typeof import('typescript/lib/tsserverlibrary.js'), languages: LanguagePlugin[], services: ServicePlugin[], getMirrorModels: monaco.worker.IWorkerContext<any>['getMirrorModels'], compilerOptions: ts.CompilerOptions, extraApis?: T): {
+export declare function createTypeScriptWorkerService<T = {}>({ typescript: ts, compilerOptions, env, workerContext, languagePlugins, servicePlugins, extraApis }: {
+    typescript: typeof import('typescript');
+    compilerOptions: ts.CompilerOptions;
+    env: ServiceEnvironment;
+    workerContext: monaco.worker.IWorkerContext<any>;
+    languagePlugins?: LanguagePlugin[];
+    servicePlugins?: ServicePlugin[];
+    extraApis?: T;
+}): {
     getTriggerCharacters: () => string[];
     getAutoFormatTriggerCharacters: () => string[];
     getSignatureHelpTriggerCharacters: () => string[];

package/worker.js

@@ -1,104 +1,88 @@
-import { createLanguageService as _createLanguageService, createFileProvider, resolveCommonLanguageId, } from '@volar/language-service';
-import { URI } from 'vscode-uri';
+import { createLanguageService as _createLanguageService, createFileRegistry, resolveCommonLanguageId, } from '@volar/language-service';
 import { createLanguage, createSys } from '@volar/typescript';
-export function createSimpleWorkerService(languages, services, getMirrorModels, extraApis = {}) {
-    return createWorkerService(services, env => {
-        const snapshots = new Map();
-        const files = createFileProvider(languages, false, fileName => {
-            const uri = env.fileNameToUri(fileName);
-            const model = getMirrorModels().find(model => model.uri.toString(true) === uri);
+export * from '@volar/language-service';
+export * from './lib/ata.js';
+export function createSimpleWorkerService({ env, workerContext, languagePlugins = [], servicePlugins = [], extraApis = {} }) {
+    const snapshots = new Map();
+    const files = createFileRegistry(languagePlugins, false, uri => {
+        const model = workerContext.getMirrorModels().find(model => model.uri.toString() === uri);
+        if (model) {
+            const cache = snapshots.get(model);
+            if (cache && cache[0] === model.version) {
+                return;
+            }
+            const text = model.getValue();
+            const snapshot = {
+                getText: (start, end) => text.substring(start, end),
+                getLength: () => text.length,
+                getChangeRange: () => undefined,
+            };
+            snapshots.set(model, [model.version, snapshot]);
+            files.set(uri, resolveCommonLanguageId(uri), snapshot);
+        }
+        else {
+            files.delete(uri);
+        }
+    });
+    return createWorkerService({ files }, servicePlugins, env, extraApis);
+}
+export function createTypeScriptWorkerService({ typescript: ts, compilerOptions, env, workerContext, languagePlugins = [], servicePlugins = [], extraApis = {} }) {
+    let projectVersion = 0;
+    const modelSnapshot = new WeakMap();
+    const modelVersions = new Map();
+    const host = {
+        getCurrentDirectory() {
+            return env.typescript.uriToFileName(env.workspaceFolder);
+        },
+        getScriptFileNames() {
+            return workerContext.getMirrorModels().map(model => env.typescript.uriToFileName(model.uri.toString()));
+        },
+        getProjectVersion() {
+            const models = workerContext.getMirrorModels();
+            if (modelVersions.size === workerContext.getMirrorModels().length) {
+                if (models.every(model => modelVersions.get(model) === model.version)) {
+                    return projectVersion.toString();
+                }
+            }
+            modelVersions.clear();
+            for (const model of workerContext.getMirrorModels()) {
+                modelVersions.set(model, model.version);
+            }
+            projectVersion++;
+            return projectVersion.toString();
+        },
+        getScriptSnapshot(fileName) {
+            const uri = env.typescript.fileNameToUri(fileName);
+            const model = workerContext.getMirrorModels().find(model => model.uri.toString() === uri);
             if (model) {
-                const cache = snapshots.get(model);
+                const cache = modelSnapshot.get(model);
                 if (cache && cache[0] === model.version) {
-                    return;
+                    return cache[1];
                 }
                 const text = model.getValue();
-                const snapshot = {
-                    getText: (start, end) => text.substring(start, end),
-                    getLength: () => text.length,
-                    getChangeRange: () => undefined,
-                };
-                snapshots.set(model, [model.version, snapshot]);
-                files.updateSourceFile(fileName, resolveCommonLanguageId(fileName), snapshot);
+                modelSnapshot.set(model, [model.version, {
+                        getText: (start, end) => text.substring(start, end),
+                        getLength: () => text.length,
+                        getChangeRange: () => undefined,
+                    }]);
+                return modelSnapshot.get(model)?.[1];
             }
-            else {
-                files.deleteSourceFile(fileName);
-            }
-        });
-        return { files };
-    }, extraApis);
-}
-export function createTypeScriptWorkerService(ts, languages, services, getMirrorModels, compilerOptions, extraApis = {}) {
-    return createWorkerService(services, env => {
-        let projectVersion = 0;
-        const modelSnapshot = new WeakMap();
-        const modelVersions = new Map();
-        const host = {
-            getCurrentDirectory() {
-                return env.uriToFileName(env.workspaceFolder.uri.toString(true));
-            },
-            getProjectVersion() {
-                const models = getMirrorModels();
-                if (modelVersions.size === getMirrorModels().length) {
-                    if (models.every(model => modelVersions.get(model) === model.version)) {
-                        return projectVersion.toString();
-                    }
-                }
-                modelVersions.clear();
-                for (const model of getMirrorModels()) {
-                    modelVersions.set(model, model.version);
-                }
-                projectVersion++;
-                return projectVersion.toString();
-            },
-            getScriptFileNames() {
-                const models = getMirrorModels();
-                return models.map(model => env.uriToFileName(model.uri.toString(true)));
-            },
-            getScriptSnapshot(fileName) {
-                const uri = env.fileNameToUri(fileName);
-                const model = getMirrorModels().find(model => model.uri.toString(true) === uri);
-                if (model) {
-                    const cache = modelSnapshot.get(model);
-                    if (cache && cache[0] === model.version) {
-                        return cache[1];
-                    }
-                    const text = model.getValue();
-                    modelSnapshot.set(model, [model.version, {
-                            getText: (start, end) => text.substring(start, end),
-                            getLength: () => text.length,
-                            getChangeRange: () => undefined,
-                        }]);
-                    return modelSnapshot.get(model)?.[1];
-                }
-            },
-            getCompilationSettings() {
-                return compilerOptions;
-            },
-            getLanguageId: id => resolveCommonLanguageId(id),
-        };
-        const sys = createSys(ts, env, host.getCurrentDirectory());
-        const language = createLanguage(ts, sys, languages, undefined, host);
-        return language;
-    }, extraApis);
-}
-function createWorkerService(services, getLanguage, extraApis = {}) {
-    const env = {
-        workspaceFolder: {
-            uri: URI.file('/'),
-            name: '',
         },
-        uriToFileName: uri => URI.parse(uri).fsPath.replace(/\\/g, '/'),
-        fileNameToUri: fileName => URI.file(fileName).toString(),
-        console,
+        getCompilationSettings() {
+            return compilerOptions;
+        },
+        getLanguageId: id => resolveCommonLanguageId(id),
     };
-    const language = getLanguage(env);
-    const languageService = _createLanguageService(language, services, env);
+    const sys = createSys(ts, env, host);
+    const languageContext = createLanguage(ts, sys, languagePlugins, undefined, host, {
+        fileNameToFileId: env.typescript.fileNameToUri,
+        fileIdToFileName: env.typescript.uriToFileName,
+    });
+    return createWorkerService(languageContext, servicePlugins, env, extraApis);
+}
+function createWorkerService(languageContext, servicePlugins, env, extraApis = {}) {
+    const languageService = _createLanguageService(languageContext, servicePlugins, env);
     class WorkerService {
-        constructor() {
-            this.env = env;
-            this.project = language;
-        }
     }
     ;
     for (const api in languageService) {