@volar/typescript 2.1.4 → 2.2.0-alpha.0

package/lib/node/proxyCreateProgram.js

@@ -9,7 +9,7 @@ function proxyCreateProgram(ts, original, extensions, getLanguagePlugins) {
             const options = args[0];
             assert(!!options.host, '!!options.host');
             const sourceFileToSnapshotMap = new WeakMap();
-            const files = (0, language_core_1.createFileRegistry)(getLanguagePlugins(ts, options), ts.sys.useCaseSensitiveFileNames, fileName => {
+            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);
@@ -31,10 +31,10 @@ function proxyCreateProgram(ts, original, extensions, getLanguagePlugins) {
                     }
                 }
                 if (snapshot) {
-                    files.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                    language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
                 }
                 else {
-                    files.delete(fileName);
+                    language.scripts.delete(fileName);
                 }
             });
             const originalSourceFiles = new Map();
@@ -60,16 +60,16 @@ function proxyCreateProgram(ts, original, extensions, getLanguagePlugins) {
                 if (originalSourceFile && extensions.some(ext => fileName.endsWith(ext))) {
                     let sourceFile2 = parsedSourceFiles.get(originalSourceFile);
                     if (!sourceFile2) {
-                        const sourceFile = files.get(fileName);
-                        assert(!!sourceFile, '!!sourceFile');
+                        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 (sourceFile.generated?.languagePlugin.typescript) {
-                            const { getScript, getExtraScripts } = sourceFile.generated.languagePlugin.typescript;
-                            const script = getScript(sourceFile.generated.code);
-                            if (script) {
-                                scriptKind = script.scriptKind;
-                                patchedText += script.code.snapshot.getText(0, script.code.snapshot.getLength());
+                        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.');
@@ -95,8 +95,9 @@ function proxyCreateProgram(ts, original, extensions, getLanguagePlugins) {
                 });
             };
             const program = Reflect.apply(target, thisArg, [options]);
-            (0, decorateProgram_1.decorateProgram)(files, program);
-            program.__volar__ = { files };
+            (0, decorateProgram_1.decorateProgram)(language, program);
+            // TODO: #128
+            program.__volar__ = { files: language };
             return program;
             function resolveModuleName(name, containingFile, options, redirectedReference) {
                 const resolved = ts.resolveModuleName(name, containingFile, options, moduleResolutionHost, originalHost.getModuleResolutionCache?.(), redirectedReference);

package/lib/node/transform.d.ts

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

package/lib/node/transform.js

@@ -26,9 +26,9 @@ function transformDiagnostic(files, diagnostic) {
         if (diagnostic.file !== undefined
             && diagnostic.start !== undefined
             && diagnostic.length !== undefined) {
-            const [virtualCode, sourceFile, map] = (0, utils_1.getVirtualFileAndMap)(files, diagnostic.file.fileName);
+            const [virtualCode, sourceScript, map] = (0, utils_1.getServiceScript)(files, diagnostic.file.fileName);
             if (virtualCode) {
-                const sourceRange = transformRange(sourceFile, map, diagnostic.start, diagnostic.start + diagnostic.length, language_core_1.shouldReportDiagnostics);
+                const sourceRange = transformRange(sourceScript, map, diagnostic.start, diagnostic.start + diagnostic.length, language_core_1.shouldReportDiagnostics);
                 if (sourceRange) {
                     transformedDiagnostics.set(diagnostic, {
                         ...diagnostic,
@@ -49,7 +49,7 @@ function transformDiagnostic(files, diagnostic) {
 }
 exports.transformDiagnostic = transformDiagnostic;
 function transformFileTextChanges(files, changes, filter) {
-    const [_, source] = (0, utils_1.getVirtualFileAndMap)(files, changes.fileName);
+    const [_, source] = (0, utils_1.getServiceScript)(files, changes.fileName);
     if (source) {
         return {
             ...changes,
@@ -72,7 +72,7 @@ exports.transformFileTextChanges = transformFileTextChanges;
 function transformDocumentSpan(files, documentSpan, filter, shouldFallback) {
     let textSpan = transformSpan(files, documentSpan.fileName, documentSpan.textSpan, filter);
     if (!textSpan && shouldFallback) {
-        const [virtualCode] = (0, utils_1.getVirtualFileAndMap)(files, documentSpan.fileName);
+        const [virtualCode] = (0, utils_1.getServiceScript)(files, documentSpan.fileName);
         if (virtualCode) {
             textSpan = {
                 fileName: documentSpan.fileName,
@@ -104,9 +104,9 @@ function transformSpan(files, fileName, textSpan, filter) {
     if (!textSpan) {
         return;
     }
-    const [virtualFile, sourceFile, map] = (0, utils_1.getVirtualFileAndMap)(files, fileName);
+    const [virtualFile, sourceScript, map] = (0, utils_1.getServiceScript)(files, fileName);
     if (virtualFile) {
-        const sourceRange = transformRange(sourceFile, map, textSpan.start, textSpan.start + textSpan.length, filter);
+        const sourceRange = transformRange(sourceScript, map, textSpan.start, textSpan.start + textSpan.length, filter);
         if (sourceRange) {
             return {
                 fileName,
@@ -125,10 +125,10 @@ function transformSpan(files, fileName, textSpan, filter) {
     }
 }
 exports.transformSpan = transformSpan;
-function transformRange(sourceFile, map, start, end, filter) {
-    for (const sourceStart of map.getSourceOffsets(start - sourceFile.snapshot.getLength())) {
+function transformRange(sourceScript, map, start, end, filter) {
+    for (const sourceStart of map.getSourceOffsets(start - sourceScript.snapshot.getLength())) {
         if (filter(sourceStart[1].data)) {
-            for (const sourceEnd of map.getSourceOffsets(end - sourceFile.snapshot.getLength())) {
+            for (const sourceEnd of map.getSourceOffsets(end - sourceScript.snapshot.getLength())) {
                 if (sourceEnd[0] >= sourceStart[0] && filter(sourceEnd[1].data)) {
                     return [sourceStart[0], sourceEnd[0]];
                 }

package/lib/node/utils.d.ts

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

package/lib/node/utils.js

@@ -1,23 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVirtualFileAndMap = exports.notEmpty = void 0;
+exports.getServiceScript = exports.notEmpty = void 0;
 function notEmpty(value) {
     return value !== null && value !== undefined;
 }
 exports.notEmpty = notEmpty;
-function getVirtualFileAndMap(files, fileName) {
-    const sourceFile = files.get(fileName);
-    if (sourceFile?.generated) {
-        const script = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
-        if (script) {
-            for (const map of files.getMaps(script.code)) {
-                if (map[1][0] === sourceFile.snapshot) {
-                    return [script, sourceFile, map[1][1]];
-                }
+function getServiceScript(language, fileName) {
+    const sourceScript = language.scripts.get(fileName);
+    if (sourceScript?.generated) {
+        const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+        if (serviceScript) {
+            const map = language.maps.get(serviceScript.code, sourceScript.id);
+            if (map) {
+                return [serviceScript, sourceScript, map];
             }
         }
     }
     return [undefined, undefined, undefined];
 }
-exports.getVirtualFileAndMap = getVirtualFileAndMap;
+exports.getServiceScript = getServiceScript;
 //# sourceMappingURL=utils.js.map

package/lib/protocol/createProject.d.ts

@@ -1,7 +1,2 @@
-import { LanguagePlugin, LanguageContext, TypeScriptProjectHost } from '@volar/language-core';
-import type * as ts from 'typescript';
-import type { createSys } from './createSys';
-export declare function createLanguage(ts: typeof import('typescript'), sys: ReturnType<typeof createSys> | ts.System, languagePlugins: LanguagePlugin<any>[], configFileName: string | undefined, projectHost: TypeScriptProjectHost, { fileIdToFileName, fileNameToFileId }: {
-    fileIdToFileName: (uri: string) => string;
-    fileNameToFileId: (fileName: string) => string;
-}): LanguageContext;
+import { LanguagePlugin, Language, TypeScriptProjectHost } from '@volar/language-core';
+export declare function createTypeScriptLanguage(ts: typeof import('typescript'), languagePlugins: LanguagePlugin[], projectHost: TypeScriptProjectHost): Language;

package/lib/protocol/createProject.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLanguage = void 0;
+exports.createTypeScriptLanguage = 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 }) {
-    const files = (0, language_core_1.createFileRegistry)(languagePlugins, sys.useCaseSensitiveFileNames, fileId => {
-        const fileName = fileIdToFileName(fileId);
+function createTypeScriptLanguage(ts, languagePlugins, projectHost) {
+    const language = (0, language_core_1.createLanguage)(languagePlugins, projectHost.useCaseSensitiveFileNames, scriptId => {
+        const fileName = projectHost.scriptIdToFileName(scriptId);
         // opened files
         let snapshot = projectHost.getScriptSnapshot(fileName);
         if (!snapshot) {
             // fs files
             const cache = fsFileSnapshots.get(fileName);
-            const modifiedTime = sys.getModifiedTime?.(fileName)?.valueOf();
+            const modifiedTime = projectHost.getModifiedTime?.(fileName)?.valueOf();
             if (!cache || cache[0] !== modifiedTime) {
-                if (sys.fileExists(fileName)) {
-                    const text = sys.readFile(fileName);
+                if (projectHost.fileExists(fileName)) {
+                    const text = projectHost.readFile(fileName);
                     const snapshot = text !== undefined ? ts.ScriptSnapshot.fromString(text) : undefined;
                     fsFileSnapshots.set(fileName, [modifiedTime, snapshot]);
                 }
@@ -29,10 +29,10 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
             snapshot = fsFileSnapshots.get(fileName)?.[1];
         }
         if (snapshot) {
-            files.set(fileId, projectHost.getLanguageId(fileId), snapshot);
+            language.scripts.set(scriptId, projectHost.getLanguageId(scriptId), snapshot);
         }
         else {
-            files.delete(fileId);
+            language.scripts.delete(scriptId);
         }
     });
     let { languageServiceHost, getExtraScript } = createLanguageServiceHost();
@@ -44,11 +44,11 @@ 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;
+        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) => {
-            if ('version' in sys && lastSysVersion !== sys.version) {
-                lastSysVersion = sys.version;
+            if (projectHost.getSystemVersion && lastSysVersion !== projectHost.getSystemVersion()) {
+                lastSysVersion = projectHost.getSystemVersion();
                 moduleCache.clear();
             }
             return moduleLiterals.map(moduleLiteral => {
@@ -56,8 +56,8 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
             });
         };
         languageServiceHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
-            if ('version' in sys && lastSysVersion !== sys.version) {
-                lastSysVersion = sys.version;
+            if (projectHost.getSystemVersion && lastSysVersion !== projectHost.getSystemVersion()) {
+                lastSysVersion = projectHost.getSystemVersion();
                 moduleCache.clear();
             }
             return moduleNames.map(moduleName => {
@@ -65,25 +65,21 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
             });
         };
     }
-    return {
-        files,
-        typescript: {
-            configFileName,
-            sys,
-            projectHost,
-            languageServiceHost,
-            getExtraScript,
-        },
+    language.typescript = {
+        projectHost,
+        languageServiceHost,
+        getExtraServiceScript: getExtraScript,
     };
+    return language;
     function createLanguageServiceHost() {
         let lastProjectVersion;
         let tsProjectVersion = 0;
-        let tsFileRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
-        let extraScriptRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
+        let tsFileRegistry = new language_core_1.FileMap(projectHost.useCaseSensitiveFileNames);
+        let extraScriptRegistry = new language_core_1.FileMap(projectHost.useCaseSensitiveFileNames);
         let lastTsVirtualFileSnapshots = new Set();
         let lastOtherVirtualFileSnapshots = new Set();
         const languageServiceHost = {
-            ...sys,
+            ...projectHost,
             getCurrentDirectory: projectHost.getCurrentDirectory,
             getCompilationSettings() {
                 const options = projectHost.getCompilationSettings();
@@ -107,16 +103,16 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
                 }
             },
             useCaseSensitiveFileNames() {
-                return sys.useCaseSensitiveFileNames;
+                return projectHost.useCaseSensitiveFileNames;
             },
             getNewLine() {
-                return sys.newLine;
+                return projectHost.newLine;
             },
             getTypeRootsVersion: () => {
-                return 'version' in sys ? sys.version : -1; // TODO: only update for /node_modules changes?
+                return projectHost.getSystemVersion?.() ?? -1; // TODO: only update for /node_modules changes?
             },
             getDirectories(dirName) {
-                return sys.getDirectories(dirName);
+                return projectHost.getDirectories(dirName);
             },
             readDirectory(dirName, extensions, excludes, includes, depth) {
                 const exts = new Set(extensions);
@@ -126,7 +122,7 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
                     }
                 }
                 extensions = [...exts];
-                return sys.readDirectory(dirName, extensions, excludes, includes, depth);
+                return projectHost.readDirectory(dirName, extensions, excludes, includes, depth);
             },
             readFile(fileName) {
                 const snapshot = getScriptSnapshot(fileName);
@@ -139,7 +135,7 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
             },
             getProjectVersion() {
                 sync();
-                return tsProjectVersion + ('version' in sys ? `:${sys.version}` : '');
+                return tsProjectVersion + (projectHost.getSystemVersion ? `:${projectHost.getSystemVersion()}` : '');
             },
             getScriptFileNames() {
                 sync();
@@ -150,11 +146,11 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
                 if (extraScriptRegistry.has(fileName)) {
                     return extraScriptRegistry.get(fileName).scriptKind;
                 }
-                const sourceFile = files.get(fileNameToFileId(fileName));
-                if (sourceFile?.generated) {
-                    const tsCode = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
-                    if (tsCode) {
-                        return tsCode.scriptKind;
+                const sourceScript = language.scripts.get(projectHost.fileNameToScriptId(fileName));
+                if (sourceScript?.generated) {
+                    const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                    if (serviceScript) {
+                        return serviceScript.scriptKind;
                     }
                 }
                 switch (path.extname(fileName)) {
@@ -199,19 +195,19 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
             const newOtherVirtualFileSnapshots = new Set();
             const tsFileNamesSet = new Set();
             for (const fileName of projectHost.getScriptFileNames()) {
-                const sourceFile = files.get(fileNameToFileId(fileName));
-                if (sourceFile?.generated) {
-                    const script = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
-                    if (script) {
-                        newTsVirtualFileSnapshots.add(script.code.snapshot);
+                const sourceScript = language.scripts.get(projectHost.fileNameToScriptId(fileName));
+                if (sourceScript?.generated) {
+                    const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                    if (serviceScript) {
+                        newTsVirtualFileSnapshots.add(serviceScript.code.snapshot);
                         tsFileNamesSet.add(fileName);
                     }
-                    for (const extraScript of sourceFile.generated.languagePlugin.typescript?.getExtraScripts?.(fileName, sourceFile.generated.code) ?? []) {
-                        newTsVirtualFileSnapshots.add(extraScript.code.snapshot);
-                        tsFileNamesSet.add(extraScript.fileName);
-                        extraScriptRegistry.set(extraScript.fileName, extraScript);
+                    for (const extraServiceScript of sourceScript.generated.languagePlugin.typescript?.getExtraServiceScripts?.(fileName, sourceScript.generated.root) ?? []) {
+                        newTsVirtualFileSnapshots.add(extraServiceScript.code.snapshot);
+                        tsFileNamesSet.add(extraServiceScript.fileName);
+                        extraScriptRegistry.set(extraServiceScript.fileName, extraServiceScript);
                     }
-                    for (const code of (0, language_core_2.forEachEmbeddedCode)(sourceFile.generated.code)) {
+                    for (const code of (0, language_core_2.forEachEmbeddedCode)(sourceScript.generated.root)) {
                         newOtherVirtualFileSnapshots.add(code.snapshot);
                     }
                 }
@@ -238,15 +234,15 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
             if (extraScriptRegistry.has(fileName)) {
                 return extraScriptRegistry.get(fileName).code.snapshot;
             }
-            const sourceFile = files.get(fileNameToFileId(fileName));
-            if (sourceFile?.generated) {
-                const script = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
-                if (script) {
-                    return script.code.snapshot;
+            const sourceScript = language.scripts.get(projectHost.fileNameToScriptId(fileName));
+            if (sourceScript?.generated) {
+                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                if (serviceScript) {
+                    return serviceScript.code.snapshot;
                 }
             }
-            else if (sourceFile) {
-                return sourceFile.snapshot;
+            else if (sourceScript) {
+                return sourceScript.snapshot;
             }
         }
         function getScriptVersion(fileName) {
@@ -262,34 +258,34 @@ function createLanguage(ts, sys, languagePlugins, configFileName, projectHost, {
                 }
                 return version.map.get(snapshot).toString();
             }
-            const sourceFile = files.get(fileNameToFileId(fileName));
-            if (sourceFile?.generated) {
-                const script = sourceFile.generated.languagePlugin.typescript?.getScript(sourceFile.generated.code);
-                if (script) {
-                    if (!version.map.has(script.code.snapshot)) {
-                        version.map.set(script.code.snapshot, version.lastVersion++);
+            const sourceScript = language.scripts.get(projectHost.fileNameToScriptId(fileName));
+            if (sourceScript?.generated) {
+                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                if (serviceScript) {
+                    if (!version.map.has(serviceScript.code.snapshot)) {
+                        version.map.set(serviceScript.code.snapshot, version.lastVersion++);
                     }
-                    return version.map.get(script.code.snapshot).toString();
+                    return version.map.get(serviceScript.code.snapshot).toString();
                 }
             }
             const isOpenedFile = !!projectHost.getScriptSnapshot(fileName);
             if (isOpenedFile) {
-                const sourceFile = files.get(fileNameToFileId(fileName));
-                if (sourceFile && !sourceFile.generated) {
-                    if (!version.map.has(sourceFile.snapshot)) {
-                        version.map.set(sourceFile.snapshot, version.lastVersion++);
+                const sourceScript = language.scripts.get(projectHost.fileNameToScriptId(fileName));
+                if (sourceScript && !sourceScript.generated) {
+                    if (!version.map.has(sourceScript.snapshot)) {
+                        version.map.set(sourceScript.snapshot, version.lastVersion++);
                     }
-                    return version.map.get(sourceFile.snapshot).toString();
+                    return version.map.get(sourceScript.snapshot).toString();
                 }
             }
-            if (sys.fileExists(fileName)) {
-                return sys.getModifiedTime?.(fileName)?.valueOf().toString() ?? '0';
+            if (projectHost.fileExists(fileName)) {
+                return projectHost.getModifiedTime?.(fileName)?.valueOf().toString() ?? '0';
             }
             return '';
         }
     }
 }
-exports.createLanguage = createLanguage;
+exports.createTypeScriptLanguage = createTypeScriptLanguage;
 function setEquals(a, b) {
     if (a.size !== b.size) {
         return false;

package/lib/protocol/createSys.js

@@ -17,36 +17,31 @@ function createSys(ts, env, currentDirectory) {
     };
     const promises = new Set();
     const fileWatcher = env.onDidChangeWatchedFiles?.(({ changes }) => {
+        version++;
         for (const change of changes) {
             const fileName = env.typescript.uriToFileName(change.uri);
             const dirName = path.dirname(fileName);
             const baseName = path.basename(fileName);
-            const dir = getDir(dirName);
-            if (dir.files.has(baseName) || dir.requestedRead) { // is requested file or directory
-                version++;
-                if (change.type === 1 || change.type === 2) {
-                    dir.files.set(normalizeFileId(baseName), {
-                        name: baseName,
-                        stat: {
-                            type: 1,
-                            ctime: Date.now(),
-                            mtime: Date.now(),
-                            size: -1,
-                        },
-                        requestedStat: false,
-                        requestedText: false,
-                    });
-                }
-                else if (change.type === 3) {
-                    dir.files.set(normalizeFileId(baseName), {
-                        name: baseName,
-                        stat: undefined,
-                        text: undefined,
-                        requestedStat: true,
-                        requestedText: true,
-                    });
-                }
-            }
+            const fileExists = change.type === 1
+                || change.type === 2;
+            const dir = getDir(dirName, fileExists);
+            dir.files.set(normalizeFileId(baseName), fileExists ? {
+                name: baseName,
+                stat: {
+                    type: 1,
+                    ctime: Date.now(),
+                    mtime: Date.now(),
+                    size: -1,
+                },
+                requestedStat: false,
+                requestedText: false,
+            } : {
+                name: baseName,
+                stat: undefined,
+                text: undefined,
+                requestedStat: true,
+                requestedText: true,
+            });
         }
     });
     return {
@@ -335,7 +330,7 @@ function createSys(ts, env, currentDirectory) {
         }
         return updated;
     }
-    function getDir(dirName) {
+    function getDir(dirName, markExists = false) {
         const dirNames = [];
         let currentDirPath = dirName;
         let currentDirName = path.basename(currentDirPath);
@@ -350,6 +345,10 @@ function createSys(ts, env, currentDirectory) {
         for (let i = dirNames.length - 1; i >= 0; i--) {
             const nextDirName = dirNames[i];
             currentDir = getDirFromDir(currentDir, nextDirName);
+            if (markExists && !currentDir.exists) {
+                currentDir.exists = true;
+                version++;
+            }
         }
         return currentDir;
     }

package/lib/quickstart/createAsyncLanguageServicePlugin.js

@@ -52,17 +52,17 @@ function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePl
                         };
                     }
                     loadLanguagePlugins(ts, info).then(languagePlugins => {
-                        const files = (0, language_core_1.createFileRegistry)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                        const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
                             const snapshot = getScriptSnapshot(fileName);
                             if (snapshot) {
-                                files.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                                language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
                             }
                             else {
-                                files.delete(fileName);
+                                language.scripts.delete(fileName);
                             }
                         });
-                        (0, decorateLanguageService_1.decorateLanguageService)(files, info.languageService);
-                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(files, info.languageServiceHost, ts);
+                        (0, decorateLanguageService_1.decorateLanguageService)(language, info.languageService);
+                        (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(language, info.languageServiceHost, ts);
                         info.project.markAsDirty();
                         initialized = true;
                     });

package/lib/quickstart/createLanguageServicePlugin.js

@@ -23,17 +23,17 @@ function createLanguageServicePlugin(loadLanguagePlugins) {
                         .flat();
                     projectExternalFileExtensions.set(info.project, extensions);
                     const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
-                    const files = (0, language_core_1.createFileRegistry)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                    const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
                         const snapshot = getScriptSnapshot(fileName);
                         if (snapshot) {
-                            files.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
+                            language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
                         }
                         else {
-                            files.delete(fileName);
+                            language.scripts.delete(fileName);
                         }
                     });
-                    (0, decorateLanguageService_1.decorateLanguageService)(files, info.languageService);
-                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(files, info.languageServiceHost, ts);
+                    (0, decorateLanguageService_1.decorateLanguageService)(language, info.languageService);
+                    (0, decorateLanguageServiceHost_1.decorateLanguageServiceHost)(language, info.languageServiceHost, ts);
                 }
                 return info.languageService;
             },

package/lib/resolveModuleName.d.ts

@@ -1,3 +1,3 @@
-import type { LanguagePlugin, SourceFile } from '@volar/language-core';
+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>[], getFile: (fileName: string) => SourceFile | 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'), 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;

package/lib/resolveModuleName.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createResolveModuleName = void 0;
-function createResolveModuleName(ts, languageServiceHost, languagePlugins, getFile) {
+function createResolveModuleName(ts, languageServiceHost, languagePlugins, getSourceScript) {
     const toPatchResults = new Map();
     const moduleResolutionHost = {
         readFile: languageServiceHost.readFile.bind(languageServiceHost),
@@ -32,11 +32,11 @@ function createResolveModuleName(ts, languageServiceHost, languagePlugins, getFi
         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;
+            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;
                 }
             }
         }