@volar/typescript 1.6.9 → 1.7.1-patch.1

package/out/languageService.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageService = void 0;
+const language_core_1 = require("@volar/language-core");
+const getProgram_1 = require("./getProgram");
+const languageServiceHost_1 = require("./languageServiceHost");
+const documentRegistry_1 = require("./documentRegistry");
+function createLanguageService(core, ts, sys) {
+    if (!ts) {
+        throw new Error('TypeScript module not provided.');
+    }
+    const lsHost = (0, languageServiceHost_1.createLanguageServiceHost)(core, ts, sys);
+    const ls = ts.createLanguageService(lsHost, (0, documentRegistry_1.getDocumentRegistry)(ts, sys.useCaseSensitiveFileNames, core.host.getCurrentDirectory()));
+    return new Proxy({
+        organizeImports,
+        // only support for .ts for now, not support for .vue
+        getDefinitionAtPosition,
+        getDefinitionAndBoundSpan,
+        getTypeDefinitionAtPosition,
+        getImplementationAtPosition,
+        findRenameLocations,
+        getReferencesAtPosition,
+        findReferences,
+        // TODO: now is handled by vue server
+        // prepareCallHierarchy: tsLanguageService.rawLs.prepareCallHierarchy,
+        // provideCallHierarchyIncomingCalls: tsLanguageService.rawLs.provideCallHierarchyIncomingCalls,
+        // provideCallHierarchyOutgoingCalls: tsLanguageService.rawLs.provideCallHierarchyOutgoingCalls,
+        // getEditsForFileRename: tsLanguageService.rawLs.getEditsForFileRename,
+        // TODO
+        // getCodeFixesAtPosition: tsLanguageService.rawLs.getCodeFixesAtPosition,
+        // getCombinedCodeFix: tsLanguageService.rawLs.getCombinedCodeFix,
+        // applyCodeActionCommand: tsLanguageService.rawLs.applyCodeActionCommand,
+        // getApplicableRefactors: tsLanguageService.rawLs.getApplicableRefactors,
+        // getEditsForRefactor: tsLanguageService.rawLs.getEditsForRefactor,
+        getProgram: () => (0, getProgram_1.getProgram)(ts, core, ls, lsHost),
+        __internal__: {
+            context: core,
+            languageService: ls,
+            languageServiceHost: lsHost,
+        },
+    }, {
+        get: (target, property) => {
+            if (property in target) {
+                return target[property];
+            }
+            return ls[property];
+        },
+    });
+    // apis
+    function organizeImports(args, formatOptions, preferences) {
+        let edits = [];
+        const file = core.virtualFiles.getSource(args.fileName)?.root;
+        if (file) {
+            (0, language_core_1.forEachEmbeddedFile)(file, embeddedFile => {
+                if (embeddedFile.kind === language_core_1.FileKind.TypeScriptHostFile && embeddedFile.capabilities.codeAction) {
+                    edits = edits.concat(ls.organizeImports({
+                        ...args,
+                        fileName: embeddedFile.fileName,
+                    }, formatOptions, preferences));
+                }
+            });
+        }
+        else {
+            return ls.organizeImports(args, formatOptions, preferences);
+        }
+        return edits.map(transformFileTextChanges).filter(notEmpty);
+    }
+    function getReferencesAtPosition(fileName, position) {
+        return findLocations(fileName, position, 'references');
+    }
+    function getDefinitionAtPosition(fileName, position) {
+        return findLocations(fileName, position, 'definition');
+    }
+    function getTypeDefinitionAtPosition(fileName, position) {
+        return findLocations(fileName, position, 'typeDefinition');
+    }
+    function getImplementationAtPosition(fileName, position) {
+        return findLocations(fileName, position, 'implementation');
+    }
+    function findRenameLocations(fileName, position, findInStrings, findInComments, preferences) {
+        return findLocations(fileName, position, 'rename', findInStrings, findInComments, preferences);
+    }
+    function findLocations(fileName, position, mode, findInStrings = false, findInComments = false, preferences) {
+        const loopChecker = new Set();
+        let symbols = [];
+        withMirrors(fileName, position);
+        return symbols.map(s => transformDocumentSpanLike(s)).filter(notEmpty);
+        function withMirrors(fileName, position) {
+            if (loopChecker.has(fileName + ':' + position))
+                return;
+            loopChecker.add(fileName + ':' + position);
+            const _symbols = mode === 'definition' ? ls.getDefinitionAtPosition(fileName, position)
+                : mode === 'typeDefinition' ? ls.getTypeDefinitionAtPosition(fileName, position)
+                    : mode === 'references' ? ls.getReferencesAtPosition(fileName, position)
+                        : mode === 'implementation' ? ls.getImplementationAtPosition(fileName, position)
+                            // @ts-expect-error
+                            : mode === 'rename' && preferences ? ls.findRenameLocations(fileName, position, findInStrings, findInComments, preferences)
+                                : undefined;
+            if (!_symbols)
+                return;
+            symbols = symbols.concat(_symbols);
+            for (const ref of _symbols) {
+                loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
+                const [virtualFile] = core.virtualFiles.getVirtualFile(ref.fileName);
+                if (!virtualFile)
+                    continue;
+                const mirrorMap = core.virtualFiles.getMirrorMap(virtualFile);
+                if (!mirrorMap)
+                    continue;
+                for (const [mirrorOffset, data] of mirrorMap.findMirrorOffsets(ref.textSpan.start)) {
+                    if ((mode === 'definition' || mode === 'typeDefinition' || mode === 'implementation') && !data.definition)
+                        continue;
+                    if ((mode === 'references') && !data.references)
+                        continue;
+                    if ((mode === 'rename') && !data.rename)
+                        continue;
+                    if (loopChecker.has(ref.fileName + ':' + mirrorOffset))
+                        continue;
+                    withMirrors(ref.fileName, mirrorOffset);
+                }
+            }
+        }
+    }
+    function getDefinitionAndBoundSpan(fileName, position) {
+        const loopChecker = new Set();
+        let textSpan;
+        let symbols = [];
+        withMirrors(fileName, position);
+        if (!textSpan)
+            return;
+        return {
+            textSpan: textSpan,
+            definitions: symbols?.map(s => transformDocumentSpanLike(s)).filter(notEmpty),
+        };
+        function withMirrors(fileName, position) {
+            if (loopChecker.has(fileName + ':' + position))
+                return;
+            loopChecker.add(fileName + ':' + position);
+            const _symbols = ls.getDefinitionAndBoundSpan(fileName, position);
+            if (!_symbols)
+                return;
+            if (!textSpan) {
+                textSpan = _symbols.textSpan;
+            }
+            if (!_symbols.definitions)
+                return;
+            symbols = symbols.concat(_symbols.definitions);
+            for (const ref of _symbols.definitions) {
+                loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
+                const [virtualFile] = core.virtualFiles.getVirtualFile(ref.fileName);
+                if (!virtualFile)
+                    continue;
+                const mirrorMap = core.virtualFiles.getMirrorMap(virtualFile);
+                if (!mirrorMap)
+                    continue;
+                for (const [mirrorOffset, data] of mirrorMap.findMirrorOffsets(ref.textSpan.start)) {
+                    if (!data.definition)
+                        continue;
+                    if (loopChecker.has(ref.fileName + ':' + mirrorOffset))
+                        continue;
+                    withMirrors(ref.fileName, mirrorOffset);
+                }
+            }
+        }
+    }
+    function findReferences(fileName, position) {
+        const loopChecker = new Set();
+        let symbols = [];
+        withMirrors(fileName, position);
+        return symbols.map(s => transformReferencedSymbol(s)).filter(notEmpty);
+        function withMirrors(fileName, position) {
+            if (loopChecker.has(fileName + ':' + position))
+                return;
+            loopChecker.add(fileName + ':' + position);
+            const _symbols = ls.findReferences(fileName, position);
+            if (!_symbols)
+                return;
+            symbols = symbols.concat(_symbols);
+            for (const symbol of _symbols) {
+                for (const ref of symbol.references) {
+                    loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
+                    const [virtualFile] = core.virtualFiles.getVirtualFile(ref.fileName);
+                    if (!virtualFile)
+                        continue;
+                    const mirrorMap = core.virtualFiles.getMirrorMap(virtualFile);
+                    if (!mirrorMap)
+                        continue;
+                    for (const [mirrorOffset, data] of mirrorMap.findMirrorOffsets(ref.textSpan.start)) {
+                        if (!data.references)
+                            continue;
+                        if (loopChecker.has(ref.fileName + ':' + mirrorOffset))
+                            continue;
+                        withMirrors(ref.fileName, mirrorOffset);
+                    }
+                }
+            }
+        }
+    }
+    // transforms
+    function transformFileTextChanges(changes) {
+        const [_, source] = core.virtualFiles.getVirtualFile(changes.fileName);
+        if (source) {
+            return {
+                ...changes,
+                fileName: source.fileName,
+                textChanges: changes.textChanges.map(c => {
+                    const span = transformSpan(changes.fileName, c.span);
+                    if (span) {
+                        return {
+                            ...c,
+                            span: span.textSpan,
+                        };
+                    }
+                }).filter(notEmpty),
+            };
+        }
+        else {
+            return changes;
+        }
+    }
+    function transformReferencedSymbol(symbol) {
+        const definition = transformDocumentSpanLike(symbol.definition);
+        const references = symbol.references.map(r => transformDocumentSpanLike(r)).filter(notEmpty);
+        if (definition) {
+            return {
+                definition,
+                references,
+            };
+        }
+        else if (references.length) { // TODO: remove patching
+            return {
+                definition: {
+                    ...symbol.definition,
+                    fileName: references[0].fileName,
+                    textSpan: references[0].textSpan,
+                },
+                references,
+            };
+        }
+    }
+    function transformDocumentSpanLike(documentSpan) {
+        const textSpan = transformSpan(documentSpan.fileName, documentSpan.textSpan);
+        if (!textSpan)
+            return;
+        const contextSpan = transformSpan(documentSpan.fileName, documentSpan.contextSpan);
+        const originalTextSpan = transformSpan(documentSpan.originalFileName, documentSpan.originalTextSpan);
+        const originalContextSpan = transformSpan(documentSpan.originalFileName, documentSpan.originalContextSpan);
+        return {
+            ...documentSpan,
+            fileName: textSpan.fileName,
+            textSpan: textSpan.textSpan,
+            contextSpan: contextSpan?.textSpan,
+            originalFileName: originalTextSpan?.fileName,
+            originalTextSpan: originalTextSpan?.textSpan,
+            originalContextSpan: originalContextSpan?.textSpan,
+        };
+    }
+    function transformSpan(fileName, textSpan) {
+        if (!fileName)
+            return;
+        if (!textSpan)
+            return;
+        const [virtualFile, source] = core.virtualFiles.getVirtualFile(fileName);
+        if (virtualFile && source) {
+            for (const [_, [sourceSnapshot, map]] of core.virtualFiles.getMaps(virtualFile)) {
+                if (source.snapshot !== sourceSnapshot)
+                    continue;
+                const sourceLoc = map.toSourceOffset(textSpan.start);
+                if (sourceLoc) {
+                    return {
+                        fileName: source.fileName,
+                        textSpan: {
+                            start: sourceLoc[0],
+                            length: textSpan.length,
+                        },
+                    };
+                }
+            }
+        }
+        else {
+            return {
+                fileName,
+                textSpan,
+            };
+        }
+    }
+}
+exports.createLanguageService = createLanguageService;
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=languageService.js.map

