@volar/typescript 2.2.0-alpha.1 → 2.2.0-alpha.11

package/lib/node/proxyCreateProgram.d.ts

@@ -1,3 +1,3 @@
-import type * as ts from 'typescript';
 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'), options: ts.CreateProgramOptions) => LanguagePlugin[]): typeof import("typescript").createProgram;
+import type * as ts from 'typescript';
+export declare function proxyCreateProgram(ts: typeof import('typescript'), original: typeof ts['createProgram'], getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[]): typeof import("typescript").createProgram;

package/lib/node/proxyCreateProgram.js

@@ -1,117 +1,165 @@
 "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) {
+const resolveModuleName_1 = require("../resolveModuleName");
+const decorateProgram_1 = require("./decorateProgram");
+const common_1 = require("../common");
+const arrayEqual = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+};
+const objectEqual = (a, b) => {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (const key of keysA) {
+        if (a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+};
+function proxyCreateProgram(ts, original, getLanguagePlugins) {
+    const sourceFileSnapshots = new Map();
+    const parsedSourceFiles = new WeakMap();
+    let lastOptions;
+    let languagePlugins;
+    let language;
+    let moduleResolutionCache;
     return new Proxy(original, {
         apply: (target, thisArg, args) => {
             const options = args[0];
             assert(!!options.host, '!!options.host');
-            const sourceFileToSnapshotMap = new WeakMap();
-            const language = (0, language_core_1.createLanguage)(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) {
-                    language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
-                }
-                else {
-                    language.scripts.delete(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]);
+            if (!lastOptions
+                || !languagePlugins
+                || !language
+                || !arrayEqual(options.rootNames, lastOptions.rootNames)
+                || !objectEqual(options.options, lastOptions.options)) {
+                moduleResolutionCache = ts.createModuleResolutionCache(options.host.getCurrentDirectory(), options.host.getCanonicalFileName, options.options);
+                lastOptions = options;
+                languagePlugins = getLanguagePlugins(ts, options);
+                language = (0, language_core_1.createLanguage)([
+                    ...languagePlugins,
+                    common_1.fileLanguageIdProviderPlugin,
+                ], ts.sys.useCaseSensitiveFileNames, fileName => {
+                    if (!sourceFileSnapshots.has(fileName)) {
+                        const sourceFileText = originalHost.readFile(fileName);
+                        if (sourceFileText !== undefined) {
+                            sourceFileSnapshots.set(fileName, [undefined, {
+                                    getChangeRange() {
+                                        return undefined;
+                                    },
+                                    getLength() {
+                                        return sourceFileText.length;
+                                    },
+                                    getText(start, end) {
+                                        return sourceFileText.substring(start, end);
+                                    },
+                                }]);
+                        }
+                        else {
+                            sourceFileSnapshots.set(fileName, [undefined, undefined]);
                         }
                     }
-                    return originalHost.fileExists(fileName);
-                },
-            };
+                    const snapshot = sourceFileSnapshots.get(fileName)?.[1];
+                    if (snapshot) {
+                        language.scripts.set(fileName, snapshot);
+                    }
+                    else {
+                        language.scripts.delete(fileName);
+                    }
+                });
+            }
+            const originalHost = options.host;
+            const extensions = languagePlugins
+                .map(plugin => plugin.typescript?.extraFileExtensions.map(({ extension }) => `.${extension}`) ?? [])
+                .flat();
             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 sourceScript = language.scripts.get(fileName);
-                        assert(!!sourceScript, '!!sourceScript');
-                        let patchedText = originalSourceFile.text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
-                        let scriptKind = ts.ScriptKind.TS;
-                        if (sourceScript.generated?.languagePlugin.typescript) {
-                            const { getServiceScript: getScript, getExtraServiceScripts: getExtraScripts } = sourceScript.generated.languagePlugin.typescript;
-                            const serviceScript = getScript(sourceScript.generated.root);
-                            if (serviceScript) {
-                                scriptKind = serviceScript.scriptKind;
-                                patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
-                            }
-                            if (getExtraScripts) {
-                                console.warn('getExtraScripts() is not available in this use case.');
-                            }
+                if (!sourceFileSnapshots.has(fileName)
+                    || sourceFileSnapshots.get(fileName)?.[0] !== originalSourceFile) {
+                    if (originalSourceFile) {
+                        sourceFileSnapshots.set(fileName, [originalSourceFile, {
+                                getChangeRange() {
+                                    return undefined;
+                                },
+                                getLength() {
+                                    return originalSourceFile.text.length;
+                                },
+                                getText(start, end) {
+                                    return originalSourceFile.text.substring(start, end);
+                                },
+                            }]);
+                    }
+                    else {
+                        sourceFileSnapshots.set(fileName, [undefined, undefined]);
+                    }
+                }
+                if (!originalSourceFile) {
+                    return;
+                }
+                if (!parsedSourceFiles.has(originalSourceFile)) {
+                    const sourceScript = language.scripts.get(fileName);
+                    assert(!!sourceScript, '!!sourceScript');
+                    parsedSourceFiles.set(originalSourceFile, originalSourceFile);
+                    if (sourceScript.generated?.languagePlugin.typescript) {
+                        const { getServiceScript, getExtraServiceScripts } = sourceScript.generated.languagePlugin.typescript;
+                        const serviceScript = getServiceScript(sourceScript.generated.root);
+                        if (serviceScript) {
+                            let patchedText = originalSourceFile.text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
+                            let scriptKind = ts.ScriptKind.TS;
+                            scriptKind = serviceScript.scriptKind;
+                            patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
+                            const parsedSourceFile = ts.createSourceFile(fileName, patchedText, languageVersionOrOptions, undefined, scriptKind);
+                            // @ts-expect-error
+                            parsedSourceFile.version = originalSourceFile.version;
+                            parsedSourceFiles.set(originalSourceFile, parsedSourceFile);
+                        }
+                        if (getExtraServiceScripts) {
+                            console.warn('getExtraServiceScripts() is not available in this use case.');
                         }
-                        sourceFile2 = ts.createSourceFile(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);
-                });
+                return parsedSourceFiles.get(originalSourceFile);
             };
-            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]);
+            if (extensions.length) {
+                options.options.allowArbitraryExtensions = true;
+                const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, originalHost, language.plugins, fileName => language.scripts.get(fileName));
+                const resolveModuleNameLiterals = originalHost.resolveModuleNameLiterals;
+                const resolveModuleNames = originalHost.resolveModuleNames;
+                options.host.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, compilerOptions, ...rest) => {
+                    if (resolveModuleNameLiterals && moduleLiterals.every(name => !extensions.some(ext => name.text.endsWith(ext)))) {
+                        return resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, compilerOptions, ...rest);
+                    }
+                    return moduleLiterals.map(moduleLiteral => {
+                        return resolveModuleName(moduleLiteral.text, containingFile, compilerOptions, moduleResolutionCache, redirectedReference);
+                    });
+                };
+                options.host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile) => {
+                    if (resolveModuleNames && moduleNames.every(name => !extensions.some(ext => name.endsWith(ext)))) {
+                        return resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile);
+                    }
+                    return moduleNames.map(moduleName => {
+                        return resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionCache, redirectedReference).resolvedModule;
+                    });
+                };
+            }
+            const program = Reflect.apply(target, thisArg, args);
             (0, decorateProgram_1.decorateProgram)(language, program);
             // TODO: #128
