@volar/language-core 1.0.14 → 1.0.17

package/out/documentRegistry.d.ts

@@ -1,36 +1,22 @@
-import { Mapping, SourceMapBase } from '@volar/source-map';
-import { Teleport } from './sourceMaps';
-import type { EmbeddedFile, LanguageModule, SourceFile } from './types';
-export declare function forEachEmbeddeds(file: EmbeddedFile, cb: (embedded: EmbeddedFile) => void): void;
-export type DocumentRegistry = ReturnType<typeof createDocumentRegistry>;
-export declare function createDocumentRegistry(): {
-    get: (fileName: string) => [SourceFile, LanguageModule] | undefined;
-    delete: (fileName: string) => boolean;
-    has: (fileName: string) => boolean;
-    set: (fileName: string, vueFile: SourceFile, languageModule: LanguageModule) => [SourceFile, LanguageModule<SourceFile>];
-    getFileNames: () => string[];
-    getAll: () => [SourceFile, LanguageModule<SourceFile>][];
-    getTeleport: (fileName: string) => Teleport | undefined;
-    getAllEmbeddeds: () => Generator<{
-        sourceFile: SourceFile;
-        embedded: EmbeddedFile;
-    }, void, unknown>;
-    fromEmbeddedLocation: (fileName: string, offset: number, baseOnRight?: boolean) => Generator<{
-        fileName: string;
-        offset: number;
-        mapping: Mapping<any>;
-        sourceMap: SourceMapBase<any>;
-    } | {
-        fileName: string;
-        offset: number;
-        mapping?: undefined;
-        sourceMap?: undefined;
-    }, void, unknown>;
-    fromEmbeddedFile: (file: EmbeddedFile) => SourceFile | undefined;
-    fromEmbeddedFileName: (fileName: string) => {
-        sourceFile: SourceFile;
-        embedded: EmbeddedFile;
-    } | undefined;
-    getSourceMap: (file: SourceFile, mappings: Mapping<any>[]) => SourceMapBase<any>;
-    onSourceFileUpdated(file: SourceFile): void;
+import { SourceMap } from '@volar/source-map';
+import { MirrorMap } from './sourceMaps';
+import type { LanguageModule, FileRangeCapabilities, VirtualFile } from './types';
+export type VirtualFiles = ReturnType<typeof createVirtualFiles>;
+type Row = [
+    string,
+    ts.IScriptSnapshot,
+    VirtualFile,
+    LanguageModule
+];
+export declare function createVirtualFiles(languageModules: LanguageModule[]): {
+    update(fileName: string, snapshot: ts.IScriptSnapshot): VirtualFile | undefined;
+    delete(fileName: string): void;
+    get(fileName: string): readonly [import("typescript/lib/tsserverlibrary").IScriptSnapshot, VirtualFile] | undefined;
+    hasSourceFile: (fileName: string) => boolean;
+    all: () => Row[];
+    getMirrorMap: (file: VirtualFile) => MirrorMap | undefined;
+    getMaps: (virtualFile: VirtualFile) => [string, SourceMap<FileRangeCapabilities>][];
+    getSourceByVirtualFileName(fileName: string): readonly [string, import("typescript/lib/tsserverlibrary").IScriptSnapshot, VirtualFile] | undefined;
 };
+export declare function forEachEmbeddedFile(file: VirtualFile, cb: (embedded: VirtualFile) => void): void;
+export {};

package/out/documentRegistry.js

@@ -1,128 +1,108 @@
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDocumentRegistry = exports.forEachEmbeddeds = void 0;
+exports.forEachEmbeddedFile = exports.createVirtualFiles = void 0;
 const source_map_1 = require("@volar/source-map");
 const reactivity_1 = require("@vue/reactivity");
 const sourceMaps_1 = require("./sourceMaps");
-function forEachEmbeddeds(file, cb) {
-    cb(file);
-    for (const child of file.embeddeds) {
-        forEachEmbeddeds(child, cb);
-    }
-}
-exports.forEachEmbeddeds = forEachEmbeddeds;
-function createDocumentRegistry() {
-    const files = (0, reactivity_1.shallowReactive)({});
-    const all = (0, reactivity_1.computed)(() => Object.values(files));
-    const fileNames = (0, reactivity_1.computed)(() => all.value.map(sourceFile => sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile[0].fileName));
-    const embeddedDocumentsMap = (0, reactivity_1.computed)(() => {
-        const map = new WeakMap();
-        for (const [sourceFile] of all.value) {
-            forEachEmbeddeds(sourceFile, embedded => {
-                map.set(embedded, sourceFile);
-            });
-        }
-        return map;
-    });
-    const sourceMapsByFileName = (0, reactivity_1.computed)(() => {
+function createVirtualFiles(languageModules) {
+    const sourceFileToRootVirtualFileMap = (0, reactivity_1.shallowReactive)({});
+    const all = (0, reactivity_1.computed)(() => Object.values(sourceFileToRootVirtualFileMap));
+    const virtualFileNameToSource = (0, reactivity_1.computed)(() => {
         const map = new Map();
-        for (const [sourceFile] of all.value) {
-            forEachEmbeddeds(sourceFile, embedded => {
-                map.set(normalizePath(embedded.fileName), { sourceFile, embedded });
-            });
-        }
-        return map;
-    });
-    const teleports = (0, reactivity_1.computed)(() => {
-        const map = new Map();
-        for (const key in files) {
-            const [sourceFile] = files[key];
-            forEachEmbeddeds(sourceFile, embedded => {
-                if (embedded.teleportMappings) {
-                    map.set(normalizePath(embedded.fileName), getTeleport(sourceFile, embedded.teleportMappings));
-                }
+        for (const row of all.value) {
+            forEachEmbeddedFile(row[2], file => {
+                map.set(normalizePath(file.fileName), [file, row]);
             });
         }
         return map;
     });
-    const _sourceMaps = new WeakMap();
-    const _teleports = new WeakMap();
+    const virtualFileToSourceMapsMap = new WeakMap();
+    const virtualFileToMirrorMap = new WeakMap();
     return {
-        get: (fileName) => files[normalizePath(fileName)],
-        delete: (fileName) => delete files[normalizePath(fileName)],
-        has: (fileName) => !!files[normalizePath(fileName)],
-        set: (fileName, vueFile, languageModule) => files[normalizePath(fileName)] = [vueFile, languageModule],
-        getFileNames: () => fileNames.value,
-        getAll: () => all.value,
-        getTeleport: (fileName) => teleports.value.get(normalizePath(fileName)),
-        getAllEmbeddeds: function* () {
-            for (const sourceMap of sourceMapsByFileName.value) {
-                yield sourceMap[1];
+        update(fileName, snapshot) {
+            const key = normalizePath(fileName);
+            if (sourceFileToRootVirtualFileMap[key]) {
+                const virtualFile = sourceFileToRootVirtualFileMap[key][2];
+                sourceFileToRootVirtualFileMap[key][1] = snapshot;
+                sourceFileToRootVirtualFileMap[key][3].updateFile(virtualFile, snapshot);
+                return virtualFile; // updated
             }
-        },
-        fromEmbeddedLocation: function* (fileName, offset, baseOnRight = false) {
-            if (fileName.endsWith('/__VLS_types.ts')) { // TODO: monkey fix
-                return;
-            }
-            const mapped = sourceMapsByFileName.value.get(normalizePath(fileName));
-            if (mapped) {
-                const sourceMap = getSourceMap(mapped.sourceFile, mapped.embedded.mappings);
-                for (const vueRange of sourceMap.toSourceOffsets(offset, baseOnRight)) {
-                    yield {
-                        fileName: mapped.sourceFile.fileName,
-                        offset: vueRange[0],
-                        mapping: vueRange[1],
-                        sourceMap,
-                    };
+            for (const languageModule of languageModules) {
+                const virtualFile = languageModule.createFile(fileName, snapshot);
+                if (virtualFile) {
+                    sourceFileToRootVirtualFileMap[key] = [fileName, snapshot, (0, reactivity_1.shallowReactive)(virtualFile), languageModule];
+                    return virtualFile; // created
                 }
             }
-            else {
-                yield {
-                    fileName,
-                    offset,
-                };
-            }
         },
-        fromEmbeddedFile: function (file) {
-            return embeddedDocumentsMap.value.get(file);
+        delete(fileName) {
+            var _a, _b;
+            const key = normalizePath(fileName);
+            if (sourceFileToRootVirtualFileMap[key]) {
+                const virtualFile = sourceFileToRootVirtualFileMap[key][2];
+                (_b = (_a = sourceFileToRootVirtualFileMap[key][3]).deleteFile) === null || _b === void 0 ? void 0 : _b.call(_a, virtualFile);
+                delete sourceFileToRootVirtualFileMap[key]; // deleted
+            }
         },
-        fromEmbeddedFileName: function (fileName) {
-            return sourceMapsByFileName.value.get(normalizePath(fileName));
+        get(fileName) {
+            const key = normalizePath(fileName);
+            if (sourceFileToRootVirtualFileMap[key]) {
+                return [
+                    sourceFileToRootVirtualFileMap[key][1],
+                    sourceFileToRootVirtualFileMap[key][2],
+                ];
+            }
         },
-        getSourceMap,
-        // TODO: unuse this
-        onSourceFileUpdated(file) {
-            _sourceMaps.delete(file);
-            _teleports.delete(file);
+        hasSourceFile: (fileName) => !!sourceFileToRootVirtualFileMap[normalizePath(fileName)],
+        all: () => all.value,
+        getMirrorMap: getMirrorMap,
+        getMaps: getSourceMaps,
+        getSourceByVirtualFileName(fileName) {
+            const source = virtualFileNameToSource.value.get(normalizePath(fileName));
+            if (source) {
+                return [
+                    source[1][0],
+                    source[1][1],
+                    source[0],
+                ];
+            }
         },
     };
-    function getSourceMap(file, mappings) {
-        let map1 = _sourceMaps.get(file);
-        if (!map1) {
-            map1 = new WeakMap();
-            _sourceMaps.set(file, map1);
+    function getSourceMaps(virtualFile) {
+        let sourceMapsBySourceFileName = virtualFileToSourceMapsMap.get(virtualFile.snapshot);
+        if (!sourceMapsBySourceFileName) {
+            sourceMapsBySourceFileName = new Map();
+            virtualFileToSourceMapsMap.set(virtualFile.snapshot, sourceMapsBySourceFileName);
         }
-        let map2 = map1.get(mappings);
-        if (!map2) {
-            map2 = new source_map_1.SourceMapBase(mappings);
-            map1.set(mappings, map2);
+        const sources = new Set();
+        for (const map of virtualFile.mappings) {
+            sources.add(map.source);
         }
-        return map2;
-    }
-    function getTeleport(file, mappings) {
-        let map1 = _teleports.get(file);
-        if (!map1) {
-            map1 = new WeakMap();
-            _teleports.set(file, map1);
+        for (const source of sources) {
+            const sourceFileName = source !== null && source !== void 0 ? source : virtualFileNameToSource.value.get(normalizePath(virtualFile.fileName))[1][0];
+            if (!sourceMapsBySourceFileName.has(sourceFileName)) {
+                sourceMapsBySourceFileName.set(sourceFileName, [
+                    sourceFileName,
+                    new source_map_1.SourceMap(virtualFile.mappings.filter(mapping => mapping.source === source)),
+                ]);
+            }
         }
-        let map2 = map1.get(mappings);
-        if (!map2) {
-            map2 = new sourceMaps_1.Teleport(mappings);
-            map1.set(mappings, map2);
+        return [...sourceMapsBySourceFileName.values()];
+    }
+    function getMirrorMap(file) {
+        if (!virtualFileToMirrorMap.has(file.snapshot)) {
+            virtualFileToMirrorMap.set(file.snapshot, file.mirrorBehaviorMappings ? new sourceMaps_1.MirrorMap(file.mirrorBehaviorMappings) : undefined);
         }
-        return map2;
+        return virtualFileToMirrorMap.get(file.snapshot);
+    }
+}
+exports.createVirtualFiles = createVirtualFiles;
+function forEachEmbeddedFile(file, cb) {
+    cb(file);
+    for (const embeddedFile of file.embeddedFiles) {
+        forEachEmbeddedFile(embeddedFile, cb);
     }
 }
-exports.createDocumentRegistry = createDocumentRegistry;
+exports.forEachEmbeddedFile = forEachEmbeddedFile;
 function normalizePath(fileName) {
     return fileName.replace(/\\/g, '/').toLowerCase();
 }

package/out/languageContext.d.ts

@@ -1,37 +1,18 @@
 import type * as ts from 'typescript/lib/tsserverlibrary';
-import { LanguageModule, SourceFile, LanguageServiceHost } from './types';
-export type EmbeddedLanguageContext = ReturnType<typeof createEmbeddedLanguageServiceHost>;
-export declare function createEmbeddedLanguageServiceHost(host: LanguageServiceHost, languageModules: LanguageModule[]): {
-    typescriptLanguageServiceHost: ts.LanguageServiceHost;
-    mapper: {
-        get: (fileName: string) => [SourceFile, LanguageModule<SourceFile>] | undefined;
-        delete: (fileName: string) => boolean;
-        has: (fileName: string) => boolean;
-        set: (fileName: string, vueFile: SourceFile, languageModule: LanguageModule<SourceFile>) => [SourceFile, LanguageModule<SourceFile>];
-        getFileNames: () => string[];
-        getAll: () => [SourceFile, LanguageModule<SourceFile>][];
-        getTeleport: (fileName: string) => import("./sourceMaps").Teleport | undefined;
-        getAllEmbeddeds: () => Generator<{
-            sourceFile: SourceFile;
-            embedded: import("./types").EmbeddedFile;
-        }, void, unknown>;
-        fromEmbeddedLocation: (fileName: string, offset: number, baseOnRight?: boolean) => Generator<{
-            fileName: string;
-            offset: number;
-            mapping: import("@volar/source-map").Mapping<any>;
-            sourceMap: import("@volar/source-map").SourceMapBase<any>;
-        } | {
-            fileName: string;
-            offset: number;
-            mapping?: undefined;
-            sourceMap?: undefined;
-        }, void, unknown>;
-        fromEmbeddedFile: (file: import("./types").EmbeddedFile) => SourceFile | undefined;
-        fromEmbeddedFileName: (fileName: string) => {
-            sourceFile: SourceFile;
-            embedded: import("./types").EmbeddedFile;
-        } | undefined;
-        getSourceMap: (file: SourceFile, mappings: import("@volar/source-map").Mapping<any>[]) => import("@volar/source-map").SourceMapBase<any>;
-        onSourceFileUpdated(file: SourceFile): void;
+import { LanguageModule, LanguageServiceHost } from './types';
+export type LanguageContext = ReturnType<typeof createLanguageContext>;
+export declare function createLanguageContext(host: LanguageServiceHost, languageModules: LanguageModule[]): {
+    typescript: {
+        languageServiceHost: ts.LanguageServiceHost;
+    };
+    virtualFiles: {
+        update(fileName: string, snapshot: ts.IScriptSnapshot): import("./types").VirtualFile | undefined;
+        delete(fileName: string): void;
+        get(fileName: string): readonly [ts.IScriptSnapshot, import("./types").VirtualFile] | undefined;
+        hasSourceFile: (fileName: string) => boolean;
+        all: () => [string, ts.IScriptSnapshot, import("./types").VirtualFile, LanguageModule<import("./types").VirtualFile>][];
+        getMirrorMap: (file: import("./types").VirtualFile) => import("./sourceMaps").MirrorMap | undefined;
+        getMaps: (virtualFile: import("./types").VirtualFile) => [string, import("@volar/source-map").SourceMap<import("./types").FileRangeCapabilities>][];
+        getSourceByVirtualFileName(fileName: string): readonly [string, ts.IScriptSnapshot, import("./types").VirtualFile] | undefined;
     };
 };

package/out/languageContext.js

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEmbeddedLanguageServiceHost = void 0;
+exports.createLanguageContext = void 0;
 const path_1 = require("path");
 const documentRegistry_1 = require("./documentRegistry");
-const reactivity_1 = require("@vue/reactivity");
-function createEmbeddedLanguageServiceHost(host, languageModules) {
+const types_1 = require("./types");
+function createLanguageContext(host, languageModules) {
     for (const languageModule of languageModules.reverse()) {
         if (languageModule.proxyLanguageServiceHost) {
             const proxyApis = languageModule.proxyLanguageServiceHost(host);
@@ -19,33 +19,28 @@ function createEmbeddedLanguageServiceHost(host, languageModules) {
     }
     let lastProjectVersion;
     let tsProjectVersion = 0;
-    const documentRegistry = (0, documentRegistry_1.createDocumentRegistry)();
+    const virtualFiles = (0, documentRegistry_1.createVirtualFiles)(languageModules);
     const ts = host.getTypeScriptModule();
-    const tsFileVersions = new Map();
     const scriptSnapshots = new Map();
-    const fileVersions = new Map();
+    const sourceTsFileVersions = new Map();
+    const sourceFileVersions = new Map();
+    const virtualFileVersions = new Map();
     const _tsHost = {
         fileExists: host.fileExists
             ? fileName => {
                 var _a;
                 // .vue.js -> .vue
                 // .vue.ts -> .vue
-                // .vue.d.ts (never)
+                // .vue.d.ts -> [ignored]
                 const vueFileName = fileName.substring(0, fileName.lastIndexOf('.'));
-                if (!documentRegistry.get(vueFileName)) {
+                if (!virtualFiles.hasSourceFile(vueFileName)) {
                     // create virtual files
                     const scriptSnapshot = host.getScriptSnapshot(vueFileName);
                     if (scriptSnapshot) {
-                        for (const languageModule of languageModules) {
-                            const sourceFile = languageModule.createSourceFile(vueFileName, scriptSnapshot);
-                            if (sourceFile) {
-                                documentRegistry.set(vueFileName, (0, reactivity_1.shallowReactive)(sourceFile), languageModule);
-                                break;
-                            }
-                        }
+                        virtualFiles.update(vueFileName, scriptSnapshot);
                     }
                 }
-                if (!!documentRegistry.fromEmbeddedFileName(fileName)) {
+                if (virtualFiles.getSourceByVirtualFileName(fileName)) {
                     return true;
                 }
                 return !!((_a = host.fileExists) === null || _a === void 0 ? void 0 : _a.call(host, fileName));
@@ -60,12 +55,12 @@ function createEmbeddedLanguageServiceHost(host, languageModules) {
         readDirectory: (_path, extensions, exclude, include, depth) => {
             var _a, _b;
             const result = (_b = (_a = host.readDirectory) === null || _a === void 0 ? void 0 : _a.call(host, _path, extensions, exclude, include, depth)) !== null && _b !== void 0 ? _b : [];
-            for (const vuePath of documentRegistry.getFileNames()) {
-                const vuePath2 = path_1.posix.join(_path, path_1.posix.basename(vuePath));
-                if (path_1.posix.relative(_path.toLowerCase(), vuePath.toLowerCase()).startsWith('..')) {
+            for (const [fileName] of virtualFiles.all()) {
+                const vuePath2 = path_1.posix.join(_path, path_1.posix.basename(fileName));
+                if (path_1.posix.relative(_path.toLowerCase(), fileName.toLowerCase()).startsWith('..')) {
                     continue;
                 }
-                if (!depth && vuePath.toLowerCase() === vuePath2.toLowerCase()) {
+                if (!depth && fileName.toLowerCase() === vuePath2.toLowerCase()) {
                     result.push(vuePath2);
                 }
                 else if (depth) {
@@ -75,7 +70,7 @@ function createEmbeddedLanguageServiceHost(host, languageModules) {
             return result;
         },
         getScriptKind(fileName) {
-            if (documentRegistry.has(fileName))
+            if (virtualFiles.hasSourceFile(fileName))
                 return ts.ScriptKind.Deferred;
             switch (path_1.posix.extname(fileName)) {
                 case '.js': return ts.ScriptKind.JS;
@@ -88,13 +83,15 @@ function createEmbeddedLanguageServiceHost(host, languageModules) {
         },
     };
     return {
-        typescriptLanguageServiceHost: new Proxy(_tsHost, {
-            get: (target, property) => {
-                update();
-                return target[property] || host[property];
-            },
-        }),
-        mapper: new Proxy(documentRegistry, {
+        typescript: {
+            languageServiceHost: new Proxy(_tsHost, {
+                get: (target, property) => {
+                    update();
+                    return target[property] || host[property];
+                },
+            }),
+        },
+        virtualFiles: new Proxy(virtualFiles, {
             get: (target, property) => {
                 update();
                 return target[property];
@@ -104,139 +101,120 @@ function createEmbeddedLanguageServiceHost(host, languageModules) {
     function update() {
         var _a;
         const newProjectVersion = (_a = host.getProjectVersion) === null || _a === void 0 ? void 0 : _a.call(host);
-        const sholdUpdate = newProjectVersion === undefined || newProjectVersion !== lastProjectVersion;
+        const shouldUpdate = newProjectVersion === undefined || newProjectVersion !== lastProjectVersion;
         lastProjectVersion = newProjectVersion;
-        if (!sholdUpdate)
+        if (!shouldUpdate)
             return;
-        let tsFileUpdated = false;
-        const remainFileNames = new Set(host.getScriptFileNames());
-        const sourceFilesToUpdate = [];
+        let shouldUpdateTsProject = false;
+        let virtualFilesUpdatedNum = 0;
+        const remainRootFiles = new Set(host.getScriptFileNames());
         // .vue
-        for (const [sourceFile, languageModule] of documentRegistry.getAll()) {
-            remainFileNames.delete(sourceFile.fileName);
-            const newVersion = host.getScriptVersion(sourceFile.fileName);
-            if (fileVersions.get(sourceFile.fileName) !== newVersion) {
-                fileVersions.set(sourceFile.fileName, newVersion);
-                const snapshot = host.getScriptSnapshot(sourceFile.fileName);
-                if (snapshot) {
-                    // update
-                    sourceFilesToUpdate.push([sourceFile, languageModule, snapshot]);
-                }
-                else {
-                    // delete
-                    if (documentRegistry.delete(sourceFile.fileName)) {
-                        tsFileUpdated = true;
-                    }
-                }
+        for (const [fileName] of virtualFiles.all()) {
+            remainRootFiles.delete(fileName);
+            const snapshot = host.getScriptSnapshot(fileName);
+            if (!snapshot) {
+                // delete
+                virtualFiles.delete(fileName);
+                shouldUpdateTsProject = true;
+                continue;
+            }
+            const newVersion = host.getScriptVersion(fileName);
+            if (sourceFileVersions.get(fileName) !== newVersion) {
+                // update
+                sourceFileVersions.set(fileName, newVersion);
+                virtualFiles.update(fileName, snapshot);
+                virtualFilesUpdatedNum++;
             }
         }
         // no any vue file version change, it mean project version was update by ts file change at this time
-        if (!sourceFilesToUpdate.length) {
-            tsFileUpdated = true;
+        if (!virtualFilesUpdatedNum) {
+            shouldUpdateTsProject = true;
         }
         // add
-        for (const fileName of [...remainFileNames]) {
+        for (const fileName of [...remainRootFiles]) {
             const snapshot = host.getScriptSnapshot(fileName);
             if (snapshot) {
-                for (const languageModule of languageModules) {
-                    const sourceFile = languageModule.createSourceFile(fileName, snapshot);
-                    if (sourceFile) {
-                        fileVersions.set(sourceFile.fileName, host.getScriptVersion(fileName));
-                        documentRegistry.set(fileName, (0, reactivity_1.shallowReactive)(sourceFile), languageModule);
-                        remainFileNames.delete(fileName);
-                        break;
-                    }
+                const virtualFile = virtualFiles.update(fileName, snapshot);
+                if (virtualFile) {
+                    remainRootFiles.delete(fileName);
                 }
             }
         }
         // .ts / .js / .d.ts / .json ...
-        for (const [oldTsFileName, oldTsFileVersion] of [...tsFileVersions]) {
+        for (const [oldTsFileName, oldTsFileVersion] of [...sourceTsFileVersions]) {
             const newVersion = host.getScriptVersion(oldTsFileName);
             if (oldTsFileVersion !== newVersion) {
-                if (!remainFileNames.has(oldTsFileName) && !host.getScriptSnapshot(oldTsFileName)) {
+                if (!remainRootFiles.has(oldTsFileName) && !host.getScriptSnapshot(oldTsFileName)) {
                     // delete
-                    tsFileVersions.delete(oldTsFileName);
+                    sourceTsFileVersions.delete(oldTsFileName);
                 }
                 else {
                     // update
-                    tsFileVersions.set(oldTsFileName, newVersion);
+                    sourceTsFileVersions.set(oldTsFileName, newVersion);
                 }
-                tsFileUpdated = true;
+                shouldUpdateTsProject = true;
             }
         }
-        for (const nowFileName of remainFileNames) {
-            if (!tsFileVersions.has(nowFileName)) {
+        for (const nowFileName of remainRootFiles) {
+            if (!sourceTsFileVersions.has(nowFileName)) {
                 // add
                 const newVersion = host.getScriptVersion(nowFileName);
-                tsFileVersions.set(nowFileName, newVersion);
-                tsFileUpdated = true;
+                sourceTsFileVersions.set(nowFileName, newVersion);
+                shouldUpdateTsProject = true;
             }
         }
-        for (const [sourceFile, languageModule, snapshot] of sourceFilesToUpdate) {
-            (0, documentRegistry_1.forEachEmbeddeds)(sourceFile, embedded => {
-                fileVersions.delete(embedded.fileName);
-            });
-            const oldScripts = {};
-            const newScripts = {};
-            if (!tsFileUpdated) {
-                (0, documentRegistry_1.forEachEmbeddeds)(sourceFile, embedded => {
-                    if (embedded.kind) {
-                        oldScripts[embedded.fileName] = embedded.text;
-                    }
-                });
-            }
-            languageModule.updateSourceFile(sourceFile, snapshot);
-            documentRegistry.onSourceFileUpdated(sourceFile);
-            if (!tsFileUpdated) {
-                (0, documentRegistry_1.forEachEmbeddeds)(sourceFile, embedded => {
-                    if (embedded.kind) {
-                        newScripts[embedded.fileName] = embedded.text;
+        for (const [_1, _2, virtualFile] of virtualFiles.all()) {
+            if (!shouldUpdateTsProject) {
+                (0, documentRegistry_1.forEachEmbeddedFile)(virtualFile, embedded => {
+                    var _a;
+                    if (embedded.kind === types_1.FileKind.TypeScriptHostFile) {
+                        if (virtualFileVersions.has(embedded.fileName) && ((_a = virtualFileVersions.get(embedded.fileName)) === null || _a === void 0 ? void 0 : _a.virtualFileSnapshot) !== embedded.snapshot) {
+                            shouldUpdateTsProject = true;
+                        }
                     }
                 });
             }
-            if (!tsFileUpdated
-                && Object.keys(oldScripts).length !== Object.keys(newScripts).length
-                || Object.keys(oldScripts).some(fileName => oldScripts[fileName] !== newScripts[fileName])) {
-                tsFileUpdated = true;
-            }
         }
-        if (tsFileUpdated) {
+        if (shouldUpdateTsProject) {
             tsProjectVersion++;
         }
     }
     function getScriptFileNames() {
         const tsFileNames = new Set();
-        for (const mapped of documentRegistry.getAllEmbeddeds()) {
-            if (mapped.embedded.kind) {
-                tsFileNames.add(mapped.embedded.fileName); // virtual .ts
-            }
+        for (const [_1, _2, sourceFile] of virtualFiles.all()) {
+            (0, documentRegistry_1.forEachEmbeddedFile)(sourceFile, embedded => {
+                if (embedded.kind === types_1.FileKind.TypeScriptHostFile) {
+                    tsFileNames.add(embedded.fileName); // virtual .ts
+                }
+            });
         }
         for (const fileName of host.getScriptFileNames()) {
-            if (host.isTsPlugin) {
-                tsFileNames.add(fileName); // .vue + .ts
-            }
-            else if (!documentRegistry.has(fileName)) {
+            if (!virtualFiles.hasSourceFile(fileName)) {
                 tsFileNames.add(fileName); // .ts
             }
         }
         return [...tsFileNames];
     }
     function getScriptVersion(fileName) {
-        var _a, _b, _c;
-        let mapped = documentRegistry.fromEmbeddedFileName(fileName);
-        if (mapped) {
-            if (fileVersions.has(mapped.embedded.fileName)) {
-                return fileVersions.get(mapped.embedded.fileName);
+        let source = virtualFiles.getSourceByVirtualFileName(fileName);
+        if (source) {
+            let version = virtualFileVersions.get(source[2].fileName);
+            if (!version) {
+                version = {
+                    value: 0,
+                    virtualFileSnapshot: source[2].snapshot,
+                    sourceFileSnapshot: source[1],
+                };
+                virtualFileVersions.set(source[2].fileName, version);
             }
-            else {
-                let version = (_c = (_b = (_a = ts.sys) === null || _a === void 0 ? void 0 : _a.createHash) === null || _b === void 0 ? void 0 : _b.call(_a, mapped.embedded.text)) !== null && _c !== void 0 ? _c : mapped.embedded.text;
-                if (host.isTsc) {
-                    // fix https://github.com/johnsoncodehk/volar/issues/1082
-                    version = host.getScriptVersion(mapped.sourceFile.fileName) + ':' + version;
-                }
-                fileVersions.set(mapped.embedded.fileName, version);
-                return version;
+            else if (version.virtualFileSnapshot !== source[2].snapshot
+                || (host.isTsc && version.sourceFileSnapshot !== source[1]) // fix https://github.com/johnsoncodehk/volar/issues/1082
+            ) {
+                version.value++;
+                version.virtualFileSnapshot = source[2].snapshot;
+                version.sourceFileSnapshot = source[1];
             }
+            return version.value.toString();
         }
         return host.getScriptVersion(fileName);
     }
@@ -246,9 +224,9 @@ function createEmbeddedLanguageServiceHost(host, languageModules) {
         if (cache && cache[0] === version) {
             return cache[1];
         }
-        const mapped = documentRegistry.fromEmbeddedFileName(fileName);
-        if (mapped) {
-            const snapshot = ts.ScriptSnapshot.fromString(mapped.embedded.text);
+        const source = virtualFiles.getSourceByVirtualFileName(fileName);
+        if (source) {
+            const snapshot = source[2].snapshot;
             scriptSnapshots.set(fileName.toLowerCase(), [version, snapshot]);
             return snapshot;
         }
@@ -259,5 +237,5 @@ function createEmbeddedLanguageServiceHost(host, languageModules) {
         }
     }
 }
-exports.createEmbeddedLanguageServiceHost = createEmbeddedLanguageServiceHost;
+exports.createLanguageContext = createLanguageContext;
 //# sourceMappingURL=languageContext.js.map

package/out/sourceMaps.d.ts

@@ -1,5 +1,5 @@
 import * as SourceMaps from '@volar/source-map';
-import { TeleportCapabilities, TeleportMappingData } from './types';
-export declare class Teleport extends SourceMaps.SourceMapBase<TeleportMappingData> {
-    findTeleports(start: number, filter?: (data: TeleportCapabilities) => boolean): Generator<number, void, unknown>;
+import { MirrorBehaviorCapabilities } from './types';
+export declare class MirrorMap extends SourceMaps.SourceMap<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]> {
+    findMirrorOffsets(start: number): Generator<readonly [number, MirrorBehaviorCapabilities], void, unknown>;
 }

package/out/sourceMaps.js

@@ -1,19 +1,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Teleport = void 0;
+exports.MirrorMap = void 0;
 const SourceMaps = require("@volar/source-map");
-class Teleport extends SourceMaps.SourceMapBase {
-    *findTeleports(start, filter) {
+class MirrorMap extends SourceMaps.SourceMap {
+    *findMirrorOffsets(start) {
         for (const mapped of this.toGeneratedOffsets(start)) {
-            if (!filter || filter(mapped[1].data.toSourceCapabilities)) {
-                yield mapped[0];
-            }
+            yield [mapped[0], mapped[1].data[1]];
         }
         for (const mapped of this.toSourceOffsets(start)) {
-            if (!filter || filter(mapped[1].data.toGenedCapabilities)) {
-                yield mapped[0];
-            }
+            yield [mapped[0], mapped[1].data[0]];
         }
     }
 }
-exports.Teleport = Teleport;
+exports.MirrorMap = MirrorMap;
 //# sourceMappingURL=sourceMaps.js.map

package/out/types.d.ts

@@ -1,6 +1,6 @@
 import { Mapping } from '@volar/source-map';
 import type * as ts from 'typescript/lib/tsserverlibrary';
-export interface DocumentCapabilities {
+export interface FileCapabilities {
     diagnostic?: boolean;
     foldingRange?: boolean;
     documentFormatting?: boolean | {
@@ -10,7 +10,7 @@ export interface DocumentCapabilities {
     codeAction?: boolean;
     inlayHint?: boolean;
 }
-export interface PositionCapabilities {
+export interface FileRangeCapabilities {
     hover?: boolean;
     references?: boolean;
     definition?: boolean;
@@ -27,41 +27,31 @@ export interface PositionCapabilities {
     referencesCodeLens?: boolean;
     displayWithLink?: boolean;
 }
-export interface TeleportCapabilities {
+export interface MirrorBehaviorCapabilities {
     references?: boolean;
     definition?: boolean;
     rename?: boolean;
 }
-export interface TeleportMappingData {
-    toSourceCapabilities: TeleportCapabilities;
-    toGenedCapabilities: TeleportCapabilities;
-}
-export interface TextRange {
-    start: number;
-    end: number;
-}
-export interface SourceFile extends EmbeddedFile {
-}
-export declare enum EmbeddedFileKind {
+export declare enum FileKind {
     TextFile = 0,
     TypeScriptHostFile = 1
 }
-export interface EmbeddedFile {
+export interface VirtualFile {
     fileName: string;
-    text: string;
-    kind: EmbeddedFileKind;
-    capabilities: DocumentCapabilities;
-    mappings: Mapping<PositionCapabilities>[];
-    teleportMappings?: Mapping<TeleportMappingData>[];
-    embeddeds: EmbeddedFile[];
-}
-export interface LanguageModule<T extends SourceFile = SourceFile> {
-    createSourceFile(fileName: string, snapshot: ts.IScriptSnapshot): T | undefined;
-    updateSourceFile(sourceFile: T, snapshot: ts.IScriptSnapshot): void;
+    snapshot: ts.IScriptSnapshot;
+    kind: FileKind;
+    capabilities: FileCapabilities;
+    mappings: Mapping<FileRangeCapabilities>[];
+    mirrorBehaviorMappings?: Mapping<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]>[];
+    embeddedFiles: VirtualFile[];
+}
+export interface LanguageModule<T extends VirtualFile = VirtualFile> {
+    createFile(fileName: string, snapshot: ts.IScriptSnapshot): T | undefined;
+    updateFile(virtualFile: T, snapshot: ts.IScriptSnapshot): void;
+    deleteFile?(virtualFile: T): void;
     proxyLanguageServiceHost?(host: LanguageServiceHost): Partial<LanguageServiceHost>;
 }
-export type LanguageServiceHost = ts.LanguageServiceHost & {
+export interface LanguageServiceHost extends ts.LanguageServiceHost {
     getTypeScriptModule(): typeof import('typescript/lib/tsserverlibrary');
-    isTsPlugin?: boolean;
     isTsc?: boolean;
-};
+}

package/out/types.js

@@ -1,8 +1,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmbeddedFileKind = void 0;
-var EmbeddedFileKind;
-(function (EmbeddedFileKind) {
-    EmbeddedFileKind[EmbeddedFileKind["TextFile"] = 0] = "TextFile";
-    EmbeddedFileKind[EmbeddedFileKind["TypeScriptHostFile"] = 1] = "TypeScriptHostFile";
-})(EmbeddedFileKind = exports.EmbeddedFileKind || (exports.EmbeddedFileKind = {}));
+exports.FileKind = void 0;
+var FileKind;
+(function (FileKind) {
+    FileKind[FileKind["TextFile"] = 0] = "TextFile";
+    FileKind[FileKind["TypeScriptHostFile"] = 1] = "TypeScriptHostFile";
+})(FileKind = exports.FileKind || (exports.FileKind = {}));
+;
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/language-core",
-	"version": "1.0.14",
+	"version": "1.0.17",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,9 +13,9 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/source-map": "1.0.14",
+		"@volar/source-map": "1.0.17",
 		"@vue/reactivity": "^3.2.45",
 		"muggle-string": "^0.1.0"
 	},
-	"gitHead": "ce4d48b37db784400e15fe08282edc836e24d4cd"
+	"gitHead": "b66b64f579b5cafee9b8d70aa9f9303f39b6df49"
 }