@volar/language-core 1.6.9 → 1.7.1

package/out/languageContext.d.ts

@@ -1,21 +1,7 @@
-import type * as ts from 'typescript/lib/tsserverlibrary';
-import { Language, LanguageServiceHost } from './types';
-export type LanguageContext = ReturnType<typeof createLanguageContext>;
-export declare function createLanguageContext(modules: {
-    typescript?: typeof import('typescript/lib/tsserverlibrary');
-}, host: LanguageServiceHost, languages: Language[]): {
-    typescript: {
-        languageServiceHost: ts.LanguageServiceHost;
-    };
-    virtualFiles: {
-        allSources(): import("./virtualFiles").Source[];
-        updateSource(fileName: string, snapshot: ts.IScriptSnapshot, languageId: string | undefined): import("./types").VirtualFile | undefined;
-        deleteSource(fileName: string): void;
-        getSource(fileName: string): import("./virtualFiles").Source | undefined;
-        hasSource: (fileName: string) => boolean;
-        getMirrorMap: (file: import("./types").VirtualFile) => import("./sourceMaps").MirrorMap | undefined;
-        getMaps: (virtualFile: import("./types").VirtualFile) => [string, import("@volar/source-map").SourceMap<import("./types").FileRangeCapabilities>][];
-        hasVirtualFile(fileName: string): boolean;
-        getVirtualFile(fileName: string): readonly [import("./types").VirtualFile, import("./virtualFiles").Source] | readonly [undefined, undefined];
-    };
-};
+import { createVirtualFiles } from './virtualFiles';
+import { Language, TypeScriptLanguageHost } from './types';
+export interface LanguageContext {
+    host: TypeScriptLanguageHost;
+    virtualFiles: ReturnType<typeof createVirtualFiles>;
+}
+export declare function createLanguageContext(host: TypeScriptLanguageHost, languages: Language<any>[]): LanguageContext;

package/out/languageContext.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLanguageContext = void 0;
-const path_1 = require("path");
 const virtualFiles_1 = require("./virtualFiles");
