@volar/typescript 2.0.3 → 2.1.0

package/lib/node/decorateLanguageService.js

@@ -293,7 +293,7 @@ function decorateLanguageService(files, languageService) {
             return result;
         }
         else {
-            return getEncodedSemanticClassifications(fileName, span);
+            return getEncodedSemanticClassifications(fileName, span, format);
         }
     };
     languageService.getSyntacticDiagnostics = fileName => {

package/lib/node/decorateLanguageServiceHost.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchExternalFiles = exports.decorateLanguageServiceHost = void 0;
 const language_core_1 = require("@volar/language-core");
+const resolveModuleName_1 = require("../resolveModuleName");
 function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts) {
     let extraProjectVersion = 0;
-    const exts = virtualFiles.languagePlugins
+    const { languagePlugins } = virtualFiles;
+    const exts = languagePlugins
         .map(plugin => plugin.typescript?.extraFileExtensions.map(ext => '.' + ext.extension) ?? [])
         .flat();
     const scripts = new Map();
@@ -27,33 +29,28 @@ function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts) {
             return readDirectory(path, extensions, exclude, include, depth);
         };
     }
-    if (resolveModuleNameLiterals) {
-        languageServiceHost.resolveModuleNameLiterals = (moduleNames, containingFile, redirectedReference, options, ...rest) => {
-            const resolvedModules = resolveModuleNameLiterals(moduleNames, containingFile, redirectedReference, options, ...rest);
-            return moduleNames.map((name, i) => {
-                if (exts.some(ext => name.text.endsWith(ext))) {
-                    const resolved = resolveModuleName(name.text, containingFile, options, redirectedReference);
-                    if (resolved.resolvedModule) {
-                        return resolved;
-                    }
+    if (languagePlugins.some(language => language.typescript?.extraFileExtensions.length)) {
+        const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, languagePlugins, fileName => virtualFiles.get(fileName));
+        if (resolveModuleNameLiterals) {
+            languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, ...rest) => {
+                if (moduleLiterals.every(name => !exts.some(ext => name.text.endsWith(ext)))) {
+                    return resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, ...rest);
                 }
-                return resolvedModules[i];
-            });
-        };
-    }
-    else if (resolveModuleNames) {
-        languageServiceHost.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile) => {
-            const resolvedModules = resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile);
-            return moduleNames.map((name, i) => {
-                if (exts.some(ext => name.endsWith(ext))) {
-                    const resolved = resolveModuleName(name, containingFile, options, redirectedReference);
-                    if (resolved.resolvedModule) {
-                        return resolved.resolvedModule;
-                    }
+                return moduleLiterals.map(moduleLiteral => {
+                    return resolveModuleName(moduleLiteral.text, containingFile, options, undefined, redirectedReference);
+                });
+            };
+        }
+        if (resolveModuleNames) {
+            languageServiceHost.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile) => {
+                if (moduleNames.every(name => !exts.some(ext => name.endsWith(ext)))) {
+                    return resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile);
                 }
-                return resolvedModules[i];
-            });
-        };
+                return moduleNames.map(moduleName => {
+                    return resolveModuleName(moduleName, containingFile, options, undefined, redirectedReference).resolvedModule;
+                });
+            };
+        }
     }
     if (getProjectVersion) {
         languageServiceHost.getProjectVersion = () => {
@@ -80,35 +77,6 @@ function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts) {
             return getScriptKind(fileName);
         };
     }