package/out/languageServiceHost.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageContext } from '@volar/language-service';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function createLanguageServiceHost(ctx: LanguageContext, ts: typeof import('typescript/lib/tsserverlibrary'), sys: ts.System & {
+    version?: number;
+}): ts.LanguageServiceHost;

package/out/languageServiceHost.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageServiceHost = void 0;
+const path_1 = require("path");
+function createLanguageServiceHost(ctx, ts, sys) {
+    let lastProjectVersion;
+    let tsProjectVersion = 0;
+    const _tsHost = {
+        ...sys,
+        getCurrentDirectory: ctx.host.getCurrentDirectory,
+        getCancellationToken: ctx.host.getCancellationToken,
+        getLocalizedDiagnosticMessages: ctx.host.getLocalizedDiagnosticMessages,
+        getCompilationSettings: ctx.host.getCompilationSettings,
+        getProjectReferences: ctx.host.getProjectReferences,
+        getDefaultLibFileName: (options) => {
+            try {
+                return ts.getDefaultLibFilePath(options);
+            }
+            catch {
+                // web
+                return `/node_modules/typescript/lib/${ts.getDefaultLibFileName(options)}`;
+            }
+        },
+        useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
+        getNewLine: () => sys.newLine,
+        readFile: fileName => {
+            const snapshot = getScriptSnapshot(fileName);
+            if (snapshot) {
+                return snapshot.getText(0, snapshot.getLength());
+            }
+        },
+        fileExists,
+        getProjectVersion: () => {
+            return tsProjectVersion.toString() + ':' + sys.version;
+        },
+        getTypeRootsVersion: () => {
+            return sys.version ?? -1; // TODO: only update for /node_modules changes?
+        },
+        getScriptFileNames,
+        getScriptVersion,
+        getScriptSnapshot,
+        getScriptKind(fileName) {
+            if (ts) {
+                if (ctx.virtualFiles.hasSource(fileName))
+                    return ts.ScriptKind.Deferred;
+                switch (path_1.posix.extname(fileName)) {
+                    case '.js': return ts.ScriptKind.JS;
+                    case '.cjs': return ts.ScriptKind.JS;
+                    case '.mjs': return ts.ScriptKind.JS;
+                    case '.jsx': return ts.ScriptKind.JSX;
+                    case '.ts': return ts.ScriptKind.TS;
+                    case '.cts': return ts.ScriptKind.TS;
+                    case '.mts': return ts.ScriptKind.TS;
+                    case '.tsx': return ts.ScriptKind.TSX;
+                    case '.json': return ts.ScriptKind.JSON;
+                    default: return ts.ScriptKind.Unknown;
+                }
+            }
+            return 0;
+        },
+    };
+    const fsFileSnapshots = new Map();
+    const fileVersions = new Map();
+    let oldTsVirtualFileSnapshots = new Set();
+    let oldOtherVirtualFileSnapshots = new Set();
+    return new Proxy(_tsHost, {
+        get: (target, property) => {
+            sync();
+            return target[property];
+        },
+    });
+    function sync() {
+        const newProjectVersion = ctx.host.getProjectVersion();
+        const shouldUpdate = newProjectVersion !== lastProjectVersion;
+        if (!shouldUpdate)
+            return;
+        lastProjectVersion = newProjectVersion;
+        const newTsVirtualFileSnapshots = new Set();
+        const newOtherVirtualFileSnapshots = new Set();
+        for (const { root } of ctx.virtualFiles.allSources()) {
+            forEachEmbeddedFile(root, embedded => {
+                if (embedded.kind === 1) {
+                    newTsVirtualFileSnapshots.add(embedded.snapshot);
+                }
+                else {
+                    newOtherVirtualFileSnapshots.add(embedded.snapshot);
+                }
+            });
+        }
+        if (!setEquals(oldTsVirtualFileSnapshots, newTsVirtualFileSnapshots)) {
+            tsProjectVersion++;
+        }
+        else if (setEquals(oldOtherVirtualFileSnapshots, newOtherVirtualFileSnapshots)) {
+            // no any meta language files update, it mean project version was update by source files this time
+            tsProjectVersion++;
+        }
+        oldTsVirtualFileSnapshots = newTsVirtualFileSnapshots;
+        oldOtherVirtualFileSnapshots = newOtherVirtualFileSnapshots;
+    }
+    function getScriptFileNames() {
+        const tsFileNames = new Set();
+        for (const { root } of ctx.virtualFiles.allSources()) {
+            forEachEmbeddedFile(root, embedded => {
+                if (embedded.kind === 1) {
+                    tsFileNames.add(embedded.fileName); // virtual .ts
+                }
+            });
+        }
+        for (const fileName of ctx.host.getScriptFileNames()) {
+            if (!ctx.virtualFiles.hasSource(fileName)) {
+                tsFileNames.add(fileName); // .ts
+            }
+        }
+        return [...tsFileNames];
+    }
+    function getScriptSnapshot(fileName) {
+        // virtual files
+        const [virtualFile] = ctx.virtualFiles.getVirtualFile(fileName);
+        if (virtualFile) {
+            return virtualFile.snapshot;
+        }
+        // root files / opened files
+        const tsScript = ctx.host.getScriptSnapshot(fileName);
+        if (tsScript) {
+            return tsScript;
+        }
+        // fs files
+        const cache = fsFileSnapshots.get(fileName);
+        const modifiedTime = sys.getModifiedTime?.(fileName)?.valueOf();
+        if (!cache || cache[0] !== modifiedTime) {
+            if (sys.fileExists(fileName)) {
+                const text = sys.readFile(fileName);
+                const snapshot = text !== undefined ? ts.ScriptSnapshot.fromString(text) : undefined;
+                fsFileSnapshots.set(fileName, [modifiedTime, snapshot]);
+            }
+            else {
+                fsFileSnapshots.set(fileName, [modifiedTime, undefined]);
+            }
+        }
+        return fsFileSnapshots.get(fileName)?.[1];
+    }
+    function getScriptVersion(fileName) {
+        // virtual files / root files / opened files
+        const [virtualFile] = ctx.virtualFiles.getVirtualFile(fileName);
+        const snapshot = virtualFile?.snapshot ?? ctx.host.getScriptSnapshot(fileName);
+        if (snapshot) {
+            if (!fileVersions.has(fileName)) {
+                fileVersions.set(fileName, { value: 0, snapshot });
+            }
+            const version = fileVersions.get(fileName);
+            if (version.snapshot !== snapshot) {
+                version.value++;
+                version.snapshot = snapshot;
+            }
+            return version.value.toString();
+        }
+        // fs files
+        return sys.getModifiedTime?.(fileName)?.valueOf().toString() ?? '';
+    }
+    function fileExists(fileName) {
+        // fill external virtual files
+        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 (!ctx.virtualFiles.hasSource(sourceFileName)) {
+                const scriptSnapshot = getScriptSnapshot(sourceFileName);
+                if (scriptSnapshot) {
+                    ctx.virtualFiles.updateSource(sourceFileName, scriptSnapshot, ctx.host.getLanguageId?.(sourceFileName));
+                }
+            }
+        }
+        // virtual files
+        if (ctx.virtualFiles.hasVirtualFile(fileName)) {
+            return true;
+        }
+        // root files
+        if (ctx.host.getScriptSnapshot(fileName)) {
+            return true;
+        }
+        // fs files
+        return !!sys.fileExists(fileName);
+    }
+}
+exports.createLanguageServiceHost = createLanguageServiceHost;
+function setEquals(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+function forEachEmbeddedFile(file, cb) {
+    cb(file);
+    for (const embeddedFile of file.embeddedFiles) {
+        forEachEmbeddedFile(embeddedFile, cb);
+    }
+}
+//# sourceMappingURL=languageServiceHost.js.map

package/out/sys.d.ts

@@ -0,0 +1,7 @@
+import type { ServiceEnvironment, Disposable, LanguageContext } from '@volar/language-service';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { IDtsHost } from './dtsHost';
+export declare function createSys(ctx: LanguageContext | undefined, ts: typeof import('typescript/lib/tsserverlibrary'), env: ServiceEnvironment, dtsHost?: IDtsHost): ts.System & {
+    version: number;
+    sync(): Promise<number>;
+} & Disposable;