@volar/typescript 2.0.0-alpha.9 → 2.0.1

package/lib/protocol/createProject.js

@@ -4,11 +4,11 @@ exports.createLanguage = void 0;
 const language_core_1 = require("@volar/language-core");
 const language_core_2 = require("@volar/language-core");
 const path = require("path-browserify");
-const utilities_1 = require("../typescript/utilities");
 const scriptVersions = new Map();
 const fsFileSnapshots = new Map();
-function createLanguage(ts, sys, languages, configFileName, projectHost) {
-    const files = (0, language_core_1.createFileProvider)(languages, sys.useCaseSensitiveFileNames, fileName => {
+function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, { fileIdToFileName, fileNameToFileId }) {
+    const files = (0, language_core_1.createFileRegistry)(languagePlugins, sys.useCaseSensitiveFileNames, fileId => {
+        const fileName = fileIdToFileName(fileId);
         // opened files
         let snapshot = projectHost.getScriptSnapshot(fileName);
         if (!snapshot) {
@@ -28,19 +28,19 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             snapshot = fsFileSnapshots.get(fileName)?.[1];
         }
         if (snapshot) {
-            files.updateSourceFile(fileName, projectHost.getLanguageId(fileName), snapshot);
+            files.set(fileId, projectHost.getLanguageId(fileId), snapshot);
         }
         else {
-            files.deleteSourceFile(fileName);
+            files.delete(fileId);
         }
     });
-    let languageServiceHost = createLanguageServiceHost();
-    for (const language of languages) {
+    let { languageServiceHost, getExtraScript } = createLanguageServiceHost();
+    for (const language of languagePlugins) {
         if (language.typescript?.resolveLanguageServiceHost) {
             languageServiceHost = language.typescript.resolveLanguageServiceHost(languageServiceHost);
         }
     }
-    if (languages.some(language => language.typescript?.resolveModuleName)) {
+    if (languagePlugins.some(language => language.typescript?.extraFileExtensions.length)) {
         // TODO: can this share between monorepo packages?
         const moduleCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), languageServiceHost.useCaseSensitiveFileNames ? s => s : s => s.toLowerCase(), languageServiceHost.getCompilationSettings());
         let lastSysVersion = 'version' in sys ? sys.version : undefined;
@@ -49,28 +49,40 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
                 lastSysVersion = sys.version;
                 moduleCache.clear();
             }
-            return moduleLiterals.map((moduleLiteral) => {
+            return moduleLiterals.map(moduleLiteral => {
                 let moduleName = moduleLiteral.text;
-                for (const language of languages) {
-                    if (language.typescript?.resolveModuleName) {
-                        moduleName = language.typescript.resolveModuleName(moduleName, sourceFile.impliedNodeFormat) ?? moduleName;
+                let extraFileExtension;
+                let isPatchResult = false;
+                for (const language of languagePlugins) {
+                    extraFileExtension = language.typescript?.extraFileExtensions.find(ext => moduleName.endsWith('.' + ext.extension))?.extension;
+                    if (extraFileExtension) {
+                        break;
                     }
                 }
-                return ts.resolveModuleName(moduleName, containingFile, options, languageServiceHost, moduleCache, redirectedReference, sourceFile.impliedNodeFormat);
-            });
-        };
-        languageServiceHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options, sourceFile) => {
-            if ('version' in sys && lastSysVersion !== sys.version) {
-                lastSysVersion = sys.version;
-                moduleCache.clear();
-            }
-            return moduleNames.map((moduleName) => {
-                for (const language of languages) {
-                    if (language.typescript?.resolveModuleName) {
-                        moduleName = language.typescript.resolveModuleName(moduleName, sourceFile?.impliedNodeFormat) ?? moduleName;
+                const result = ts.resolveModuleName(moduleName, containingFile, options, {
+                    ...languageServiceHost,
+                    fileExists(fileName) {
+                        if (extraFileExtension && fileName.endsWith('.d.ts')) {
+                            const patchResult = languageServiceHost.fileExists(fileName.slice(0, -5));
+                            if (patchResult) {
+                                isPatchResult = true;
+                                return true;
+                            }
+                        }
+                        return sys.fileExists(fileName);
+                    },
+                }, moduleCache, redirectedReference, sourceFile.impliedNodeFormat);
+                if (isPatchResult && result.resolvedModule) {
+                    result.resolvedModule.resolvedFileName = result.resolvedModule.resolvedFileName.slice(0, -5);
+                    const sourceFile = files.get(fileNameToFileId(result.resolvedModule.resolvedFileName));
+                    if (sourceFile?.generated) {
+                        const tsCode = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
+                        if (tsCode) {
+                            result.resolvedModule.extension = tsCode.extension;
+                        }
                     }
                 }
-                return ts.resolveModuleName(moduleName, containingFile, options, languageServiceHost, moduleCache, redirectedReference, sourceFile?.impliedNodeFormat).resolvedModule;
+                return result;
             });
         };
     }
@@ -81,22 +93,31 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             sys,
             projectHost,
             languageServiceHost,
-            synchronizeFileSystem: 'sync' in sys ? () => sys.sync() : undefined,
+            getExtraScript,
         },
     };
     function createLanguageServiceHost() {
         let lastProjectVersion;
         let tsProjectVersion = 0;
         let tsFileRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
+        let extraScriptRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
         let lastTsVirtualFileSnapshots = new Set();
         let lastOtherVirtualFileSnapshots = new Set();
         const languageServiceHost = {
             ...sys,
             getCurrentDirectory: projectHost.getCurrentDirectory,
-            getCompilationSettings: projectHost.getCompilationSettings,
+            getCompilationSettings() {
+                const options = projectHost.getCompilationSettings();
+                if (languagePlugins.some(language => language.typescript?.extraFileExtensions.length)
+                    && !options.allowNonTsExtensions) {
+                    console.warn('`allowNonTsExtensions` must be `true`.');
+                    options.allowNonTsExtensions ??= true;
+                }
+                return options;
+            },
             getLocalizedDiagnosticMessages: projectHost.getLocalizedDiagnosticMessages,
             getProjectReferences: projectHost.getProjectReferences,
-            getDefaultLibFileName: (options) => {
+            getDefaultLibFileName: options => {
                 try {
                     return ts.getDefaultLibFilePath(options);
                 }
@@ -114,71 +135,47 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             getTypeRootsVersion: () => {
                 return 'version' in sys ? sys.version : -1; // TODO: only update for /node_modules changes?
             },
-            // need sync
             getDirectories(dirName) {
-                syncProject();
-                return [...new Set([
-                        ...getVirtualFileDirectories(dirName),
-                        ...sys.getDirectories(dirName),
-                    ])];
+                return sys.getDirectories(dirName);
+            },
+            readDirectory(dirName, extensions, excludes, includes, depth) {
+                const exts = new Set(extensions);
+                for (const languagePlugin of languagePlugins) {
+                    for (const ext of languagePlugin.typescript?.extraFileExtensions ?? []) {
+                        exts.add('.' + ext.extension);
+                    }
+                }
+                extensions = [...exts];
+                return sys.readDirectory(dirName, extensions, excludes, includes, depth);
             },
             readFile(fileName) {
-                syncSourceFile(fileName);
                 const snapshot = getScriptSnapshot(fileName);
                 if (snapshot) {
                     return snapshot.getText(0, snapshot.getLength());
                 }
             },
             fileExists(fileName) {
-                syncSourceFile(fileName);
                 return getScriptVersion(fileName) !== '';
             },
-            readDirectory(dirName, extensions, excludes, includes, depth) {
-                syncProject();
-                let matches = (0, utilities_1.matchFiles)(dirName, extensions, excludes, includes, sys?.useCaseSensitiveFileNames ?? false, projectHost.getCurrentDirectory(), depth, (dirPath) => {
-                    const files = [];
-                    for (const fileName of tsFileRegistry.keys()) {
-                        if (fileName.toLowerCase().startsWith(dirPath.toLowerCase())) {
-                            const baseName = fileName.substring(dirPath.length);
-                            if (baseName.indexOf('/') === -1) {
-                                files.push(baseName);
-                            }
-                        }
-                    }
-                    return {
-                        files,
-                        directories: getVirtualFileDirectories(dirPath),
-                    };
-                }, sys?.realpath ? (path => sys.realpath(path)) : (path => path));
-                matches = matches.map(match => {
-                    const [_, source] = files.getVirtualFile(match);
-                    if (source) {
-                        return source.fileName;
-                    }
-                    return match;
-                });
-                return [...new Set([
-                        ...matches,
-                        ...sys.readDirectory(dirName, extensions, excludes, includes, depth),
-                    ])];
-            },
             getProjectVersion() {
-                syncProject();
+                sync();
                 return tsProjectVersion + ('version' in sys ? `:${sys.version}` : '');
             },
             getScriptFileNames() {
-                syncProject();
+                sync();
                 return [...tsFileRegistry.keys()];
             },
             getScriptKind(fileName) {
-                syncSourceFile(fileName);
-                const virtualFile = files.getVirtualFile(fileName)[0];
-                if (virtualFile?.typescript) {
-                    return virtualFile.typescript.scriptKind;
+                sync();
+                if (extraScriptRegistry.has(fileName)) {
+                    return extraScriptRegistry.get(fileName).scriptKind;
                 }
-                const sourceFile = files.getSourceFile(fileName);
-                if (sourceFile?.virtualFile) {
-                    return ts.ScriptKind.Deferred;
+                const sourceFile = files.get(fileNameToFileId(fileName));
+                if (sourceFile?.generated) {
+                    const tsCode = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
+                    if (tsCode) {
+                        return tsCode.scriptKind;
+                    }
                 }
                 switch (path.extname(fileName)) {
                     case '.js':
@@ -202,35 +199,40 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             getScriptVersion,
             getScriptSnapshot,
         };
-        return languageServiceHost;
-        function syncSourceFile(tsFileName) {
-            for (const language of languages) {
-                const sourceFileName = language.typescript?.resolveSourceFileName(tsFileName);
-                if (sourceFileName) {
-                    files.getSourceFile(sourceFileName); // trigger sync
-                }
-            }
+        return {
+            languageServiceHost,
+            getExtraScript,
+        };
+        function getExtraScript(fileName) {
+            sync();
+            return extraScriptRegistry.get(fileName);
         }
-        function syncProject() {
+        function sync() {
             const newProjectVersion = projectHost.getProjectVersion?.();
             const shouldUpdate = newProjectVersion === undefined || newProjectVersion !== lastProjectVersion;
-            if (!shouldUpdate)
+            if (!shouldUpdate) {
                 return;
+            }
             lastProjectVersion = newProjectVersion;
+            extraScriptRegistry.clear();
             const newTsVirtualFileSnapshots = new Set();
             const newOtherVirtualFileSnapshots = new Set();
             const tsFileNamesSet = new Set();
             for (const fileName of projectHost.getScriptFileNames()) {
-                const sourceFile = files.getSourceFile(fileName);
-                if (sourceFile?.virtualFile) {
-                    for (const file of (0, language_core_2.forEachEmbeddedFile)(sourceFile.virtualFile[0])) {
-                        if (file.typescript) {
-                            newTsVirtualFileSnapshots.add(file.snapshot);
-                            tsFileNamesSet.add(file.fileName); // virtual .ts
-                        }
-                        else {
-                            newOtherVirtualFileSnapshots.add(file.snapshot);
-                        }
+                const sourceFile = files.get(fileNameToFileId(fileName));
+                if (sourceFile?.generated) {
+                    const script = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
+                    if (script) {
+                        newTsVirtualFileSnapshots.add(script.code.snapshot);
+                        tsFileNamesSet.add(fileName);
+                    }
+                    for (const extraScript of sourceFile.generated.languagePlugin.typescript?.getExtraScripts?.(fileName, sourceFile.generated.code) ?? []) {
+                        newTsVirtualFileSnapshots.add(extraScript.code.snapshot);
+                        tsFileNamesSet.add(extraScript.fileName);
+                        extraScriptRegistry.set(extraScript.fileName, extraScript);
+                    }
+                    for (const code of (0, language_core_2.forEachEmbeddedCode)(sourceFile.generated.code)) {
+                        newOtherVirtualFileSnapshots.add(code.snapshot);
                     }
                 }
                 else {
@@ -252,33 +254,48 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             }
         }
         function getScriptSnapshot(fileName) {
-            syncSourceFile(fileName);
-            const virtualFile = files.getVirtualFile(fileName)[0];
-            if (virtualFile) {
-                return virtualFile.snapshot;
+            sync();
+            if (extraScriptRegistry.has(fileName)) {
+                return extraScriptRegistry.get(fileName).code.snapshot;
             }
-            const sourceFile = files.getSourceFile(fileName);
-            if (sourceFile && !sourceFile.virtualFile) {
+            const sourceFile = files.get(fileNameToFileId(fileName));
+            if (sourceFile?.generated) {
+                const script = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
+                if (script) {
+                    return script.code.snapshot;
+                }
+            }
+            else if (sourceFile) {
                 return sourceFile.snapshot;
             }
         }
         function getScriptVersion(fileName) {
-            syncSourceFile(fileName);
+            sync();
             if (!scriptVersions.has(fileName)) {
                 scriptVersions.set(fileName, { lastVersion: 0, map: new WeakMap() });
             }
             const version = scriptVersions.get(fileName);
-            const virtualFile = files.getVirtualFile(fileName)[0];
-            if (virtualFile) {
-                if (!version.map.has(virtualFile.snapshot)) {
-                    version.map.set(virtualFile.snapshot, version.lastVersion++);
+            if (extraScriptRegistry.has(fileName)) {
+                const snapshot = extraScriptRegistry.get(fileName).code.snapshot;
+                if (!version.map.has(snapshot)) {
+                    version.map.set(snapshot, version.lastVersion++);
+                }
+                return version.map.get(snapshot).toString();
+            }
+            const sourceFile = files.get(fileNameToFileId(fileName));
+            if (sourceFile?.generated) {
+                const script = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
+                if (script) {
+                    if (!version.map.has(script.code.snapshot)) {
+                        version.map.set(script.code.snapshot, version.lastVersion++);
+                    }
+                    return version.map.get(script.code.snapshot).toString();
                 }
-                return version.map.get(virtualFile.snapshot).toString();
             }
             const isOpenedFile = !!projectHost.getScriptSnapshot(fileName);
             if (isOpenedFile) {
-                const sourceFile = files.getSourceFile(fileName);
-                if (sourceFile && !sourceFile.virtualFile) {
+                const sourceFile = files.get(fileNameToFileId(fileName));
+                if (sourceFile && !sourceFile.generated) {
                     if (!version.map.has(sourceFile.snapshot)) {
                         version.map.set(sourceFile.snapshot, version.lastVersion++);
                     }
@@ -290,27 +307,17 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             }
             return '';
         }
-        function getVirtualFileDirectories(dirName) {
-            const names = new Set();
-            for (const fileName of tsFileRegistry.keys()) {
-                if (fileName.toLowerCase().startsWith(dirName.toLowerCase())) {
-                    const path = fileName.substring(dirName.length);
-                    if (path.indexOf('/') >= 0) {
-                        names.add(path.split('/')[0]);
-                    }
-                }
-            }
-            return [...names];
-        }
     }
 }
 exports.createLanguage = createLanguage;
 function setEquals(a, b) {
-    if (a.size !== b.size)
+    if (a.size !== b.size) {
         return false;
+    }
     for (const item of a) {
-        if (!b.has(item))
+        if (!b.has(item)) {
             return false;
+        }
     }
     return true;
 }

package/lib/protocol/createSys.d.ts

@@ -1,6 +1,6 @@
-import type { ServiceEnvironment, Disposable } from '@volar/language-service';
-import type * as ts from 'typescript/lib/tsserverlibrary';
-export declare function createSys(ts: typeof import('typescript/lib/tsserverlibrary'), env: ServiceEnvironment, currentDirectory: string): ts.System & {
+import type { ServiceEnvironment, Disposable, TypeScriptProjectHost } from '@volar/language-service';
+import type * as ts from 'typescript';
+export declare function createSys(ts: typeof import('typescript'), env: ServiceEnvironment, projectHost: TypeScriptProjectHost): ts.System & {
     version: number;
     sync(): Promise<number>;
 } & Disposable;

package/lib/protocol/createSys.js

@@ -4,9 +4,9 @@ exports.createSys = void 0;
 const path = require("path-browserify");
 const utilities_1 = require("../typescript/utilities");
 let currentCwd = '';
-function createSys(ts, env, currentDirectory) {
+function createSys(ts, env, projectHost) {
     let version = 0;
-    const rootPath = currentDirectory;
+    const rootPath = projectHost.getCurrentDirectory();
     const sys = ts.sys;
     const root = {
         dirs: new Map(),
@@ -16,7 +16,7 @@ function createSys(ts, env, currentDirectory) {
     const promises = new Set();
     const fileWatcher = env.onDidChangeWatchedFiles?.(({ changes }) => {
         for (const change of changes) {
-            const fileName = env.uriToFileName(change.uri);
+            const fileName = env.typescript.uriToFileName(change.uri);
             const dirName = path.dirname(fileName);
             const baseName = path.basename(fileName);
             const dir = getDir(dirName);
@@ -107,7 +107,7 @@ function createSys(ts, env, currentDirectory) {
         const dir = getDir(dirName);
         if (dir.exists === undefined) {
             dir.exists = false;
-            const result = env.fs?.stat(env.fileNameToUri(dirName));
+            const result = env.fs?.stat(env.typescript.fileNameToUri(dirName));
             if (typeof result === 'object' && 'then' in result) {
                 const promise = result;
                 promises.add(promise);
@@ -148,7 +148,7 @@ function createSys(ts, env, currentDirectory) {
         return exists();
     }
     function handleStat(fileName, file) {
-        const result = env.fs?.stat(env.fileNameToUri(fileName));
+        const result = env.fs?.stat(env.typescript.fileNameToUri(fileName));
         if (typeof result === 'object' && 'then' in result) {
             const promise = result;
             promises.add(promise);
@@ -184,7 +184,7 @@ function createSys(ts, env, currentDirectory) {
     }
     function readDirectory(dirName, extensions, excludes, includes, depth) {
         dirName = resolvePath(dirName);
-        const matches = (0, utilities_1.matchFiles)(dirName, extensions, excludes, includes, sys?.useCaseSensitiveFileNames ?? false, rootPath, depth, (dirPath) => {
+        const matches = (0, utilities_1.matchFiles)(dirName, extensions, excludes, includes, sys?.useCaseSensitiveFileNames ?? false, rootPath, depth, dirPath => {
             dirPath = resolvePath(dirPath);
             readDirectoryWorker(dirPath);
             const dir = getDir(dirPath);
@@ -205,7 +205,7 @@ function createSys(ts, env, currentDirectory) {
             return;
         }
         file.requestedText = true;
-        const uri = env.fileNameToUri(fileName);
+        const uri = env.typescript.fileNameToUri(fileName);
         const result = env.fs?.readFile(uri, encoding);
         if (typeof result === 'object' && 'then' in result) {
             const promise = result;
@@ -231,11 +231,11 @@ function createSys(ts, env, currentDirectory) {
             return;
         }
         dir.requestedRead = true;
-        const result = env.fs?.readDirectory(env.fileNameToUri(dirName || '.'));
+        const result = env.fs?.readDirectory(env.typescript.fileNameToUri(dirName || '.'));
         if (typeof result === 'object' && 'then' in result) {
             const promise = result;
             promises.add(promise);
-            result.then((result) => {
+            result.then(result => {
                 promises.delete(promise);
                 if (onReadDirectoryResult(dirName, dir, result)) {
                     version++;
@@ -253,11 +253,11 @@ function createSys(ts, env, currentDirectory) {
         for (const [name, _fileType] of result) {
             let fileType = _fileType;
             if (fileType === 64) {
-                const stat = env.fs?.stat(env.fileNameToUri(dirName + '/' + name));
+                const stat = env.fs?.stat(env.typescript.fileNameToUri(dirName + '/' + name));
                 if (typeof stat === 'object' && 'then' in stat) {
                     const promise = stat;
                     promises.add(promise);
-                    stat.then((stat) => {
+                    stat.then(stat => {
                         promises.delete(promise);
                         if (stat?.type === 1) {
                             let file = dir.files.get(name);

package/lib/quickstart/createAsyncLanguageServicePlugin.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript';
+import { LanguagePlugin } from '@volar/language-core';
+export declare function createAsyncLanguageServicePlugin(extensions: string[], scriptKind: ts.ScriptKind, loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<LanguagePlugin[]>): ts.server.PluginModuleFactory;

package/lib/quickstart/createAsyncLanguageServicePlugin.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsyncLanguageServicePlugin = void 0;
+const decorateLanguageService_1 = require("../node/decorateLanguageService");
+const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
+const language_core_1 = require("@volar/language-core");
+const createLanguageServicePlugin_1 = require("./createLanguageServicePlugin");
+const externalFiles = new WeakMap();
+const decoratedLanguageServices = new WeakSet();
+const decoratedLanguageServiceHosts = new WeakSet();
+function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePlugins) {
+    return modules => {
+        const { typescript: ts } = modules;
+        const pluginModule = {
+            create(info) {
+                if (!decoratedLanguageServices.has(info.languageService)
+                    && !decoratedLanguageServiceHosts.has(info.languageServiceHost)) {
+                    decoratedLanguageServices.add(info.languageService);
+                    decoratedLanguageServiceHosts.add(info.languageServiceHost);
+                    const emptySnapshot = ts.ScriptSnapshot.fromString('');
+                    const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
+                    const getScriptVersion = info.languageServiceHost.getScriptVersion.bind(info.languageServiceHost);
+                    const getScriptKind = info.languageServiceHost.getScriptKind?.bind(info.languageServiceHost);
+                    const getProjectVersion = info.languageServiceHost.getProjectVersion?.bind(info.languageServiceHost);
+                    let initialized = false;
+                    info.languageServiceHost.getScriptSnapshot = fileName => {
+                        if (!initialized && extensions.some(ext => fileName.endsWith(ext))) {
+                            return emptySnapshot;
+                        }
+                        return getScriptSnapshot(fileName);
+                    };
+                    info.languageServiceHost.getScriptVersion = fileName => {
+                        if (!initialized && extensions.some(ext => fileName.endsWith(ext))) {
+                            return 'initializing...';
+                        }
+                        return getScriptVersion(fileName);
+                    };
+                    if (getScriptKind) {
+                        info.languageServiceHost.getScriptKind = fileName => {
+                            if (!initialized && extensions.some(ext => fileName.endsWith(ext))) {
+                                return scriptKind; // TODO: bypass upstream bug
+                            }
+                            return getScriptKind(fileName);
+                        };
+                    }
+                    if (getProjectVersion) {
+                        info.languageServiceHost.getProjectVersion = () => {
+                            if (!initialized) {
+                                return getProjectVersion() + ',initializing...';
+                            }
+                            return getProjectVersion();
+                        };
+                    }
+                    loadLanguagePlugins(ts, info).then(languagePlugins => {
+                        const files = (0, language_core_1.createFileRegistry)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                            const snapshot = getScriptSnapshot(fileName);
+                            if (snapshot) {
+                                files.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                            }
+                            else {
+                                files.delete(fileName);
+                            }
+                        });
+                        (0, decorateLanguageService_1.decorateLanguageService)(files, info.languageService);
+                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(files, info.languageServiceHost, ts);
+                        info.project.markAsDirty();
+                        initialized = true;
+                    });
+                }
+                return info.languageService;
+            },
+            getExternalFiles(project, updateLevel = 0) {
+                if (updateLevel >= (1)
+                    || !externalFiles.has(project)) {
+                    const oldFiles = externalFiles.get(project);
+                    const newFiles = (0, decorateLanguageServiceHost_1.searchExternalFiles)(ts, project, extensions);
+                    externalFiles.set(project, newFiles);
+                    if (oldFiles && !(0, createLanguageServicePlugin_1.arrayItemsEqual)(oldFiles, newFiles)) {
+                        project.refreshDiagnostics();
+                    }
+                }
+                return externalFiles.get(project);
+            },
+        };
+        return pluginModule;
+    };
+}
+exports.createAsyncLanguageServicePlugin = createAsyncLanguageServicePlugin;
+//# sourceMappingURL=createAsyncLanguageServicePlugin.js.map

package/lib/quickstart/createLanguageServicePlugin.d.ts

@@ -0,0 +1,4 @@
+import type * as ts from 'typescript';
+import { LanguagePlugin } from '@volar/language-core';
+export declare function createLanguageServicePlugin(loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => LanguagePlugin[]): ts.server.PluginModuleFactory;
+export declare function arrayItemsEqual(a: string[], b: string[]): boolean;

package/lib/quickstart/createLanguageServicePlugin.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayItemsEqual = exports.createLanguageServicePlugin = void 0;
+const decorateLanguageService_1 = require("../node/decorateLanguageService");
+const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
+const language_core_1 = require("@volar/language-core");
+const externalFiles = new WeakMap();
+const projectExternalFileExtensions = new WeakMap();
+const decoratedLanguageServices = new WeakSet();
+const decoratedLanguageServiceHosts = new WeakSet();
+function createLanguageServicePlugin(loadLanguagePlugins) {
+    return modules => {
+        const { typescript: ts } = modules;
+        const pluginModule = {
+            create(info) {
+                if (!decoratedLanguageServices.has(info.languageService)
+                    && !decoratedLanguageServiceHosts.has(info.languageServiceHost)) {
+                    decoratedLanguageServices.add(info.languageService);
+                    decoratedLanguageServiceHosts.add(info.languageServiceHost);
+                    const languagePlugins = loadLanguagePlugins(ts, info);
+                    const extensions = languagePlugins
+                        .map(plugin => plugin.typescript?.extraFileExtensions.map(ext => '.' + ext.extension) ?? [])
+                        .flat();
+                    projectExternalFileExtensions.set(info.project, extensions);
+                    const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
+                    const files = (0, language_core_1.createFileRegistry)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                        const snapshot = getScriptSnapshot(fileName);
+                        if (snapshot) {
+                            files.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                        }
+                        else {
+                            files.delete(fileName);
+                        }
+                    });
+                    (0, decorateLanguageService_1.decorateLanguageService)(files, info.languageService);
+                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(files, info.languageServiceHost, ts);
+                }
+                return info.languageService;
+            },
+            getExternalFiles(project, updateLevel = 0) {
+                if (updateLevel >= (1)
+                    || !externalFiles.has(project)) {
+                    const oldFiles = externalFiles.get(project);
+                    const newFiles = (0, decorateLanguageServiceHost_1.searchExternalFiles)(ts, project, projectExternalFileExtensions.get(project));
+                    externalFiles.set(project, newFiles);
+                    if (oldFiles && !arrayItemsEqual(oldFiles, newFiles)) {
+                        project.refreshDiagnostics();
+                    }
+                }
+                return externalFiles.get(project);
+            },
+        };
+        return pluginModule;
+    };
+}
+exports.createLanguageServicePlugin = createLanguageServicePlugin;
+function arrayItemsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    const set = new Set(a);
+    for (const file of b) {
+        if (!set.has(file)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.arrayItemsEqual = arrayItemsEqual;
+//# sourceMappingURL=createLanguageServicePlugin.js.map