@vue/language-service 1.9.0-alpha.3 → 2.0.1

package/out/plugins/vue-toggle-v-bind-codeaction.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = void 0;
-const language_core_1 = require("@vue/language-core");
-const create = function () {
-    return (ctx, modules) => {
-        if (!modules?.typescript)
-            return {};
-        const ts = modules.typescript;
-        return {
-            provideCodeActions(document, range, _context) {
-                const startOffset = document.offsetAt(range.start);
-                const endOffset = document.offsetAt(range.end);
-                const [vueFile] = ctx.documents.getVirtualFileByUri(document.uri);
-                if (!vueFile || !(vueFile instanceof language_core_1.VueFile)) {
-                    return;
-                }
-                const { template } = vueFile.sfc;
-                if (!template?.ast)
-                    return;
-                const templateStartOffset = template.startTagEnd;
-                const result = [];
-                (0, language_core_1.walkElementNodes)(template.ast, node => {
-                    if (startOffset > templateStartOffset + node.loc.end.offset || endOffset < templateStartOffset + node.loc.start.offset) {
-                        return;
-                    }
-                    for (const prop of node.props) {
-                        if (startOffset - templateStartOffset >= prop.loc.start.offset
-                            && endOffset - templateStartOffset <= prop.loc.end.offset) {
-                            if (prop.type === 7 && prop.exp) {
-                                const sourceFile = ts.createSourceFile('/a.ts', prop.exp.loc.source, ts.ScriptTarget.Latest, true);
-                                const firstStatement = sourceFile.statements[0];
-                                if (sourceFile.statements.length === 1 && ts.isExpressionStatement(firstStatement) && ts.isStringLiteralLike(firstStatement.expression)) {
-                                    const stringNode = sourceFile.statements[0];
-                                    const removeTextRanges = [
-                                        [prop.loc.start.offset, prop.loc.start.offset + 1],
-                                        // Work correctly with trivias for cases like <input :type=" 'password' " />
-                                        [prop.exp.loc.start.offset, prop.exp.loc.start.offset + stringNode.pos + stringNode.getLeadingTriviaWidth() + 1],
-                                        [prop.exp.loc.start.offset + stringNode.end - 1, prop.exp.loc.end.offset],
-                                    ];
-                                    result.push({
-                                        title: 'Remove v-bind from attribute',
-                                        kind: 'refactor.rewrite.removeVBind',
-                                        edit: {
-                                            changes: {
-                                                [document.uri]: removeTextRanges.map(range => ({
-                                                    newText: '',
-                                                    range: {
-                                                        start: document.positionAt(templateStartOffset + range[0]),
-                                                        end: document.positionAt(templateStartOffset + range[1]),
-                                                    }
-                                                }))
-                                            },
-                                        },
-                                    });
-                                }
-                            }
-                            if (prop.type === 6) {
-                                const edits = [];
-                                const addVBindPos = document.positionAt(templateStartOffset + prop.loc.start.offset);
-                                edits.push({
-                                    newText: ':',
-                                    range: {
-                                        start: addVBindPos,
-                                        end: addVBindPos,
-                                    },
-                                });
-                                let newPosition;
-                                if (prop.value) {
-                                    const valueStart = document.positionAt(templateStartOffset + prop.value.loc.start.offset);
-                                    const valueEnd = document.positionAt(templateStartOffset + prop.value.loc.end.offset);
-                                    if (prop.value.loc.end.offset - prop.value.loc.start.offset !== prop.value.content.length) {
-                                        valueStart.character++;
-                                        valueEnd.character--;
-                                    }
-                                    edits.push({
-                                        newText: "'",
-                                        range: {
-                                            start: valueStart,
-                                            end: valueStart,
-                                        },
-                                    });
-                                    edits.push({
-                                        newText: "'",
-                                        range: {
-                                            start: valueEnd,
-                                            end: valueEnd,
-                                        },
-                                    });
-                                }
-                                else {
-                                    const addValuePos = document.positionAt(templateStartOffset + prop.loc.end.offset);
-                                    newPosition = {
-                                        line: addValuePos.line,
-                                        character: addValuePos.character + ':'.length + '="'.length,
-                                    };
-                                    edits.push({
-                                        newText: '=""',
-                                        range: {
-                                            start: addValuePos,
-                                            end: addValuePos
-                                        },
-                                    });
-                                }
-                                result.push({
-                                    title: 'Add v-bind to attribute',
-                                    kind: 'refactor.rewrite.addVBind',
-                                    edit: {
-                                        changes: { [document.uri]: edits },
-                                    },
-                                    command: newPosition ? ctx?.commands.setSelection.create(newPosition) : undefined,
-                                });
-                            }
-                        }
-                    }
-                });
-                return result;
-            },
-            transformCodeAction(item) {
-                return item; // ignore mapping
-            },
-        };
-    };
-};
-exports.create = create;
-//# sourceMappingURL=vue-toggle-v-bind-codeaction.js.map

package/out/plugins/vue-twoslash-queries.d.ts