-    function resolveModuleName(name, containingFile, options, redirectedReference) {
-        const resolved = ts.resolveModuleName(name, containingFile, options, {
-            readFile(fileName) {
-                return languageServiceHost.readFile(fileName);
-            },
-            fileExists(fileName) {
-                if (exts.some(ext => fileName.endsWith(ext + '.d.ts'))) {
-                    return fileExists(fileName.slice(0, -'.d.ts'.length));
-                }
-                return languageServiceHost.fileExists(fileName);
-            },
-        }, undefined, redirectedReference);
-        if (resolved.resolvedModule) {
-            resolved.resolvedModule.resolvedFileName = resolved.resolvedModule.resolvedFileName.slice(0, -'.d.ts'.length);
-            const script = updateScript(resolved.resolvedModule.resolvedFileName);
-            if (script) {
-                resolved.resolvedModule.extension = script.extension;
-            }
-        }
-        return resolved;
-    }
-    // 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;
-            return fileSize < 4 * 1024 * 1024;
-        }
-        return false;
-    }
     function updateScript(fileName) {
         const version = languageServiceHost.getScriptVersion(fileName);
         if (version !== scripts.get(fileName)?.version) {

package/lib/protocol/createProject.js

@@ -4,6 +4,7 @@ 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 resolveModuleName_1 = require("../resolveModuleName");
 const scriptVersions = new Map();
 const fsFileSnapshots = new Map();
 function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, { fileIdToFileName, fileNameToFileId }) {
@@ -43,6 +44,7 @@ function createLanguage(ts, sys, languagePlugins, configFileName, 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 resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, languagePlugins, fileName => files.get(fileNameToFileId(fileName)));
         let lastSysVersion = 'version' in sys ? sys.version : undefined;
         languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, sourceFile) => {
             if ('version' in sys && lastSysVersion !== sys.version) {
@@ -50,42 +52,16 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
                 moduleCache.clear();
             }
             return moduleLiterals.map(moduleLiteral => {
-                let moduleName = moduleLiteral.text;
-                let extraFileExtension;
-                let isPatchResult = false;
-                for (const language of languagePlugins) {
-                    extraFileExtension = language.typescript?.extraFileExtensions.find(ext => moduleName.endsWith('.' + ext.extension))?.extension;
-                    if (extraFileExtension) {
-                        break;
-                    }
-                }
-                const result = ts.resolveModuleName(moduleName, containingFile, options, {
-                    ...languageServiceHost,
-                    fileExists(fileName) {
-                        if (extraFileExtension && fileName.endsWith(`.d.${extraFileExtension}.ts`)) {
-                            const patchResult = languageServiceHost.fileExists(fileName.slice(0, -`.d.${extraFileExtension}.ts`.length)
-                                + `.${extraFileExtension}`);
-                            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, -`.d.${extraFileExtension}.ts`.length)
-                        + `.${extraFileExtension}`;
-                    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 result;
+                return resolveModuleName(moduleLiteral.text, containingFile, options, moduleCache, redirectedReference, sourceFile.impliedNodeFormat);
+            });
+        };
+        languageServiceHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
+            if ('version' in sys && lastSysVersion !== sys.version) {
+                lastSysVersion = sys.version;
+                moduleCache.clear();
+            }
+            return moduleNames.map(moduleName => {
+                return resolveModuleName(moduleName, containingFile, options, moduleCache, redirectedReference).resolvedModule;
             });
         };
     }

package/lib/protocol/createSys.d.ts

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

package/lib/protocol/createSys.js

@@ -4,9 +4,8 @@ exports.createSys = void 0;
 const path = require("path-browserify");
 const utilities_1 = require("../typescript/utilities");
 let currentCwd = '';
-function createSys(ts, env, projectHost) {
+function createSys(ts, env, currentDirectory) {
     let version = 0;
-    const rootPath = projectHost.getCurrentDirectory();
     const sys = ts.sys;
     const root = {
         dirs: new Map(),
@@ -56,8 +55,8 @@ function createSys(ts, env, projectHost) {
         writeFile: sys?.writeFile ?? (() => { }),
         createDirectory: sys?.createDirectory ?? (() => { }),
         exit: sys?.exit ?? (() => { }),
-        getExecutingFilePath: sys?.getExecutingFilePath ?? (() => rootPath + '/__fake__.js'),
-        getCurrentDirectory: () => rootPath,
+        getExecutingFilePath: sys?.getExecutingFilePath ?? (() => currentDirectory + '/__fake__.js'),
+        getCurrentDirectory: () => currentDirectory,
         getModifiedTime,
         readFile,
         readDirectory,
@@ -77,15 +76,15 @@ function createSys(ts, env, projectHost) {
     };
     function resolvePath(fsPath) {
         if (sys) {
-            if (currentCwd !== rootPath) {
-                currentCwd = rootPath;
+            if (currentCwd !== currentDirectory) {
+                currentCwd = currentDirectory;
                 // https://github.com/vuejs/language-tools/issues/2039
                 // https://github.com/vuejs/language-tools/issues/2234
-                if (sys.directoryExists(rootPath)) {
+                if (sys.directoryExists(currentDirectory)) {
                     // https://github.com/vuejs/language-tools/issues/2480
                     try {
                         // @ts-ignore
-                        process.chdir(rootPath);
+                        process.chdir(currentDirectory);
                     }
                     catch { }
                 }
@@ -184,7 +183,7 @@ function createSys(ts, env, projectHost) {
     }
     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, currentDirectory, depth, dirPath => {
             dirPath = resolvePath(dirPath);
             readDirectoryWorker(dirPath);
             const dir = getDir(dirPath);

package/lib/resolveModuleName.d.ts

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

package/lib/resolveModuleName.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResolveModuleName = void 0;
+function createResolveModuleName(ts, languageServiceHost, languagePlugins, getFile) {
+    const toPatchResults = 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),
+        fileExists(fileName) {
+            for (const { typescript } of languagePlugins) {
+                if (!typescript) {
+                    continue;
+                }
+                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;
+                        }
+                    }
+                }
+            }
+            return languageServiceHost.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 sourceFile = getFile(result.resolvedModule.resolvedFileName);
+            if (sourceFile?.generated) {
+                const tsCode = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
+                if (tsCode) {
+                    result.resolvedModule.extension = tsCode.extension;
+                }
+            }
+        }
+        toPatchResults.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;
+            return fileSize < 4 * 1024 * 1024;
+        }
+        return false;
+    }
+}
+exports.createResolveModuleName = createResolveModuleName;
+//# sourceMappingURL=resolveModuleName.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/typescript",
-	"version": "2.0.3",
+	"version": "2.1.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,13 +12,13 @@
 		"directory": "packages/typescript"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.0.3",
+		"@volar/language-core": "2.1.0",
 		"path-browserify": "^1.0.1"
 	},
 	"devDependencies": {
 		"@types/node": "latest",
 		"@types/path-browserify": "latest",
-		"@volar/language-service": "2.0.3"
+		"@volar/language-service": "2.1.0"
 	},
-	"gitHead": "d8a6dc056d37779ff6486f545f45bc57b22c02e4"
+	"gitHead": "09e1792f0adafb02caf89a5a45a6fcaaf3177808"
 }