@volar/typescript 2.0.0-alpha.0 → 2.0.0-alpha.10

package/lib/node/decorateLanguageServiceHost.js

@@ -116,12 +116,12 @@ function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts, exts
             const snapshot = getScriptSnapshot(fileName);
             if (snapshot) {
                 extraProjectVersion++;
-                const sourceFile = virtualFiles.updateSourceFile(fileName, snapshot, (0, language_service_1.resolveCommonLanguageId)(fileName));
+                const sourceFile = virtualFiles.updateSourceFile(fileName, (0, language_service_1.resolveCommonLanguageId)(fileName), snapshot);
                 if (sourceFile.virtualFile) {
                     const text = snapshot.getText(0, snapshot.getLength());
                     let patchedText = text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
                     for (const file of (0, language_core_1.forEachEmbeddedFile)(sourceFile.virtualFile[0])) {
-                        const ext = file.id.substring(fileName.length);
+                        const ext = file.fileName.substring(fileName.length);
                         if (file.typescript && (ext === '.d.ts' || ext.match(/^\.(js|ts)x?$/))) {
                             extension = ext;
                             scriptKind = file.typescript.scriptKind;

package/lib/node/decorateProgram.d.ts

@@ -0,0 +1,3 @@
+import type { FileProvider } from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function decorateProgram(files: FileProvider, program: ts.Program): void;

package/lib/node/decorateProgram.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateProgram = void 0;
+const utils_1 = require("./utils");
+const transform_1 = require("./transform");
+function decorateProgram(files, program) {
+    const emit = program.emit;
+    // for tsc --noEmit
+    const getSyntacticDiagnostics = program.getSyntacticDiagnostics;
+    const getSemanticDiagnostics = program.getSemanticDiagnostics;
+    const getGlobalDiagnostics = program.getGlobalDiagnostics;
+    // for tsc --noEmit --watch
+    // @ts-ignore
+    const getBindAndCheckDiagnostics = program.getBindAndCheckDiagnostics;
+    program.emit = (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
+        const result = emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
+        return {
+            emitSkipped: result.emitSkipped,
+            emittedFiles: result.emittedFiles,
+            diagnostics: result.diagnostics
+                .map(d => (0, transform_1.transformDiagnostic)(files, d))
+                .filter(utils_1.notEmpty),
+        };
+    };
+    program.getSyntacticDiagnostics = (sourceFile, cancellationToken) => {
+        return getSyntacticDiagnostics(sourceFile, cancellationToken)
+            .map(d => (0, transform_1.transformDiagnostic)(files, d))
+            .filter(utils_1.notEmpty);
+    };
+    program.getSemanticDiagnostics = (sourceFile, cancellationToken) => {
+        return getSemanticDiagnostics(sourceFile, cancellationToken)
+            .map(d => (0, transform_1.transformDiagnostic)(files, d))
+            .filter(utils_1.notEmpty);
+    };
+    program.getGlobalDiagnostics = (cancellationToken) => {
+        return getGlobalDiagnostics(cancellationToken)
+            .map(d => (0, transform_1.transformDiagnostic)(files, d))
+            .filter(utils_1.notEmpty);
+    };
+    // @ts-ignore
+    program.getBindAndCheckDiagnostics = (sourceFile, cancellationToken) => {
+        return getBindAndCheckDiagnostics(sourceFile, cancellationToken)
+            .map(d => (0, transform_1.transformDiagnostic)(files, d))
+            .filter(utils_1.notEmpty);
+    };
+}
+exports.decorateProgram = decorateProgram;
+//# sourceMappingURL=decorateProgram.js.map

package/lib/node/proxyCreateProgram.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { LanguagePlugin } from '@volar/language-core';
+export declare function proxyCreateProgram(ts: typeof import('typescript'), original: typeof ts['createProgram'], extensions: string[], getLanguagePlugins: (ts: typeof import('typescript/lib/tsserverlibrary'), options: ts.CreateProgramOptions) => LanguagePlugin[]): typeof import("typescript").createProgram;

package/lib/node/proxyCreateProgram.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyCreateProgram = void 0;
+const decorateProgram_1 = require("./decorateProgram");
+const language_core_1 = require("@volar/language-core");
+function proxyCreateProgram(ts, original, extensions, getLanguagePlugins) {
+    return new Proxy(original, {
+        apply: (target, thisArg, args) => {
+            const options = args[0];
+            assert(!!options.host, '!!options.host');
+            const sourceFileToSnapshotMap = new WeakMap();
+            const files = (0, language_core_1.createFileProvider)(getLanguagePlugins(ts, options), ts.sys.useCaseSensitiveFileNames, fileName => {
+                let snapshot;
+                assert(originalSourceFiles.has(fileName), `originalSourceFiles.has(${fileName})`);
+                const sourceFile = originalSourceFiles.get(fileName);
+                if (sourceFile) {
+                    snapshot = sourceFileToSnapshotMap.get(sourceFile);
+                    if (!snapshot) {
+                        snapshot = {
+                            getChangeRange() {
+                                return undefined;
+                            },
+                            getLength() {
+                                return sourceFile.text.length;
+                            },
+                            getText(start, end) {
+                                return sourceFile.text.substring(start, end);
+                            },
+                        };
+                        sourceFileToSnapshotMap.set(sourceFile, snapshot);
+                    }
+                }
+                if (snapshot) {
+                    files.updateSourceFile(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                }
+                else {
+                    files.deleteSourceFile(fileName);
+                }
+            });
+            const originalSourceFiles = new Map();
+            const parsedSourceFiles = new WeakMap();
+            const arbitraryExtensions = extensions.map(ext => `.d${ext}.ts`);
+            const originalHost = options.host;
+            const moduleResolutionHost = {
+                ...originalHost,
+                fileExists(fileName) {
+                    for (let i = 0; i < arbitraryExtensions.length; i++) {
+                        if (fileName.endsWith(arbitraryExtensions[i])) {
+                            return originalHost.fileExists(fileName.slice(0, -arbitraryExtensions[i].length) + extensions[i]);
+                        }
+                    }
+                    return originalHost.fileExists(fileName);
+                },
+            };
+            options.host = { ...originalHost };
+            options.options.allowArbitraryExtensions = true;
+            options.host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+                const originalSourceFile = originalHost.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+                originalSourceFiles.set(fileName, originalSourceFile);
+                if (originalSourceFile && extensions.some(ext => fileName.endsWith(ext))) {
+                    let sourceFile2 = parsedSourceFiles.get(originalSourceFile);
+                    if (!sourceFile2) {
+                        const sourceFile = files.getSourceFile(fileName);
+                        assert(!!sourceFile, '!!sourceFile');
+                        let patchedText = originalSourceFile.text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
+                        let scriptKind = ts.ScriptKind.TS;
+                        const virtualFile = sourceFile.virtualFile?.[0];
+                        if (virtualFile) {
+                            for (const file of (0, language_core_1.forEachEmbeddedFile)(virtualFile)) {
+                                if (file.typescript) {
+                                    scriptKind = file.typescript.scriptKind;
+                                    patchedText += file.snapshot.getText(0, file.snapshot.getLength());
+                                    break;
+                                }
+                            }
+                        }
+                        sourceFile2 = ts.createSourceFile(sourceFile.fileName, patchedText, 99, true, scriptKind);
+                        // @ts-expect-error
+                        sourceFile2.version = originalSourceFile.version;
+                        parsedSourceFiles.set(originalSourceFile, sourceFile2);
+                    }
+                    return sourceFile2;
+                }
+                return originalSourceFile;
+            };
+            options.host.resolveModuleNameLiterals = (moduleNames, containingFile, redirectedReference, options) => {
+                return moduleNames.map(name => {
+                    return resolveModuleName(name.text, containingFile, options, redirectedReference);
+                });
+            };
+            options.host.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
+                return moduleNames.map(name => {
+                    return resolveModuleName(name, containingFile, options, redirectedReference).resolvedModule;
+                });
+            };
+            const program = Reflect.apply(target, thisArg, [options]);
+            (0, decorateProgram_1.decorateProgram)(files, program);
+            return program;
+            function resolveModuleName(name, containingFile, options, redirectedReference) {
+                const resolved = ts.resolveModuleName(name, containingFile, options, moduleResolutionHost, originalHost.getModuleResolutionCache?.(), redirectedReference);
+                if (resolved.resolvedModule) {
+                    for (let i = 0; i < arbitraryExtensions.length; i++) {
+                        if (resolved.resolvedModule.resolvedFileName.endsWith(arbitraryExtensions[i])) {
+                            const sourceFileName = resolved.resolvedModule.resolvedFileName.slice(0, -arbitraryExtensions[i].length) + extensions[i];
+                            resolved.resolvedModule.resolvedFileName = sourceFileName;
+                            resolved.resolvedModule.extension = extensions[i];
+                        }
+                    }
+                }
+                return resolved;
+            }
+        },
+    });
+}
+exports.proxyCreateProgram = proxyCreateProgram;
+function assert(condition, message) {
+    if (!condition) {
+        console.error(message);
+        throw new Error(message);
+    }
+}
+//# sourceMappingURL=proxyCreateProgram.js.map

package/lib/node/transform.d.ts

@@ -0,0 +1,10 @@
+import { FileProvider, CodeInformation } from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function transformCallHierarchyItem(files: FileProvider, item: ts.CallHierarchyItem, filter: (data: CodeInformation) => boolean): ts.CallHierarchyItem;
+export declare function transformDiagnostic<T extends ts.Diagnostic>(files: FileProvider, diagnostic: T): T | undefined;
+export declare function transformFileTextChanges(files: FileProvider, changes: ts.FileTextChanges, filter: (data: CodeInformation) => boolean): ts.FileTextChanges | undefined;
+export declare function transformDocumentSpan<T extends ts.DocumentSpan>(files: FileProvider, documentSpan: T, filter: (data: CodeInformation) => boolean, shouldFallback?: boolean): T | undefined;
+export declare function transformSpan(files: FileProvider, fileName: string | undefined, textSpan: ts.TextSpan | undefined, filter: (data: CodeInformation) => boolean): {
+    fileName: string;
+    textSpan: ts.TextSpan;
+} | undefined;

package/lib/node/transform.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSpan = exports.transformDocumentSpan = exports.transformFileTextChanges = exports.transformDiagnostic = exports.transformCallHierarchyItem = void 0;
+const language_core_1 = require("@volar/language-core");
+const utils_1 = require("./utils");
+const transformedDiagnostics = new WeakMap();
+function transformCallHierarchyItem(files, item, filter) {
+    const span = transformSpan(files, item.file, item.span, filter);
+    const selectionSpan = transformSpan(files, item.file, item.selectionSpan, filter);
+    return {
+        ...item,
+        span: span?.textSpan ?? { start: 0, length: 0 },
+        selectionSpan: selectionSpan?.textSpan ?? { start: 0, length: 0 },
+    };
+}
+exports.transformCallHierarchyItem = transformCallHierarchyItem;
+function transformDiagnostic(files, diagnostic) {
+    if (!transformedDiagnostics.has(diagnostic)) {
+        transformedDiagnostics.set(diagnostic, undefined);
+        const { relatedInformation } = diagnostic;
+        if (relatedInformation) {
+            diagnostic.relatedInformation = relatedInformation
+                .map(d => transformDiagnostic(files, d))
+                .filter(utils_1.notEmpty);
+        }
+        if (diagnostic.file !== undefined
+            && diagnostic.start !== undefined
+            && diagnostic.length !== undefined) {
+            const [virtualFile, sourceFile, map] = (0, utils_1.getVirtualFileAndMap)(files, diagnostic.file.fileName);
+            if (virtualFile) {
+                const sourceRange = transformRange(sourceFile, map, diagnostic.start, diagnostic.start + diagnostic.length, language_core_1.shouldReportDiagnostics);
+                if (sourceRange) {
+                    transformedDiagnostics.set(diagnostic, {
+                        ...diagnostic,
+                        start: sourceRange[0],
+                        length: sourceRange[1] - sourceRange[0],
+                    });
+                }
+            }
+            else {
+                transformedDiagnostics.set(diagnostic, diagnostic);
+            }
+        }
+        else {
+            transformedDiagnostics.set(diagnostic, diagnostic);
+        }
+    }
+    return transformedDiagnostics.get(diagnostic);
+}
+exports.transformDiagnostic = transformDiagnostic;
+function transformFileTextChanges(files, changes, filter) {
+    const [_, source] = (0, utils_1.getVirtualFileAndMap)(files, changes.fileName);
+    if (source) {
+        return {
+            ...changes,
+            fileName: source.fileName,
+            textChanges: changes.textChanges.map(c => {
+                const span = transformSpan(files, changes.fileName, c.span, filter);
+                if (span) {
+                    return {
+                        ...c,
+                        span: span.textSpan,
+                    };
+                }
+            }).filter(utils_1.notEmpty),
+        };
+    }
+    else {
+        return changes;
+    }
+}
+exports.transformFileTextChanges = transformFileTextChanges;
+function transformDocumentSpan(files, documentSpan, filter, shouldFallback) {
+    let textSpan = transformSpan(files, documentSpan.fileName, documentSpan.textSpan, filter);
+    if (!textSpan && shouldFallback) {
+        const [virtualFile, source] = (0, utils_1.getVirtualFileAndMap)(files, documentSpan.fileName);
+        if (virtualFile) {
+            textSpan = {
+                fileName: source.fileName,
+                textSpan: { start: 0, length: 0 },
+            };
+        }
+    }
+    if (!textSpan)
+        return;
+    const contextSpan = transformSpan(files, documentSpan.fileName, documentSpan.contextSpan, filter);
+    const originalTextSpan = transformSpan(files, documentSpan.originalFileName, documentSpan.originalTextSpan, filter);
+    const originalContextSpan = transformSpan(files, documentSpan.originalFileName, documentSpan.originalContextSpan, filter);
+    return {
+        ...documentSpan,
+        fileName: textSpan.fileName,
+        textSpan: textSpan.textSpan,
+        contextSpan: contextSpan?.textSpan,
+        originalFileName: originalTextSpan?.fileName,
+        originalTextSpan: originalTextSpan?.textSpan,
+        originalContextSpan: originalContextSpan?.textSpan,
+    };
+}
+exports.transformDocumentSpan = transformDocumentSpan;
+function transformSpan(files, fileName, textSpan, filter) {
+    if (!fileName)
+        return;
+    if (!textSpan)
+        return;
+    const [virtualFile, sourceFile, map] = (0, utils_1.getVirtualFileAndMap)(files, fileName);
+    if (virtualFile) {
+        const sourceRange = transformRange(sourceFile, map, textSpan.start, textSpan.start + textSpan.length, filter);
+        if (sourceRange) {
+            return {
+                fileName: sourceFile.fileName,
+                textSpan: {
+                    start: sourceRange[0],
+                    length: sourceRange[1] - sourceRange[0],
+                },
+            };
+        }
+    }
+    else {
+        return {
+            fileName,
+            textSpan,
+        };
+    }
+}
+exports.transformSpan = transformSpan;
+function transformRange(sourceFile, map, start, end, filter) {
+    for (const sourceStart of map.getSourceOffsets(start - sourceFile.snapshot.getLength())) {
+        if (filter(sourceStart[1].data)) {
+            for (const sourceEnd of map.getSourceOffsets(end - sourceFile.snapshot.getLength())) {
+                if (sourceEnd[0] >= sourceStart[0] && filter(sourceEnd[1].data)) {
+                    return [sourceStart[0], sourceEnd[0]];
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=transform.js.map

package/lib/node/utils.d.ts

@@ -0,0 +1,3 @@
+import { FileProvider } from '@volar/language-core';
+export declare function notEmpty<T>(value: T | null | undefined): value is T;
+export declare function getVirtualFileAndMap(files: FileProvider, fileName: string): readonly [import("@volar/language-core").VirtualFile, import("@volar/language-core").SourceFile, import("@volar/language-core").SourceMap<import("@volar/language-core").CodeInformation>] | readonly [undefined, undefined, undefined];

package/lib/node/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVirtualFileAndMap = exports.notEmpty = void 0;
+const language_core_1 = require("@volar/language-core");
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+exports.notEmpty = notEmpty;
+function getVirtualFileAndMap(files, fileName) {
+    const sourceFile = files.getSourceFile(fileName);
+    if (sourceFile?.virtualFile) {
+        for (const virtualFile of (0, language_core_1.forEachEmbeddedFile)(sourceFile.virtualFile[0])) {
+            const ext = virtualFile.fileName.substring(fileName.length);
+            if (virtualFile.typescript && (ext === '.d.ts' || ext.match(/^\.(js|ts)x?$/))) {
+                for (const map of files.getMaps(virtualFile)) {
+                    if (map[1][0] === sourceFile.snapshot) {
+                        return [virtualFile, sourceFile, map[1][1]];
+                    }
+                }
+            }
+        }
+    }
+    return [undefined, undefined, undefined];
+}
+exports.getVirtualFileAndMap = getVirtualFileAndMap;
+//# sourceMappingURL=utils.js.map

package/lib/protocol/createProject.js

@@ -8,8 +8,7 @@ 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, (id) => {
-        const fileName = projectHost.getFileName(id);
+    const files = (0, language_core_1.createFileProvider)(languages, sys.useCaseSensitiveFileNames, fileName => {
         // opened files
         let snapshot = projectHost.getScriptSnapshot(fileName);
         if (!snapshot) {
@@ -29,10 +28,10 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             snapshot = fsFileSnapshots.get(fileName)?.[1];
         }
         if (snapshot) {
-            files.updateSourceFile(id, snapshot, projectHost.getLanguageId(id));
+            files.updateSourceFile(fileName, projectHost.getLanguageId(fileName), snapshot);
         }
         else {
-            files.deleteSourceFile(id);
+            files.deleteSourceFile(fileName);
         }
     });
     let languageServiceHost = createLanguageServiceHost();
@@ -95,7 +94,6 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             ...sys,
             getCurrentDirectory: projectHost.getCurrentDirectory,
             getCompilationSettings: projectHost.getCompilationSettings,
-            getCancellationToken: projectHost.getCancellationToken,
             getLocalizedDiagnosticMessages: projectHost.getLocalizedDiagnosticMessages,
             getProjectReferences: projectHost.getProjectReferences,
             getDefaultLibFileName: (options) => {
@@ -153,9 +151,9 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
                     };
                 }, sys?.realpath ? (path => sys.realpath(path)) : (path => path));
                 matches = matches.map(match => {
-                    const [_, source] = files.getVirtualFile(projectHost.getFileId(match));
+                    const [_, source] = files.getVirtualFile(match);
                     if (source) {
-                        return projectHost.getFileName(source.id);
+                        return source.fileName;
                     }
                     return match;
                 });
@@ -174,11 +172,11 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             },
             getScriptKind(fileName) {
                 syncSourceFile(fileName);
-                const virtualFile = files.getVirtualFile(projectHost.getFileId(fileName))[0];
+                const virtualFile = files.getVirtualFile(fileName)[0];
                 if (virtualFile?.typescript) {
                     return virtualFile.typescript.scriptKind;
                 }
-                const sourceFile = files.getSourceFile(projectHost.getFileId(fileName));
+                const sourceFile = files.getSourceFile(fileName);
                 if (sourceFile?.virtualFile) {
                     return ts.ScriptKind.Deferred;
                 }
@@ -209,7 +207,7 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             for (const language of languages) {
                 const sourceFileName = language.typescript?.resolveSourceFileName(tsFileName);
                 if (sourceFileName) {
-                    files.getSourceFile(projectHost.getFileId(sourceFileName)); // trigger sync
+                    files.getSourceFile(sourceFileName); // trigger sync
                 }
             }
         }
@@ -223,13 +221,12 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             const newOtherVirtualFileSnapshots = new Set();
             const tsFileNamesSet = new Set();
             for (const fileName of projectHost.getScriptFileNames()) {
-                const uri = projectHost.getFileId(fileName);
-                const sourceFile = files.getSourceFile(uri);
+                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(projectHost.getFileName(file.id)); // virtual .ts
+                            tsFileNamesSet.add(file.fileName); // virtual .ts
                         }
                         else {
                             newOtherVirtualFileSnapshots.add(file.snapshot);
@@ -256,12 +253,11 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
         }
         function getScriptSnapshot(fileName) {
             syncSourceFile(fileName);
-            const uri = projectHost.getFileId(fileName);
-            const virtualFile = files.getVirtualFile(uri)[0];
+            const virtualFile = files.getVirtualFile(fileName)[0];
             if (virtualFile) {
                 return virtualFile.snapshot;
             }
-            const sourceFile = files.getSourceFile(uri);
+            const sourceFile = files.getSourceFile(fileName);
             if (sourceFile && !sourceFile.virtualFile) {
                 return sourceFile.snapshot;
             }
@@ -272,7 +268,7 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
                 scriptVersions.set(fileName, { lastVersion: 0, map: new WeakMap() });
             }
             const version = scriptVersions.get(fileName);
-            const virtualFile = files.getVirtualFile(projectHost.getFileId(fileName))[0];
+            const virtualFile = files.getVirtualFile(fileName)[0];
             if (virtualFile) {
                 if (!version.map.has(virtualFile.snapshot)) {
                     version.map.set(virtualFile.snapshot, version.lastVersion++);
@@ -281,7 +277,7 @@ function createLanguage(ts, sys, languages, configFileName, projectHost) {
             }
             const isOpenedFile = !!projectHost.getScriptSnapshot(fileName);
             if (isOpenedFile) {
-                const sourceFile = files.getSourceFile(projectHost.getFileId(fileName));
+                const sourceFile = files.getSourceFile(fileName);
                 if (sourceFile && !sourceFile.virtualFile) {
                     if (!version.map.has(sourceFile.snapshot)) {
                         version.map.set(sourceFile.snapshot, version.lastVersion++);

package/lib/protocol/getProgram.d.ts

@@ -1,6 +1,3 @@
 import { type FileProvider } from '@volar/language-core';
 import type * as ts from 'typescript/lib/tsserverlibrary';
-export declare function getProgram(ts: typeof import('typescript/lib/tsserverlibrary'), files: FileProvider, { getFileId, getFileName }: {
-    getFileId(fileName: string): string;
-    getFileName(id: string): string;
-}, ls: ts.LanguageService, sys: ts.System): ts.Program;
+export declare function getProgram(ts: typeof import('typescript/lib/tsserverlibrary'), files: FileProvider, ls: ts.LanguageService, sys: ts.System): ts.Program;

package/lib/protocol/getProgram.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProgram = void 0;
 const language_core_1 = require("@volar/language-core");
-function getProgram(ts, files, { getFileId, getFileName }, ls, sys) {
+function getProgram(ts, files, ls, sys) {
     const proxy = {
         getRootFileNames,
         emit,
@@ -50,8 +50,7 @@ function getProgram(ts, files, { getFileId, getFileName }, ls, sys) {
     }
     function getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, api) {
         if (sourceFile) {
-            const uri = getFileId(sourceFile.fileName);
-            const [virtualFile, source] = files.getVirtualFile(uri);
+            const [virtualFile, source] = files.getVirtualFile(sourceFile.fileName);
             if (virtualFile && source) {
                 if (!virtualFile.mappings.some(mapping => (0, language_core_1.isDiagnosticsEnabled)(mapping.data)))
                     return [];
@@ -79,11 +78,9 @@ function getProgram(ts, files, { getFileId, getFileName }, ls, sys) {
             if (diagnostic.file !== undefined
                 && diagnostic.start !== undefined
                 && diagnostic.length !== undefined) {
-                const uri = getFileId(diagnostic.file.fileName);
-                const [virtualFile, source] = files.getVirtualFile(uri);
+                const [virtualFile, source] = files.getVirtualFile(diagnostic.file.fileName);
                 if (virtualFile && source) {
-                    const sourceFileName = getFileName(source.id);
-                    if (sys.fileExists?.(sourceFileName) === false)
+                    if (sys.fileExists?.(source.fileName) === false)
                         continue;
                     for (const [_, [sourceSnapshot, map]] of files.getMaps(virtualFile)) {
                         if (sourceSnapshot !== source.snapshot)
@@ -94,7 +91,7 @@ function getProgram(ts, files, { getFileId, getFileName }, ls, sys) {
                             for (const end of map.getSourceOffsets(diagnostic.start + diagnostic.length)) {
                                 if (!(0, language_core_1.shouldReportDiagnostics)(end[1].data))
                                     continue;
-                                onMapping(diagnostic, sourceFileName, start[0], end[0], source.snapshot.getText(0, source.snapshot.getLength()));
+                                onMapping(diagnostic, source.fileName, start[0], end[0], source.snapshot.getText(0, source.snapshot.getLength()));
                                 break;
                             }
                             break;
@@ -118,8 +115,7 @@ function getProgram(ts, files, { getFileId, getFileName }, ls, sys) {
                 : undefined;
             if (!file) {
                 if (docText === undefined) {
-                    const uri = getFileId(fileName);
-                    const snapshot = files.getSourceFile(uri)?.snapshot;
+                    const snapshot = files.getSourceFile(fileName)?.snapshot;
                     if (snapshot) {
                         docText = snapshot.getText(0, snapshot.getLength());
                     }

package/lib/starters/createAsyncTSServerPlugin.d.ts

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

package/lib/starters/createAsyncTSServerPlugin.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsyncTSServerPlugin = void 0;
+const decorateLanguageService_1 = require("../node/decorateLanguageService");
+const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
+const language_core_1 = require("@volar/language-core");
+const createTSServerPlugin_1 = require("./createTSServerPlugin");
+const externalFiles = new WeakMap();
+function createAsyncTSServerPlugin(extensions, scriptKind, loadLanguagePlugins) {
+    return (modules) => {
+        const { typescript: ts } = modules;
+        const pluginModule = {
+            create(info) {
+                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.createFileProvider)(languagePlugins, ts.sys.useCaseSensitiveFileNames, (fileName) => {
+                        const snapshot = getScriptSnapshot(fileName);
+                        if (snapshot) {
+                            files.updateSourceFile(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                        }
+                        else {
+                            files.deleteSourceFile(fileName);
+                        }
+                    });
+                    (0, decorateLanguageService_1.decorateLanguageService)(files, info.languageService);
+                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(files, info.languageServiceHost, ts, extensions);
+                    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, createTSServerPlugin_1.arrayItemsEqual)(oldFiles, newFiles)) {
+                        project.refreshDiagnostics();
+                    }
+                }
+                return externalFiles.get(project);
+            },
+        };
+        return pluginModule;
+    };
+}
+exports.createAsyncTSServerPlugin = createAsyncTSServerPlugin;
+//# sourceMappingURL=createAsyncTSServerPlugin.js.map

package/lib/starters/createTSServerPlugin.d.ts

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