@volar/typescript 1.0.0-rc.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/out/getProgram.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type * as embedded from '@volar/language-core';
+export declare function getProgram(ts: typeof import('typescript/lib/tsserverlibrary'), core: embedded.EmbeddedLanguageContext, ls: ts.LanguageService): any;

package/out/getProgram.js

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgram = void 0;
+function getProgram(ts, core, ls) {
+    const proxy = {
+        getRootFileNames,
+        emit,
+        getSyntacticDiagnostics,
+        getSemanticDiagnostics,
+        getGlobalDiagnostics,
+        // @ts-expect-error
+        getBindAndCheckDiagnostics,
+    };
+    return new Proxy({}, {
+        get: (target, property) => {
+            if (property in proxy) {
+                return proxy[property];
+            }
+            const program = getProgram();
+            if (property in program) {
+                return program[property];
+            }
+            return target[property];
+        },
+    });
+    function getProgram() {
+        return ls.getProgram();
+    }
+    function getRootFileNames() {
+        return getProgram().getRootFileNames().filter(fileName => { var _a, _b; return (_b = (_a = core.typescriptLanguageServiceHost).fileExists) === null || _b === void 0 ? void 0 : _b.call(_a, fileName); });
+    }
+    // for vue-tsc --noEmit --watch
+    function getBindAndCheckDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getBindAndCheckDiagnostics');
+    }
+    // for vue-tsc --noEmit
+    function getSyntacticDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getSyntacticDiagnostics');
+    }
+    function getSemanticDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getSemanticDiagnostics');
+    }
+    function getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, api) {
+        var _a, _b, _c;
+        if (sourceFile) {
+            const mapped = core.mapper.fromEmbeddedFileName(sourceFile.fileName);
+            if (mapped) {
+                if (!mapped.embedded.capabilities.diagnostic)
+                    return [];
+                const errors = transformDiagnostics((_b = (_a = ls.getProgram()) === null || _a === void 0 ? void 0 : _a[api](sourceFile, cancellationToken)) !== null && _b !== void 0 ? _b : []);
+                return errors;
+            }
+        }
+        return transformDiagnostics((_c = getProgram()[api](sourceFile, cancellationToken)) !== null && _c !== void 0 ? _c : []);
+    }
+    function getGlobalDiagnostics(cancellationToken) {
+        var _a;
+        return transformDiagnostics((_a = getProgram().getGlobalDiagnostics(cancellationToken)) !== null && _a !== void 0 ? _a : []);
+    }
+    function emit(targetSourceFile, _writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
+        var _a;
+        const scriptResult = getProgram().emit(targetSourceFile, ((_a = core.typescriptLanguageServiceHost.writeFile) !== null && _a !== void 0 ? _a : ts.sys.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
+        return {
+            emitSkipped: scriptResult.emitSkipped,
+            emittedFiles: scriptResult.emittedFiles,
+            diagnostics: transformDiagnostics(scriptResult.diagnostics),
+        };
+    }
+    // transform
+    function transformDiagnostics(diagnostics) {
+        var _a, _b, _c;
+        const result = [];
+        for (const diagnostic of diagnostics) {
+            if (diagnostic.file !== undefined
+                && diagnostic.start !== undefined
+                && diagnostic.length !== undefined) {
+                for (const start of core.mapper.fromEmbeddedLocation(diagnostic.file.fileName, diagnostic.start)) {
+                    if (start.mapping && !start.mapping.data.diagnostic)
+                        continue;
+                    if (!((_b = (_a = core.typescriptLanguageServiceHost).fileExists) === null || _b === void 0 ? void 0 : _b.call(_a, start.fileName)))
+                        continue;
+                    for (const end of core.mapper.fromEmbeddedLocation(diagnostic.file.fileName, diagnostic.start + diagnostic.length)) {
+                        if (end.mapping && !end.mapping.data.diagnostic)
+                            continue;
+                        onMapping(diagnostic, start.fileName, start.offset, end.offset, (_c = core.mapper.get(start.fileName)) === null || _c === void 0 ? void 0 : _c[0].text);
+                        break;
+                    }
+                    break;
+                }
+            }
+            else if (diagnostic.file === undefined) {
+                result.push(diagnostic);
+            }
+        }
+        return result;
+        function onMapping(diagnostic, fileName, start, end, docText) {
+            var _a;
+            let file = fileName === ((_a = diagnostic.file) === null || _a === void 0 ? void 0 : _a.fileName)
+                ? diagnostic.file
+                : undefined;
+            if (!file) {
+                if (docText === undefined) {
+                    const snapshot = core.typescriptLanguageServiceHost.getScriptSnapshot(fileName);
+                    if (snapshot) {
+                        docText = snapshot.getText(0, snapshot.getLength());
+                    }
+                }
+                else {
+                    file = ts.createSourceFile(fileName, docText, fileName.endsWith('.vue') || fileName.endsWith('.md') || fileName.endsWith('.html') ? ts.ScriptTarget.JSON : ts.ScriptTarget.Latest);
+                }
+            }
+            const newDiagnostic = Object.assign(Object.assign({}, diagnostic), { file, start: start, length: end - start });
+            const relatedInformation = diagnostic.relatedInformation;
+            if (relatedInformation) {
+                newDiagnostic.relatedInformation = transformDiagnostics(relatedInformation);
+            }
+            result.push(newDiagnostic);
+        }
+    }
+}
+exports.getProgram = getProgram;
+//# sourceMappingURL=getProgram.js.map

package/out/index.d.ts

@@ -0,0 +1,2 @@
+import * as vue from '@volar/vue-language-core';
+export declare function createLanguageService(host: vue.LanguageServiceHost): any;

package/out/index.js

@@ -0,0 +1,250 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageService = void 0;
+const tsFaster = require("@volar/typescript-faster");
+const vue = require("@volar/vue-language-core");
+const getProgram_1 = require("./getProgram");
+const embedded = require("@volar/language-core");
+function createLanguageService(host) {
+    const mods = [vue.createEmbeddedLanguageModule(host.getTypeScriptModule(), host.getCurrentDirectory(), host.getCompilationSettings(), host.getVueCompilationSettings(), ['.vue'])];
+    return create(host, mods);
+}
+exports.createLanguageService = createLanguageService;
+function create(host, mods) {
+    const core = embedded.createEmbeddedLanguageServiceHost(host, mods);
+    const ts = host.getTypeScriptModule();
+    const ls = ts.createLanguageService(core.typescriptLanguageServiceHost);
+    tsFaster.decorate(ts, core.typescriptLanguageServiceHost, ls);
+    const proxy = {
+        organizeImports,
+        // only support for .ts for now, not support for .vue
+        getCompletionsAtPosition,
+        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),
+    };
+    return new Proxy(ls, {
+        get: (target, property) => {
+            if (property in proxy) {
+                return proxy[property];
+            }
+            return target[property];
+        },
+    });
+    // apis
+    function organizeImports(args, formatOptions, preferences) {
+        const file = core.mapper.get(args.fileName);
+        let edits = [];
+        if (file) {
+            embedded.forEachEmbeddeds(file[0].embeddeds, embedded => {
+                if (embedded.kind && embedded.capabilities.codeAction) {
+                    edits = edits.concat(ls.organizeImports(Object.assign(Object.assign({}, args), { fileName: embedded.fileName }), formatOptions, preferences));
+                }
+            });
+        }
+        else {
+            return ls.organizeImports(args, formatOptions, preferences);
+        }
+        return edits.map(transformFileTextChanges).filter(notEmpty);
+    }
+    function getCompletionsAtPosition(fileName, position, options) {
+        const finalResult = ls.getCompletionsAtPosition(fileName, position, options);
+        if (finalResult) {
+            finalResult.entries = finalResult.entries.filter(entry => entry.name.indexOf('__VLS_') === -1);
+        }
+        return finalResult;
+    }
+    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, providePrefixAndSuffixTextForRename) {
+        return findLocations(fileName, position, 'rename', findInStrings, findInComments, providePrefixAndSuffixTextForRename);
+    }
+    function findLocations(fileName, position, mode, findInStrings = false, findInComments = false, providePrefixAndSuffixTextForRename) {
+        const loopChecker = new Set();
+        let symbols = [];
+        withTeleports(fileName, position);
+        return symbols.map(s => transformDocumentSpanLike(s)).filter(notEmpty);
+        function withTeleports(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)
+                            : mode === 'rename' ? ls.findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename)
+                                : undefined;
+            if (!_symbols)
+                return;
+            symbols = symbols.concat(_symbols);
+            for (const ref of _symbols) {
+                loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
+                const teleport = core.mapper.getTeleport(ref.fileName);
+                if (!teleport)
+                    continue;
+                for (const teleOffset of teleport.findTeleports(ref.textSpan.start, data => {
+                    if ((mode === 'definition' || mode === 'typeDefinition' || mode === 'implementation') && !data.definition)
+                        return false;
+                    if ((mode === 'references') && !data.references)
+                        return false;
+                    if ((mode === 'rename') && !data.rename)
+                        return false;
+                    return true;
+                })) {
+                    if (loopChecker.has(ref.fileName + ':' + teleOffset))
+                        continue;
+                    withTeleports(ref.fileName, teleOffset);
+                }
+            }
+        }
+    }
+    function getDefinitionAndBoundSpan(fileName, position) {
+        const loopChecker = new Set();
+        let textSpan;
+        let symbols = [];
+        withTeleports(fileName, position);
+        if (!textSpan)
+            return;
+        return {
+            textSpan: textSpan,
+            definitions: symbols === null || symbols === void 0 ? void 0 : symbols.map(s => transformDocumentSpanLike(s)).filter(notEmpty),
+        };
+        function withTeleports(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 teleport = core.mapper.getTeleport(ref.fileName);
+                if (!teleport)
+                    continue;
+                for (const teleOffset of teleport.findTeleports(ref.textSpan.start, data => !!data.definition)) {
+                    if (loopChecker.has(ref.fileName + ':' + teleOffset))
+                        continue;
+                    withTeleports(ref.fileName, teleOffset);
+                }
+            }
+        }
+    }
+    function findReferences(fileName, position) {
+        const loopChecker = new Set();
+        let symbols = [];
+        withTeleports(fileName, position);
+        return symbols.map(s => transformReferencedSymbol(s)).filter(notEmpty);
+        function withTeleports(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 teleport = core.mapper.getTeleport(ref.fileName);
+                    if (!teleport)
+                        continue;
+                    for (const telePos of teleport.findTeleports(ref.textSpan.start, data => !!data.references)) {
+                        if (loopChecker.has(ref.fileName + ':' + telePos))
+                            continue;
+                        withTeleports(ref.fileName, telePos);
+                    }
+                }
+            }
+        }
+    }
+    // transforms
+    function transformFileTextChanges(changes) {
+        const sourceFile = core.mapper.fromEmbeddedFileName(changes.fileName);
+        if (sourceFile) {
+            return Object.assign(Object.assign({}, changes), { fileName: sourceFile.sourceFile.fileName, textChanges: changes.textChanges.map(c => {
+                    const span = transformSpan(changes.fileName, c.span);
+                    if (span) {
+                        return Object.assign(Object.assign({}, 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: Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, documentSpan), { fileName: textSpan.fileName, textSpan: textSpan.textSpan, contextSpan: contextSpan === null || contextSpan === void 0 ? void 0 : contextSpan.textSpan, originalFileName: originalTextSpan === null || originalTextSpan === void 0 ? void 0 : originalTextSpan.fileName, originalTextSpan: originalTextSpan === null || originalTextSpan === void 0 ? void 0 : originalTextSpan.textSpan, originalContextSpan: originalContextSpan === null || originalContextSpan === void 0 ? void 0 : originalContextSpan.textSpan });
+    }
+    function transformSpan(fileName, textSpan) {
+        if (!fileName)
+            return;
+        if (!textSpan)
+            return;
+        for (const sourceLoc of core.mapper.fromEmbeddedLocation(fileName, textSpan.start)) {
+            return {
+                fileName: sourceLoc.fileName,
+                textSpan: {
+                    start: sourceLoc.offset,
+                    length: textSpan.length,
+                },
+            };
+        }
+    }
+}
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "@volar/typescript",
+	"version": "1.0.0-rc.4",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/johnsoncodehk/volar.git",
+		"directory": "packages/typescript"
+	},
+	"dependencies": {
+		"@volar/language-core": "1.0.0-rc.4",
+		"@volar/typescript-faster": "1.0.0-rc.4"
+	}
+}