-const types_1 = require("./types");
-function createLanguageContext(modules, host, languages) {
+;
+function createLanguageContext(host, languages) {
     for (const language of languages.reverse()) {
         if (language.resolveHost) {
             const pastHost = host;
@@ -24,257 +23,41 @@ function createLanguageContext(modules, host, languages) {
         }
     }
     let lastProjectVersion;
-    let tsProjectVersion = 0;
     const virtualFiles = (0, virtualFiles_1.createVirtualFiles)(languages);
-    const ts = modules.typescript;
-    const scriptSnapshots = new Map();
-    const sourceTsFileVersions = new Map();
-    const sourceFileVersions = new Map();
-    const virtualFileVersions = new Map();
-    const _tsHost = {
-        fileExists: host.fileExists
-            ? fileName => {
-                const ext = fileName.substring(fileName.lastIndexOf('.'));
-                if (ext === '.js'
-                    || ext === '.ts'
-                    || ext === '.jsx'
-                    || ext === '.tsx') {
-                    /**
-                     * If try to access a external .vue file that outside of the project,
-                     * the file will not process by language service host,
-                     * so virtual file will not be created.
-                     *
-                     * We try to create virtual file here.
-                     */
-                    const sourceFileName = fileName.substring(0, fileName.lastIndexOf('.'));
-                    if (!virtualFiles.hasSource(sourceFileName)) {
-                        const scriptSnapshot = host.getScriptSnapshot(sourceFileName);
-                        if (scriptSnapshot) {
-                            virtualFiles.updateSource(sourceFileName, scriptSnapshot, host.getScriptLanguageId?.(sourceFileName));
-                        }
-                    }
-                }
-                if (virtualFiles.hasVirtualFile(fileName)) {
-                    return true;
-                }
-                return !!host.fileExists?.(fileName);
-            }
-            : undefined,
-        getProjectVersion: () => {
-            return host.getTypeRootsVersion?.() + ':' + tsProjectVersion.toString();
-        },
-        getTypeRootsVersion: host.getTypeRootsVersion,
-        getScriptFileNames,
-        getScriptVersion,
-        getScriptSnapshot,
-        readDirectory: (_path, extensions, exclude, include, depth) => {
-            const result = host.readDirectory?.(_path, extensions, exclude, include, depth) ?? [];
-            for (const { fileName } of virtualFiles.allSources()) {
-                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 && fileName.toLowerCase() === vuePath2.toLowerCase()) {
-                    result.push(vuePath2);
-                }
-                else if (depth) {
-                    result.push(vuePath2); // TODO: depth num
-                }
-            }
-            return result;
-        },
-        getScriptKind(fileName) {
-            if (ts) {
-                if (virtualFiles.hasSource(fileName))
-                    return ts.ScriptKind.Deferred;
-                switch (path_1.posix.extname(fileName)) {
-                    case '.js': return ts.ScriptKind.JS;
-                    case '.jsx': return ts.ScriptKind.JSX;
-                    case '.ts': return ts.ScriptKind.TS;
-                    case '.tsx': return ts.ScriptKind.TSX;
-                    case '.json': return ts.ScriptKind.JSON;
-                    default: return ts.ScriptKind.Unknown;
-                }
-            }
-            return 0;
-        },
-    };
     return {
-        typescript: {
-            languageServiceHost: new Proxy(_tsHost, {
-                get: (target, property) => {
-                    update();
-                    return target[property] || host[property];
-                },
-            }),
-        },
+        host,
         virtualFiles: new Proxy(virtualFiles, {
             get: (target, property) => {
-                update();
+                syncVirtualFiles();
                 return target[property];
             },
         }),
     };
-    function update() {
-        const newProjectVersion = host.getProjectVersion?.();
-        const shouldUpdate = newProjectVersion === undefined || newProjectVersion !== lastProjectVersion;
-        lastProjectVersion = newProjectVersion;
+    function syncVirtualFiles() {
+        const newProjectVersion = host.getProjectVersion();
+        const shouldUpdate = newProjectVersion !== lastProjectVersion;
         if (!shouldUpdate)
             return;
-        let shouldUpdateTsProject = false;
-        let virtualFilesUpdatedNum = 0;
+        lastProjectVersion = newProjectVersion;
         const remainRootFiles = new Set(host.getScriptFileNames());
-        const oldVirtualTsFileNames = new Set();
-        const newVirtualTsFileNames = new Set();
-        for (const { root: rootVirtualFile } of virtualFiles.allSources()) {
-            (0, virtualFiles_1.forEachEmbeddedFile)(rootVirtualFile, embedded => {
-                if (embedded.kind === types_1.FileKind.TypeScriptHostFile) {
-                    oldVirtualTsFileNames.add(embedded.fileName);
-                }
-            });
-        }
-        // .vue
-        for (const { fileName } of virtualFiles.allSources()) {
+        for (const { fileName, snapshot } of virtualFiles.allSources()) {
             remainRootFiles.delete(fileName);
-            const snapshot = host.getScriptSnapshot(fileName);
-            if (!snapshot) {
+            const newSnapshot = host.getScriptSnapshot(fileName);
+            if (!newSnapshot) {
                 // delete
                 virtualFiles.deleteSource(fileName);
-                shouldUpdateTsProject = true;
-                virtualFilesUpdatedNum++;
-                continue;
             }
-            const newVersion = host.getScriptVersion(fileName);
-            if (sourceFileVersions.get(fileName) !== newVersion) {
+            else if (newSnapshot !== snapshot) {
                 // update
-                sourceFileVersions.set(fileName, newVersion);
-                virtualFiles.updateSource(fileName, snapshot, host.getScriptLanguageId?.(fileName));
-                virtualFilesUpdatedNum++;
+                virtualFiles.updateSource(fileName, newSnapshot, host.getLanguageId?.(fileName));
             }
         }
-        // no any vue file version change, it mean project version was update by ts file change at this time
-        if (!virtualFilesUpdatedNum) {
-            shouldUpdateTsProject = true;
-        }
-        // add
+        // create
         for (const fileName of [...remainRootFiles]) {
             const snapshot = host.getScriptSnapshot(fileName);
             if (snapshot) {
-                const virtualFile = virtualFiles.updateSource(fileName, snapshot, host.getScriptLanguageId?.(fileName));
-                if (virtualFile) {
-                    remainRootFiles.delete(fileName);
-                }
-            }
-        }
-        // .ts / .js / .d.ts / .json ...
-        for (const [oldTsFileName, oldTsFileVersion] of [...sourceTsFileVersions]) {
-            const newVersion = host.getScriptVersion(oldTsFileName);
-            if (oldTsFileVersion !== newVersion) {
-                if (!remainRootFiles.has(oldTsFileName) && !host.getScriptSnapshot(oldTsFileName)) {
-                    // delete
-                    sourceTsFileVersions.delete(oldTsFileName);
-                }
-                else {
-                    // update
-                    sourceTsFileVersions.set(oldTsFileName, newVersion);
-                }
-                shouldUpdateTsProject = true;
-            }
-        }
-        for (const nowFileName of remainRootFiles) {
-            if (!sourceTsFileVersions.has(nowFileName)) {
-                // add
-                const newVersion = host.getScriptVersion(nowFileName);
-                sourceTsFileVersions.set(nowFileName, newVersion);
-                shouldUpdateTsProject = true;
-            }
-        }
-        // check virtual file update
-        if (!shouldUpdateTsProject) {
-            for (const { root: rootVirtualFile } of virtualFiles.allSources()) {
-                (0, virtualFiles_1.forEachEmbeddedFile)(rootVirtualFile, embedded => {
-                    if (embedded.kind === types_1.FileKind.TypeScriptHostFile) {
-                        newVirtualTsFileNames.add(embedded.fileName);
-                        if (virtualFileVersions.has(embedded.fileName) && virtualFileVersions.get(embedded.fileName)?.virtualFileSnapshot !== embedded.snapshot) {
-                            shouldUpdateTsProject = true;
-                        }
-                    }
-                });
-            }
-        }
-        // check virtual file create / delete
-        if (!shouldUpdateTsProject) {
-            if (oldVirtualTsFileNames.size !== newVirtualTsFileNames.size) {
-                shouldUpdateTsProject = true;
-            }
-            else {
-                for (const fileName of oldVirtualTsFileNames) {
-                    if (!newVirtualTsFileNames.has(fileName)) {
-                        shouldUpdateTsProject = true;
-                        break;
-                    }
-                }
-            }
-        }
-        if (shouldUpdateTsProject) {
-            tsProjectVersion++;
-        }
-    }
-    function getScriptFileNames() {
-        const tsFileNames = new Set();
-        for (const { root: rootVirtualFile } of virtualFiles.allSources()) {
-            (0, virtualFiles_1.forEachEmbeddedFile)(rootVirtualFile, embedded => {
-                if (embedded.kind === types_1.FileKind.TypeScriptHostFile) {
-                    tsFileNames.add(embedded.fileName); // virtual .ts
-                }
-            });
-        }
-        for (const fileName of host.getScriptFileNames()) {
-            if (!virtualFiles.hasSource(fileName)) {
-                tsFileNames.add(fileName); // .ts
-            }
-        }
-        return [...tsFileNames];
-    }
-    function getScriptVersion(fileName) {
-        let [virtualFile, source] = virtualFiles.getVirtualFile(fileName);
-        if (virtualFile && source) {
-            let version = virtualFileVersions.get(virtualFile.fileName);
-            if (!version) {
-                version = {
-                    value: 0,
-                    virtualFileSnapshot: virtualFile.snapshot,
-                    sourceFileSnapshot: source.snapshot,
-                };
-                virtualFileVersions.set(virtualFile.fileName, version);
-            }
-            else if (version.virtualFileSnapshot !== virtualFile.snapshot
-                || (host.isTsc && version.sourceFileSnapshot !== source.snapshot) // fix https://github.com/johnsoncodehk/volar/issues/1082
-            ) {
-                version.value++;
-                version.virtualFileSnapshot = virtualFile.snapshot;
-                version.sourceFileSnapshot = source.snapshot;
+                virtualFiles.updateSource(fileName, snapshot, host.getLanguageId?.(fileName));
             }
-            return version.value.toString();
-        }
-        return host.getScriptVersion(fileName);
-    }
-    function getScriptSnapshot(fileName) {
-        const version = getScriptVersion(fileName);
-        const cache = scriptSnapshots.get(fileName.toLowerCase());
-        if (cache && cache[0] === version) {
-            return cache[1];
-        }
-        const [virtualFile] = virtualFiles.getVirtualFile(fileName);
-        if (virtualFile) {
-            const snapshot = virtualFile.snapshot;
-            scriptSnapshots.set(fileName.toLowerCase(), [version, snapshot]);
-            return snapshot;
-        }
-        let tsScript = host.getScriptSnapshot(fileName);
-        if (tsScript) {
-            scriptSnapshots.set(fileName.toLowerCase(), [version, tsScript]);
-            return tsScript;
         }
     }
 }

package/out/types.d.ts

@@ -56,12 +56,22 @@ export interface VirtualFile {
     embeddedFiles: VirtualFile[];
 }
 export interface Language<T extends VirtualFile = VirtualFile> {
-    resolveHost?(host: LanguageServiceHost): LanguageServiceHost;
+    resolveHost?(host: TypeScriptLanguageHost): TypeScriptLanguageHost;
     createVirtualFile(fileName: string, snapshot: ts.IScriptSnapshot, languageId: string | undefined): T | undefined;
     updateVirtualFile(virtualFile: T, snapshot: ts.IScriptSnapshot): void;
     deleteVirtualFile?(virtualFile: T): void;
 }
-export interface LanguageServiceHost extends ts.LanguageServiceHost {
-    getScriptLanguageId?(fileName: string): string | undefined;
-    isTsc?: boolean;
+interface LanguageHost {
+    getProjectVersion(): number | string;
+    getScriptFileNames(): string[];
+    getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined;
+    getLanguageId?(fileName: string): string | undefined;
 }
+export interface TypeScriptLanguageHost extends LanguageHost {
+    getCurrentDirectory(): string;
+    getCancellationToken?(): ts.CancellationToken;
+    getLocalizedDiagnosticMessages?: () => any;
+    getCompilationSettings(): ts.CompilerOptions;
+    getProjectReferences?(): readonly ts.ProjectReference[] | undefined;
+}
+export {};

package/out/virtualFiles.d.ts

@@ -17,8 +17,9 @@ export declare function createVirtualFiles(languages: Language[]): {
     getSource(fileName: string): Source | undefined;
     hasSource: (fileName: string) => boolean;
     getMirrorMap: (file: VirtualFile) => MirrorMap | undefined;
-    getMaps: (virtualFile: VirtualFile) => [string, SourceMap<FileRangeCapabilities>][];
+    getMaps: (virtualFile: VirtualFile) => Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>;
     hasVirtualFile(fileName: string): boolean;
     getVirtualFile(fileName: string): readonly [VirtualFile, Source] | readonly [undefined, undefined];
 };
+export declare function updateVirtualFileMaps(virtualFile: VirtualFile, getSourceSnapshot: (source: string | undefined) => [string, ts.IScriptSnapshot] | undefined, map?: Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>): Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>;
 export declare function forEachEmbeddedFile(file: VirtualFile, cb: (embedded: VirtualFile) => void): void;

package/out/virtualFiles.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.forEachEmbeddedFile = exports.createVirtualFiles = void 0;
+exports.forEachEmbeddedFile = exports.updateVirtualFileMaps = exports.createVirtualFiles = void 0;
 const source_map_1 = require("@volar/source-map");
 const sourceMaps_1 = require("./sourceMaps");
 function createVirtualFiles(languages) {
@@ -81,21 +81,17 @@ function createVirtualFiles(languages) {
         if (!virtualFileMaps.has(virtualFile.snapshot)) {
             virtualFileMaps.set(virtualFile.snapshot, new Map());
         }
-        const map = virtualFileMaps.get(virtualFile.snapshot);
-        const sources = new Set();
-        const result = [];
-        for (const mapping of virtualFile.mappings) {
-            if (sources.has(mapping.source))
-                continue;
-            sources.add(mapping.source);
-            const sourceFileName = mapping.source ?? getVirtualFileToSourceFileMap().get(normalizePath(virtualFile.fileName)).source.fileName;
-            const sourceSnapshot = mapping.source ? sourceFiles.get(normalizePath(mapping.source)).snapshot : getVirtualFileToSourceFileMap().get(normalizePath(virtualFile.fileName)).source.snapshot;
-            if (!map.has(sourceSnapshot)) {
-                map.set(sourceSnapshot, [sourceFileName, new source_map_1.SourceMap(virtualFile.mappings.filter(mapping2 => mapping2.source === mapping.source))]);
+        updateVirtualFileMaps(virtualFile, sourceFileName => {
+            if (sourceFileName) {
+                const source = sourceFiles.get(normalizePath(sourceFileName));
+                return [sourceFileName, source.snapshot];
             }
-            result.push(map.get(sourceSnapshot));
-        }
-        return result;
+            else {
+                const source = getVirtualFileToSourceFileMap().get(normalizePath(virtualFile.fileName)).source;
+                return [source.fileName, source.snapshot];
+            }
+        }, virtualFileMaps.get(virtualFile.snapshot));
+        return virtualFileMaps.get(virtualFile.snapshot);
     }
     function getMirrorMap(file) {
         if (!virtualFileToMirrorMap.has(file.snapshot)) {
@@ -105,6 +101,22 @@ function createVirtualFiles(languages) {
     }
 }
 exports.createVirtualFiles = createVirtualFiles;
+function updateVirtualFileMaps(virtualFile, getSourceSnapshot, map = new Map()) {
+    const sources = new Set();
+    for (const mapping of virtualFile.mappings) {
+        if (sources.has(mapping.source))
+            continue;
+        sources.add(mapping.source);
+        const source = getSourceSnapshot(mapping.source);
+        if (!source)
+            continue;
+        if (!map.has(source[0]) || map.get(source[0])[0] !== source[1]) {
+            map.set(source[0], [source[1], new source_map_1.SourceMap(virtualFile.mappings.filter(mapping2 => mapping2.source === mapping.source))]);
+        }
+    }
+    return map;
+}
+exports.updateVirtualFileMaps = updateVirtualFileMaps;
 function forEachEmbeddedFile(file, cb) {
     cb(file);
     for (const embeddedFile of file.embeddedFiles) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/language-core",
-	"version": "1.6.9",
+	"version": "1.7.1",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,7 +13,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/source-map": "1.6.9"
+		"@volar/source-map": "1.7.1"
 	},
-	"gitHead": "e676fa08e4186bd2f8cc14861ef65f8d8c855ea1"
+	"gitHead": "6d092d684c65ce43af8a401bc90d0b2769a2bf49"
 }