@@ -1,3 +0,0 @@
-import { Service } from '@volar/language-service';
-export declare const create: () => Service;
-//# sourceMappingURL=vue-twoslash-queries.d.ts.map

package/out/plugins/vue-twoslash-queries.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = void 0;
-const language_service_1 = require("@volar/language-service");
-const vue = require("@vue/language-core");
-const twoslashReg = /<!--\s*\^\?\s*-->/g;
-const plugin = (context, modules) => {
-    if (!context || !modules?.typescript)
-        return {};
-    const ts = modules.typescript;
-    return {
-        provideInlayHints(document, range) {
-            return worker(document.uri, (vueFile) => {
-                const hoverOffsets = [];
-                const inlayHints = [];
-                const languageService = context.inject('typescript/languageService');
-                for (const pointer of document.getText(range).matchAll(twoslashReg)) {
-                    const offset = pointer.index + pointer[0].indexOf('^?') + document.offsetAt(range.start);
-                    const position = document.positionAt(offset);
-                    hoverOffsets.push([position, document.offsetAt({
-                            line: position.line - 1,
-                            character: position.character,
-                        })]);
-                }
-                (0, language_service_1.forEachEmbeddedFile)(vueFile, (embedded) => {
-                    if (embedded.kind === language_service_1.FileKind.TypeScriptHostFile) {
-                        for (const [_, map] of context.documents.getMapsByVirtualFileName(embedded.fileName)) {
-                            for (const [pointerPosition, hoverOffset] of hoverOffsets) {
-                                for (const [tsOffset, mapping] of map.map.toGeneratedOffsets(hoverOffset)) {
-                                    if (mapping.data.hover) {
-                                        const quickInfo = languageService.getQuickInfoAtPosition(embedded.fileName, tsOffset);
-                                        if (quickInfo) {
-                                            inlayHints.push({
-                                                position: { line: pointerPosition.line, character: pointerPosition.character + 2 },
-                                                label: ts.displayPartsToString(quickInfo.displayParts),
-                                                paddingLeft: true,
-                                                paddingRight: false,
-                                            });
-                                        }
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                });
-                return inlayHints;
-            });
-        },
-    };
-    function worker(uri, callback) {
-        const [virtualFile] = context.documents.getVirtualFileByUri(uri);
-        if (!(virtualFile instanceof vue.VueFile))
-            return;
-        return callback(virtualFile);
-    }
-};
-const create = () => plugin;
-exports.create = create;
-//# sourceMappingURL=vue-twoslash-queries.js.map

package/out/plugins/vue-visualize-hidden-callback-param.d.ts

@@ -1,3 +0,0 @@
-import { Service } from '@volar/language-service';
-export declare const create: () => Service;
-//# sourceMappingURL=vue-visualize-hidden-callback-param.d.ts.map

package/out/plugins/vue-visualize-hidden-callback-param.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = void 0;
-const plugin = (context) => {
-    if (!context)
-        return {};
-    return {
-        async provideInlayHints(document, range) {
-            const settings = {};
-            const result = [];
-            const [file] = context.documents.getVirtualFileByUri(document.uri);
-            if (file) {
-                const start = document.offsetAt(range.start);
-                const end = document.offsetAt(range.end);
-                for (const mapping of file.mappings) {
-                    const hint = mapping.data.__hint;
-                    if (mapping.generatedRange[0] >= start
-                        && mapping.generatedRange[1] <= end
-                        && hint) {
-                        settings[hint.setting] ??= await context.env.getConfiguration?.(hint.setting) ?? false;
-                        if (!settings[hint.setting])
-                            continue;
-                        result.push({
-                            label: hint.label,
-                            paddingRight: hint.paddingRight,
-                            paddingLeft: hint.paddingLeft,
-                            position: document.positionAt(mapping.generatedRange[0]),
-                            kind: 2,
-                            tooltip: {
-                                kind: 'markdown',
-                                value: hint.tooltip,
-                            },
-                        });
-                    }
-                }
-            }
-            return result;
-        },
-    };
-};
-const create = () => plugin;
-exports.create = create;
-//# sourceMappingURL=vue-visualize-hidden-callback-param.js.map

package/out/plugins/vue.d.ts

@@ -1,8 +0,0 @@
-import type { Service } from '@volar/language-service';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-import * as vue from '@vue/language-core';
-export interface Provide {
-    'vue/vueFile': (document: TextDocument) => vue.VueFile | undefined;
-}
-export declare const create: () => Service<Provide>;
-//# sourceMappingURL=vue.d.ts.map

package/out/plugins/vue.js

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = void 0;
-const html = require("vscode-html-languageservice");
-const volar_service_html_1 = require("volar-service-html");
-const vue = require("@vue/language-core");
-const data_1 = require("./data");
-let sfcDataProvider;
-const create = () => (context, modules) => {
-    const htmlPlugin = (0, volar_service_html_1.default)({ languageId: 'vue', useCustomDataProviders: false })(context, modules);
-    if (!context)
-        return htmlPlugin;
-    sfcDataProvider ??= html.newHTMLDataProvider('vue', (0, data_1.loadLanguageBlocks)(context.env.locale ?? 'en'));
-    htmlPlugin.provide['html/languageService']().setDataProviders(false, [sfcDataProvider]);
-    return {
-        ...htmlPlugin,
-        provide: {
-            'vue/vueFile': document => {
-                return worker(document, (vueFile) => {
-                    return vueFile;
-                });
-            },
-        },
-        provideSemanticDiagnostics(document) {
-            return worker(document, (vueSourceFile) => {
-                const result = [];
-                const sfc = vueSourceFile.sfc;
-                const program = context.inject('typescript/languageService').getProgram();
-                if (program && !program.getSourceFile(vueSourceFile.mainScriptName)) {
-                    for (const script of [sfc.script, sfc.scriptSetup]) {
-                        if (!script || script.content === '')
-                            continue;
-                        const error = {
-                            range: {
-                                start: document.positionAt(script.start),
-                                end: document.positionAt(script.startTagEnd),
-                            },
-                            message: `Virtual script ${JSON.stringify(vueSourceFile.mainScriptName)} not found, may missing <script lang="ts"> / "allowJs": true / jsconfig.json.`,
-                            severity: 3,
-                            source: 'vue',
-                        };
-                        result.push(error);
-                    }
-                }
-                return result;
-            });
-        },
-        provideDocumentLinks: undefined,
-        provideDocumentSymbols(document) {
-            return worker(document, (vueSourceFile) => {
-                const result = [];
-                const descriptor = vueSourceFile.sfc;
-                if (descriptor.template) {
-                    result.push({
-                        name: 'template',
-                        kind: 2,
-                        range: {
-                            start: document.positionAt(descriptor.template.start),
-                            end: document.positionAt(descriptor.template.end),
-                        },
-                        selectionRange: {
-                            start: document.positionAt(descriptor.template.start),
-                            end: document.positionAt(descriptor.template.startTagEnd),
-                        },
-                    });
-                }
-                if (descriptor.script) {
-                    result.push({
-                        name: 'script',
-                        kind: 2,
-                        range: {
-                            start: document.positionAt(descriptor.script.start),
-                            end: document.positionAt(descriptor.script.end),
-                        },
-                        selectionRange: {
-                            start: document.positionAt(descriptor.script.start),
-                            end: document.positionAt(descriptor.script.startTagEnd),
-                        },
-                    });
-                }
-                if (descriptor.scriptSetup) {
-                    result.push({
-                        name: 'script setup',
-                        kind: 2,
-                        range: {
-                            start: document.positionAt(descriptor.scriptSetup.start),
-                            end: document.positionAt(descriptor.scriptSetup.end),
-                        },
-                        selectionRange: {
-                            start: document.positionAt(descriptor.scriptSetup.start),
-                            end: document.positionAt(descriptor.scriptSetup.startTagEnd),
-                        },
-                    });
-                }
-                for (const style of descriptor.styles) {
-                    let name = 'style';
-                    if (style.scoped)
-                        name += ' scoped';
-                    if (style.module)
-                        name += ' module';
-                    result.push({
-                        name,
-                        kind: 2,
-                        range: {
-                            start: document.positionAt(style.start),
-                            end: document.positionAt(style.end),
-                        },
-                        selectionRange: {
-                            start: document.positionAt(style.start),
-                            end: document.positionAt(style.startTagEnd),
-                        },
-                    });
-                }
-                for (const customBlock of descriptor.customBlocks) {
-                    result.push({
-                        name: `${customBlock.type}`,
-                        kind: 2,
-                        range: {
-                            start: document.positionAt(customBlock.start),
-                            end: document.positionAt(customBlock.end),
-                        },
-                        selectionRange: {
-                            start: document.positionAt(customBlock.start),
-                            end: document.positionAt(customBlock.startTagEnd),
-                        },
-                    });
-                }
-                return result;
-            });
-        },
-        provideDocumentFormattingEdits(document) {
-            return worker(document, (vueSourceFile) => {
-                const blocks = [
-                    vueSourceFile.sfc.script,
-                    vueSourceFile.sfc.scriptSetup,
-                    vueSourceFile.sfc.template,
-                    ...vueSourceFile.sfc.styles,
-                    ...vueSourceFile.sfc.customBlocks,
-                ].filter((block) => !!block)
-                    .sort((a, b) => b.start - a.start);
-                const edits = [];
-                for (const block of blocks) {
-                    const startPos = document.positionAt(block.start);
-                    if (startPos.character !== 0) {
-                        edits.push({
-                            range: {
-                                start: {
-                                    line: startPos.line,
-                                    character: 0,
-                                },
-                                end: startPos,
-                            },
-                            newText: '',
-                        });
-                    }
-                }
-                return edits;
-            });
-        },
-    };
-    function worker(document, callback) {
-        const [vueFile] = context.documents.getVirtualFileByUri(document.uri);
-        if (vueFile instanceof vue.VueFile) {
-            return callback(vueFile);
-        }
-    }
-};
-exports.create = create;
-//# sourceMappingURL=vue.js.map