-            program.__volar__ = { files: language };
+            program.__volar__ = { language };
             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;
-            }
         },
     });
 }

package/lib/node/transform.d.ts

@@ -1,7 +1,8 @@
 import { Language, CodeInformation, SourceMap, SourceScript } from '@volar/language-core';
 import type * as ts from 'typescript';
 export declare function transformCallHierarchyItem(language: Language, item: ts.CallHierarchyItem, filter: (data: CodeInformation) => boolean): ts.CallHierarchyItem;
-export declare function transformDiagnostic<T extends ts.Diagnostic>(language: Language, diagnostic: T): T | undefined;
+export declare function transformDiagnostic<T extends ts.Diagnostic>(language: Language, diagnostic: T, isTsc: boolean): T | undefined;
+export declare function fillSourceFileText(language: Language, sourceFile: ts.SourceFile): void;
 export declare function transformFileTextChanges(language: Language, changes: ts.FileTextChanges, filter: (data: CodeInformation) => boolean): ts.FileTextChanges | undefined;
 export declare function transformDocumentSpan<T extends ts.DocumentSpan>(language: Language, documentSpan: T, filter: (data: CodeInformation) => boolean, shouldFallback?: boolean): T | undefined;
 export declare function transformSpan(language: Language, fileName: string | undefined, textSpan: ts.TextSpan | undefined, filter: (data: CodeInformation) => boolean): {
@@ -12,3 +13,4 @@ export declare function transformTextChange(sourceScript: SourceScript, map: Sou
 export declare function transformTextSpan(sourceScript: SourceScript, map: SourceMap<CodeInformation>, textSpan: ts.TextSpan, filter: (data: CodeInformation) => boolean): ts.TextSpan | undefined;
 export declare function toSourceOffset(sourceScript: SourceScript, map: SourceMap, position: number, filter: (data: CodeInformation) => boolean): number | undefined;
 export declare function toGeneratedOffset(sourceScript: SourceScript, map: SourceMap, position: number, filter: (data: CodeInformation) => boolean): number | undefined;
+export declare function forEachGeneratedOffset(sourceScript: SourceScript, map: SourceMap, position: number, filter: (data: CodeInformation) => boolean): Generator<number, void, unknown>;

package/lib/node/transform.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toGeneratedOffset = exports.toSourceOffset = exports.transformTextSpan = exports.transformTextChange = exports.transformSpan = exports.transformDocumentSpan = exports.transformFileTextChanges = exports.transformDiagnostic = exports.transformCallHierarchyItem = void 0;
+exports.forEachGeneratedOffset = exports.toGeneratedOffset = exports.toSourceOffset = exports.transformTextSpan = exports.transformTextChange = exports.transformSpan = exports.transformDocumentSpan = exports.transformFileTextChanges = exports.fillSourceFileText = exports.transformDiagnostic = exports.transformCallHierarchyItem = void 0;
 const language_core_1 = require("@volar/language-core");
 const utils_1 = require("./utils");
 const transformedDiagnostics = new WeakMap();
+const transformedSourceFile = new WeakSet();
 function transformCallHierarchyItem(language, item, filter) {
     const span = transformSpan(language, item.file, item.span, filter);
     const selectionSpan = transformSpan(language, item.file, item.selectionSpan, filter);
@@ -14,13 +15,13 @@ function transformCallHierarchyItem(language, item, filter) {
     };
 }
 exports.transformCallHierarchyItem = transformCallHierarchyItem;
-function transformDiagnostic(language, diagnostic) {
+function transformDiagnostic(language, diagnostic, isTsc) {
     if (!transformedDiagnostics.has(diagnostic)) {
         transformedDiagnostics.set(diagnostic, undefined);
         const { relatedInformation } = diagnostic;
         if (relatedInformation) {
             diagnostic.relatedInformation = relatedInformation
-                .map(d => transformDiagnostic(language, d))
+                .map(d => transformDiagnostic(language, d, isTsc))
                 .filter(utils_1.notEmpty);
         }
         if (diagnostic.file !== undefined
@@ -30,6 +31,9 @@ function transformDiagnostic(language, diagnostic) {
             if (serviceScript) {
                 const sourceSpan = transformTextSpan(sourceScript, map, { start: diagnostic.start, length: diagnostic.length }, language_core_1.shouldReportDiagnostics);
                 if (sourceSpan) {
+                    if (isTsc) {
+                        fillSourceFileText(language, diagnostic.file);
+                    }
                     transformedDiagnostics.set(diagnostic, {
                         ...diagnostic,
                         start: sourceSpan.start,
@@ -48,6 +52,19 @@ function transformDiagnostic(language, diagnostic) {
     return transformedDiagnostics.get(diagnostic);
 }
 exports.transformDiagnostic = transformDiagnostic;
+// fix https://github.com/vuejs/language-tools/issues/4099 without `incremental`
+function fillSourceFileText(language, sourceFile) {
+    if (transformedSourceFile.has(sourceFile)) {
+        return;
+    }
+    transformedSourceFile.add(sourceFile);
+    const [serviceScript, sourceScript] = (0, utils_1.getServiceScript)(language, sourceFile.fileName);
+    if (serviceScript) {
+        sourceFile.text = sourceScript.snapshot.getText(0, sourceScript.snapshot.getLength())
+            + sourceFile.text.substring(sourceScript.snapshot.getLength());
+    }
+}
+exports.fillSourceFileText = fillSourceFileText;
 function transformFileTextChanges(language, changes, filter) {
     const [_, source] = (0, utils_1.getServiceScript)(language, changes.fileName);
     if (source) {
@@ -72,13 +89,10 @@ exports.transformFileTextChanges = transformFileTextChanges;
 function transformDocumentSpan(language, documentSpan, filter, shouldFallback) {
     let textSpan = transformSpan(language, documentSpan.fileName, documentSpan.textSpan, filter);
     if (!textSpan && shouldFallback) {
-        const [serviceScript] = (0, utils_1.getServiceScript)(language, documentSpan.fileName);
-        if (serviceScript) {
-            textSpan = {
-                fileName: documentSpan.fileName,
-                textSpan: { start: 0, length: 0 },
-            };
-        }
+        textSpan = {
+            fileName: documentSpan.fileName,
+            textSpan: { start: 0, length: 0 },
+        };
     }
     if (!textSpan) {
         return;
@@ -158,4 +172,12 @@ function toGeneratedOffset(sourceScript, map, position, filter) {
     }
 }
 exports.toGeneratedOffset = toGeneratedOffset;
+function* forEachGeneratedOffset(sourceScript, map, position, filter) {
+    for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+        if (filter(mapping.data)) {
+            yield generateOffset + sourceScript.snapshot.getLength();
+        }
+    }
+}
+exports.forEachGeneratedOffset = forEachGeneratedOffset;
 //# sourceMappingURL=transform.js.map

package/lib/protocol/createProject.js

@@ -5,10 +5,14 @@ const language_core_1 = require("@volar/language-core");
 const language_core_2 = require("@volar/language-core");
 const path = require("path-browserify");
 const resolveModuleName_1 = require("../resolveModuleName");
+const common_1 = require("../common");
 const scriptVersions = new Map();
 const fsFileSnapshots = new Map();
 function createTypeScriptLanguage(ts, languagePlugins, projectHost) {
-    const language = (0, language_core_1.createLanguage)(languagePlugins, projectHost.useCaseSensitiveFileNames, scriptId => {
+    const language = (0, language_core_1.createLanguage)([
+        ...languagePlugins,
+        common_1.fileLanguageIdProviderPlugin,
+    ], projectHost.useCaseSensitiveFileNames, scriptId => {
         const fileName = projectHost.scriptIdToFileName(scriptId);
         // opened files
         let snapshot = projectHost.getScriptSnapshot(fileName);
@@ -29,7 +33,7 @@ function createTypeScriptLanguage(ts, languagePlugins, projectHost) {
             snapshot = fsFileSnapshots.get(fileName)?.[1];
         }
         if (snapshot) {
-            language.scripts.set(scriptId, projectHost.getLanguageId(scriptId), snapshot);
+            language.scripts.set(scriptId, snapshot);
         }
         else {
             language.scripts.delete(scriptId);
@@ -43,7 +47,7 @@ function createTypeScriptLanguage(ts, languagePlugins, projectHost) {
     }
     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());
+        const moduleCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), languageServiceHost.useCaseSensitiveFileNames?.() ? s => s : s => s.toLowerCase(), languageServiceHost.getCompilationSettings());
         const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, languagePlugins, fileName => language.scripts.get(projectHost.fileNameToScriptId(fileName)));
         let lastSysVersion = projectHost.getSystemVersion?.();
         languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, sourceFile) => {

package/lib/quickstart/createAsyncLanguageServicePlugin.js

@@ -5,6 +5,7 @@ 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 common_1 = require("../common");
 const externalFiles = new WeakMap();
 const decoratedLanguageServices = new WeakSet();
 const decoratedLanguageServiceHosts = new WeakSet();
@@ -52,17 +53,26 @@ function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePl
                         };
                     }
                     loadLanguagePlugins(ts, info).then(languagePlugins => {
-                        const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                        const syncedScriptVersions = new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames);
+                        const language = (0, language_core_1.createLanguage)([
+                            ...languagePlugins,
+                            common_1.fileLanguageIdProviderPlugin,
+                        ], ts.sys.useCaseSensitiveFileNames, fileName => {
+                            const version = getScriptVersion(fileName);
+                            if (syncedScriptVersions.get(fileName) === version) {
+                                return;
+                            }
+                            syncedScriptVersions.set(fileName, version);
                             const snapshot = getScriptSnapshot(fileName);
                             if (snapshot) {
-                                language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                                language.scripts.set(fileName, snapshot);
                             }
                             else {
                                 language.scripts.delete(fileName);
                             }
                         });
                         (0, decorateLanguageService_1.decorateLanguageService)(language, info.languageService);
-                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(language, info.languageServiceHost, ts);
+                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
                         info.project.markAsDirty();
                         initialized = true;
                     });

package/lib/quickstart/createLanguageServicePlugin.js

@@ -4,6 +4,7 @@ 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 common_1 = require("../common");
 const externalFiles = new WeakMap();
 const projectExternalFileExtensions = new WeakMap();
 const decoratedLanguageServices = new WeakSet();
@@ -23,17 +24,27 @@ function createLanguageServicePlugin(loadLanguagePlugins) {
                         .flat();
                     projectExternalFileExtensions.set(info.project, extensions);
                     const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
-                    const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                    const getScriptVersion = info.languageServiceHost.getScriptVersion.bind(info.languageServiceHost);
+                    const syncedScriptVersions = new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames);
+                    const language = (0, language_core_1.createLanguage)([
+                        ...languagePlugins,
+                        common_1.fileLanguageIdProviderPlugin,
+                    ], ts.sys.useCaseSensitiveFileNames, fileName => {
+                        const version = getScriptVersion(fileName);
+                        if (syncedScriptVersions.get(fileName) === version) {
+                            return;
+                        }
+                        syncedScriptVersions.set(fileName, version);
                         const snapshot = getScriptSnapshot(fileName);
                         if (snapshot) {
-                            language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                            language.scripts.set(fileName, snapshot);
                         }
                         else {
                             language.scripts.delete(fileName);
                         }
                     });
                     (0, decorateLanguageService_1.decorateLanguageService)(language, info.languageService);
-                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(language, info.languageServiceHost, ts);
+                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(ts, language, info.languageServiceHost);
                 }
                 return info.languageService;
             },

package/lib/quickstart/runTsc.d.ts

@@ -1,4 +1,5 @@
 import type * as ts from 'typescript';
 import type { LanguagePlugin } from '@volar/language-core';
 export declare let getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[];
-export declare function runTsc(tscPath: string, extensions: string[], _getLanguagePlugins: typeof getLanguagePlugins): void;
+export declare let getLanguageId: (fileName: string) => string;
+export declare function runTsc(tscPath: string, extensions: string[], _getLanguagePlugins: typeof getLanguagePlugins, _getLanguageId: typeof getLanguageId): void;

package/lib/quickstart/runTsc.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTsc = exports.getLanguagePlugins = void 0;
+exports.runTsc = exports.getLanguageId = exports.getLanguagePlugins = void 0;
 const fs = require("fs");
 let getLanguagePlugins = () => [];
 exports.getLanguagePlugins = getLanguagePlugins;
-function runTsc(tscPath, extensions, _getLanguagePlugins) {
+let getLanguageId = () => 'ts';
+exports.getLanguageId = getLanguageId;
+function runTsc(tscPath, extensions, _getLanguagePlugins, _getLanguageId) {
     exports.getLanguagePlugins = _getLanguagePlugins;
+    exports.getLanguageId = _getLanguageId;
     const proxyApiPath = require.resolve('../node/proxyCreateProgram');
     const readFileSync = fs.readFileSync;
     fs.readFileSync = (...args) => {
@@ -18,10 +21,12 @@ function runTsc(tscPath, extensions, _getLanguagePlugins) {
             tsc = replace(tsc, /allSupportedExtensions = .*(?=;)/, s => s + `.concat([[${extsText}]])`);
             // proxy createProgram
             tsc = replace(tsc, /function createProgram\(.+\) {/, s => `var createProgram = require(${JSON.stringify(proxyApiPath)}).proxyCreateProgram(`
-                + `new Proxy({}, { get(_target, p, _receiver) { return eval(p); } } ), `
-                + `_createProgram, `
-                + `[${extsText}], `
-                + `require(${JSON.stringify(__filename)}).getLanguagePlugins`
+                + [
+                    `new Proxy({}, { get(_target, p, _receiver) { return eval(p); } } )`,
+                    `_createProgram`,
+                    `require(${JSON.stringify(__filename)}).getLanguagePlugins`,
+                    `require(${JSON.stringify(__filename)}).getLanguageId`,
+                ].join(', ')
                 + `);\n`
                 + s.replace('createProgram', '_createProgram'));
             return tsc;

package/lib/resolveModuleName.d.ts

@@ -1,3 +1,3 @@
 import type { LanguagePlugin, SourceScript } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare function createResolveModuleName(ts: typeof import('typescript'), languageServiceHost: ts.LanguageServiceHost, languagePlugins: LanguagePlugin<any>[], getSourceScript: (fileName: string) => SourceScript | undefined): (moduleName: string, containingFile: string, compilerOptions: ts.CompilerOptions, cache?: ts.ModuleResolutionCache, redirectedReference?: ts.ResolvedProjectReference, resolutionMode?: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations;
+export declare function createResolveModuleName(ts: typeof import('typescript'), host: ts.ModuleResolutionHost, languagePlugins: LanguagePlugin<any>[], getSourceScript: (fileName: string) => SourceScript | undefined): (moduleName: string, containingFile: string, compilerOptions: ts.CompilerOptions, cache?: ts.ModuleResolutionCache, redirectedReference?: ts.ResolvedProjectReference, resolutionMode?: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations;

package/lib/resolveModuleName.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createResolveModuleName = void 0;
-function createResolveModuleName(ts, languageServiceHost, languagePlugins, getSourceScript) {
-    const toPatchResults = new Map();
+function createResolveModuleName(ts, host, languagePlugins, getSourceScript) {
+    const toSourceFileInfo = new Map();
     const moduleResolutionHost = {
-        readFile: languageServiceHost.readFile.bind(languageServiceHost),
-        directoryExists: languageServiceHost.directoryExists?.bind(languageServiceHost),
-        realpath: languageServiceHost.realpath?.bind(languageServiceHost),
-        getCurrentDirectory: languageServiceHost.getCurrentDirectory.bind(languageServiceHost),
-        getDirectories: languageServiceHost.getDirectories?.bind(languageServiceHost),
-        useCaseSensitiveFileNames: languageServiceHost.useCaseSensitiveFileNames?.bind(languageServiceHost),
+        readFile: host.readFile.bind(host),
+        directoryExists: host.directoryExists?.bind(host),
+        realpath: host.realpath?.bind(host),
+        getCurrentDirectory: host.getCurrentDirectory?.bind(host),
+        getDirectories: host.getDirectories?.bind(host),
+        useCaseSensitiveFileNames: typeof host.useCaseSensitiveFileNames === 'function'
+            ? host.useCaseSensitiveFileNames.bind(host)
+            : host.useCaseSensitiveFileNames,
         fileExists(fileName) {
             for (const { typescript } of languagePlugins) {
                 if (!typescript) {
@@ -17,36 +19,51 @@ function createResolveModuleName(ts, languageServiceHost, languagePlugins, getSo
                 }
                 for (const { extension } of typescript.extraFileExtensions) {
                     if (fileName.endsWith(`.d.${extension}.ts`)) {
-                        const patchFileName = fileName.slice(0, -`.d.${extension}.ts`.length) + `.${extension}`;
-                        if (fileExists(patchFileName)) {
-                            toPatchResults.set(fileName, patchFileName);
-                            return true;
+                        const sourceFileName = fileName.slice(0, -`.d.${extension}.ts`.length) + `.${extension}`;
+                        if (fileExists(sourceFileName)) {
+                            const sourceScript = getSourceScript(sourceFileName);
+                            if (sourceScript?.generated) {
+                                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                                if (serviceScript) {
+                                    const dtsPath = sourceFileName + '.d.ts';
+                                    if ((serviceScript.extension === '.js' || serviceScript.extension === '.jsx') && fileExists(dtsPath)) {
+                                        toSourceFileInfo.set(fileName, {
+                                            sourceFileName: dtsPath,
+                                            extension: '.ts',
+                                        });
+                                    }
+                                    else {
+                                        toSourceFileInfo.set(fileName, {
+                                            sourceFileName,
+                                            extension: serviceScript.extension,
+                                        });
+                                    }
+                                    return true;
+                                }
+                            }
                         }
                     }
                 }
             }
-            return languageServiceHost.fileExists(fileName);
+            return host.fileExists(fileName);
         },
     };
     return (moduleName, containingFile, compilerOptions, cache, redirectedReference, resolutionMode) => {
         const result = ts.resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionHost, cache, redirectedReference, resolutionMode);
-        if (result.resolvedModule && toPatchResults.has(result.resolvedModule.resolvedFileName)) {
-            result.resolvedModule.resolvedFileName = toPatchResults.get(result.resolvedModule.resolvedFileName);
-            const sourceScript = getSourceScript(result.resolvedModule.resolvedFileName);
-            if (sourceScript?.generated) {
-                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
-                if (serviceScript) {
-                    result.resolvedModule.extension = serviceScript.extension;
-                }
+        if (result.resolvedModule) {
+            const sourceFileInfo = toSourceFileInfo.get(result.resolvedModule.resolvedFileName);
+            if (sourceFileInfo) {
+                result.resolvedModule.resolvedFileName = sourceFileInfo.sourceFileName;
+                result.resolvedModule.extension = sourceFileInfo.extension;
             }
         }
-        toPatchResults.clear();
+        toSourceFileInfo.clear();
         return result;
     };
     // fix https://github.com/vuejs/language-tools/issues/3332
     function fileExists(fileName) {
-        if (languageServiceHost.fileExists(fileName)) {
-            const fileSize = ts.sys.getFileSize?.(fileName) ?? languageServiceHost.readFile(fileName)?.length ?? 0;
+        if (host.fileExists(fileName)) {
+            const fileSize = ts.sys.getFileSize?.(fileName) ?? host.readFile(fileName)?.length ?? 0;
             return fileSize < 4 * 1024 * 1024;
         }
         return false;