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

package/out/plugins/vue-codelens-references.js

@@ -1,54 +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 (context) => {
-        if (!context)
-            return {};
-        return {
-            provideReferencesCodeLensRanges(document) {
-                return worker(document.uri, async () => {
-                    const result = [];
-                    for (const [_, map] of context.documents.getMapsBySourceFileUri(document.uri)?.maps ?? []) {
-                        for (const mapping of map.map.mappings) {
-                            if (!mapping.data.referencesCodeLens)
-                                continue;
-                            result.push({
-                                start: document.positionAt(mapping.sourceRange[0]),
-                                end: document.positionAt(mapping.sourceRange[1]),
-                            });
-                        }
-                    }
-                    return result;
-                });
-            },
-            async resolveReferencesCodeLensLocations(document, range, references) {
-                await worker(document.uri, async (vueFile) => {
-                    const document = context.documents.getDocumentByFileName(vueFile.snapshot, vueFile.fileName);
-                    const offset = document.offsetAt(range.start);
-                    const blocks = [
-                        vueFile.sfc.script,
-                        vueFile.sfc.scriptSetup,
-                        vueFile.sfc.template,
-                        ...vueFile.sfc.styles,
-                        ...vueFile.sfc.customBlocks,
-                    ];
-                    const sourceBlock = blocks.find(block => block && offset >= block.startTagEnd && offset <= block.endTagStart);
-                    references = references.filter(reference => reference.uri !== document.uri // different file
-                        || sourceBlock !== blocks.find(block => block && document.offsetAt(reference.range.start) >= block.startTagEnd && document.offsetAt(reference.range.end) <= block.endTagStart) // different block
-                    );
-                });
-                return references;
-            },
-        };
-        function worker(uri, callback) {
-            const [virtualFile] = context.documents.getVirtualFileByUri(uri);
-            if (!(virtualFile instanceof language_core_1.VueFile))
-                return;
-            return callback(virtualFile);
-        }
-    };
-};
-exports.create = create;
-//# sourceMappingURL=vue-codelens-references.js.map

package/out/plugins/vue-directive-comments.d.ts

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

package/out/plugins/vue-directive-comments.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.create = void 0;
-const cmds = [
-    'vue-ignore',
-    'vue-skip',
-    'vue-expect-error',
-];
-const directiveCommentReg = /<!--\s*@/;
-const plugin = () => {
-    return {
-        triggerCharacters: ['@'],
-        provideCompletionItems(document, position) {
-            if (document.languageId !== 'html')
-                return;
-            const line = document.getText({ start: { line: position.line, character: 0 }, end: position });
-            const cmdStart = line.match(directiveCommentReg);
-            if (!cmdStart)
-                return;
-            const startIndex = cmdStart.index + cmdStart[0].length;
-            const remainText = line.substring(startIndex);
-            const result = [];
-            for (const cmd of cmds) {
-                let match = true;
-                for (let i = 0; i < remainText.length; i++) {
-                    if (remainText[i] !== cmd[i]) {
-                        console.log(JSON.stringify(remainText[i]), JSON.stringify(cmd[i]));
-                        match = false;
-                        break;
-                    }
-                }
-                if (match) {
-                    result.push({
-                        label: '@' + cmd,
-                        textEdit: {
-                            range: {
-                                start: {
-                                    line: position.line,
-                                    character: startIndex - 1,
-                                },
-                                end: position,
-                            },
-                            newText: '@' + cmd,
-                        },
-                    });
-                }
-            }
-            return {
-                isIncomplete: false,
-                items: result,
-            };
-        },
-    };
-};
-const create = () => plugin;
-exports.create = create;
-//# sourceMappingURL=vue-directive-comments.js.map

package/out/plugins/vue-extract-file.d.ts

@@ -1,9 +0,0 @@
-import { Service } from '@volar/language-service';
-import type * as ts from 'typescript/lib/tsserverlibrary';
-export declare const create: () => Service;
-export declare function getLastImportNode(ts: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile): ts.Node | undefined;
-export declare function createAddComponentToOptionEdit(ts: typeof import('typescript/lib/tsserverlibrary'), ast: ts.SourceFile, componentName: string): {
-    range: import("@vue/language-core").TextRange;
-    newText: string;
-} | undefined;
-//# sourceMappingURL=vue-extract-file.d.ts.map

package/out/plugins/vue-extract-file.js

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAddComponentToOptionEdit = exports.getLastImportNode = exports.create = void 0;
-const language_core_1 = require("@vue/language-core");
-const unicodeReg = /\\u/g;
-const create = function () {
-    return (ctx, modules) => {
-        if (!modules?.typescript)
-            return {};
-        const ts = modules.typescript;
-        return {
-            async provideCodeActions(document, range, _context) {
-                const startOffset = document.offsetAt(range.start);
-                const endOffset = document.offsetAt(range.end);
-                if (startOffset === endOffset) {
-                    return;
-                }
-                const [vueFile] = ctx.documents.getVirtualFileByUri(document.uri);
-                if (!vueFile || !(vueFile instanceof language_core_1.VueFile))
-                    return;
-                const { sfc } = vueFile;
-                const script = sfc.scriptSetup ?? sfc.script;
-                if (!sfc.template || !script)
-                    return;
-                const templateCodeRange = selectTemplateCode(startOffset, endOffset, sfc.template);
-                if (!templateCodeRange)
-                    return;
-                return [
-                    {
-                        title: 'Extract into new dumb component',
-                        kind: 'refactor.move.newFile.dumb',
-                        data: {
-                            uri: document.uri,
-                            range: [startOffset, endOffset],
-                            newName: 'NewComponent',
-                        },
-                    },
-                ];
-            },
-            async resolveCodeAction(codeAction) {
-                const { uri, range, newName } = codeAction.data;
-                const document = ctx.getTextDocument(uri);
-                const [startOffset, endOffset] = range;
-                const [vueFile] = ctx.documents.getVirtualFileByUri(document.uri);
-                const { sfc } = vueFile;
-                const script = sfc.scriptSetup ?? sfc.script;
-                if (!sfc.template || !script)
-                    return codeAction;
-                const templateCodeRange = selectTemplateCode(startOffset, endOffset, sfc.template);
-                if (!templateCodeRange)
-                    return codeAction;
-                const languageService = ctx.inject('typescript/languageService');
-                const languageServiceHost = ctx.inject('typescript/languageServiceHost');
-                const sourceFile = languageService.getProgram().getSourceFile(vueFile.mainScriptName);
-                const sourceFileKind = languageServiceHost.getScriptKind?.(vueFile.mainScriptName);
-                const toExtract = collectExtractProps();
-                const initialIndentSetting = await ctx.env.getConfiguration('volar.format.initialIndent');
-                const newUri = document.uri.substring(0, document.uri.lastIndexOf('/') + 1) + `${newName}.vue`;
-                const lastImportNode = getLastImportNode(ts, script.ast);
-                let newFileTags = [];
-                newFileTags.push(constructTag('template', [], initialIndentSetting.html, sfc.template.content.substring(templateCodeRange[0], templateCodeRange[1])));
-                if (toExtract.length) {
-                    newFileTags.push(constructTag('script', ['setup', 'lang="ts"'], isInitialIndentNeeded(ts, sourceFileKind, initialIndentSetting), generateNewScriptContents()));
-                }
-                if (sfc.template.startTagEnd > script.startTagEnd) {
-                    newFileTags = newFileTags.reverse();
-                }
-                const currentFileEdits = [
-                    {
-                        range: {
-                            start: document.positionAt(sfc.template.startTagEnd + templateCodeRange[0]),
-                            end: document.positionAt(sfc.template.startTagEnd + templateCodeRange[1]),
-                        },
-                        newText: generateReplaceTemplate(),
-                    },
-                    {
-                        range: lastImportNode ? {
-                            start: document.positionAt(script.startTagEnd + lastImportNode.end),
-                            end: document.positionAt(script.startTagEnd + lastImportNode.end),
-                        } : {
-                            start: document.positionAt(script.startTagEnd),
-                            end: document.positionAt(script.startTagEnd),
-                        },
-                        newText: `\nimport ${newName} from './${newName}.vue'`,
-                    },
-                ];
-                if (sfc.script) {
-                    const edit = createAddComponentToOptionEdit(ts, sfc.script.ast, newName);
-                    if (edit) {
-                        currentFileEdits.push({
-                            range: {
-                                start: document.positionAt(sfc.script.startTagEnd + edit.range.start),
-                                end: document.positionAt(sfc.script.startTagEnd + edit.range.end),
-                            },
-                            newText: edit.newText,
-                        });
-                    }
-                }
-                return {
-                    ...codeAction,
-                    edit: {
-                        documentChanges: [
-                            // editing current file
-                            {
-                                textDocument: {
-                                    uri: document.uri,
-                                    version: null,
-                                },
-                                edits: currentFileEdits,
-                            },
-                            // creating new file with content
-                            {
-                                uri: newUri,
-                                kind: 'create',
-                            },
-                            {
-                                textDocument: {
-                                    uri: newUri,
-                                    version: null,
-                                },
-                                edits: [
-                                    {
-                                        range: {
-                                            start: { line: 0, character: 0 },
-                                            end: { line: 0, character: 0 },
-                                        },
-                                        newText: newFileTags.join('\n'),
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                };
-                function collectExtractProps() {
-                    const result = new Map();
-                    const checker = languageService.getProgram().getTypeChecker();
-                    const maps = [...ctx.documents.getMapsByVirtualFileName(vueFile.mainScriptName)];
-                    sourceFile.forEachChild(function visit(node) {
-                        if (ts.isPropertyAccessExpression(node)
-                            && ts.isIdentifier(node.expression)
-                            && node.expression.text === '__VLS_ctx'
-                            && ts.isIdentifier(node.name)) {
-                            const { name } = node;
-                            for (const [_, map] of maps) {
-                                const source = map.map.toSourceOffset(name.getEnd());
-                                if (source && source[0] >= sfc.template.startTagEnd + templateCodeRange[0] && source[0] <= sfc.template.startTagEnd + templateCodeRange[1] && source[1].data.semanticTokens) {
-                                    if (!result.has(name.text)) {
-                                        const type = checker.getTypeAtLocation(node);
-                                        const typeString = checker.typeToString(type, node, ts.TypeFormatFlags.NoTruncation);
-                                        result.set(name.text, {
-                                            name: name.text,
-                                            type: typeString.includes('__VLS_') ? 'any' : typeString,
-                                            model: false,
-                                        });
-                                    }
-                                    const isModel = ts.isPostfixUnaryExpression(node.parent) || ts.isBinaryExpression(node.parent);
-                                    if (isModel) {
-                                        result.get(name.text).model = true;
-                                    }
-                                    break;
-                                }
-                            }
-                        }
-                        node.forEachChild(visit);
-                    });
-                    return [...result.values()];
-                }
-                function generateNewScriptContents() {
-                    const lines = [];
-                    const props = [...toExtract.values()].filter(p => !p.model);
-                    const models = [...toExtract.values()].filter(p => p.model);
-                    if (props.length) {
-                        lines.push(`defineProps<{ \n\t${props.map(p => `${p.name}: ${p.type};`).join('\n\t')}\n}>()`);
-                    }
-                    for (const model of models) {
-                        lines.push(`const ${model.name} = defineModel<${model.type}>('${model.name}', { required: true })`);
-                    }
-                    return lines.join('\n');
-                }
-                function generateReplaceTemplate() {
-                    const props = [...toExtract.values()].filter(p => !p.model);
-                    const models = [...toExtract.values()].filter(p => p.model);
-                    return [
-                        `<${newName}`,
-                        ...props.map(p => `:${p.name}="${p.name}"`),
-                        ...models.map(p => `v-model:${p.name}="${p.name}"`),
-                        `/>`,
-                    ].join(' ');
-                }
-            },
-            transformCodeAction(item) {
-                return item; // ignore mapping
-            },
-        };
-    };
-};
-exports.create = create;
-function selectTemplateCode(startOffset, endOffset, templateBlock) {
-    if (startOffset < templateBlock.startTagEnd || endOffset > templateBlock.endTagStart)
-        return;
-    const insideNodes = [];
-    templateBlock.ast?.children.forEach(function visit(node) {
-        if (node.loc.start.offset + templateBlock.startTagEnd >= startOffset
-            && node.loc.end.offset + templateBlock.startTagEnd <= endOffset) {
-            insideNodes.push(node);
-        }
-        if ('children' in node) {
-            node.children.forEach(node => {
-                if (typeof node === 'object') {
-                    visit(node);
-                }
-            });
-        }
-        else if ('branches' in node) {
-            node.branches.forEach(visit);
-        }
-        else if ('content' in node) {
-            if (typeof node.content === 'object') {
-                visit(node.content);
-            }
-        }
-    });
-    if (insideNodes.length) {
-        const first = insideNodes.sort((a, b) => a.loc.start.offset - b.loc.start.offset)[0];
-        const last = insideNodes.sort((a, b) => b.loc.end.offset - a.loc.end.offset)[0];
-        return [first.loc.start.offset, last.loc.end.offset];
-    }
-}
-function constructTag(name, attributes, initialIndent, content) {
-    if (initialIndent)
-        content = content.split('\n').map(line => `\t${line}`).join('\n');
-    const attributesString = attributes.length ? ` ${attributes.join(' ')}` : '';
-    return `<${name}${attributesString}>\n${content}\n</${name}>\n`;
-}
-function isInitialIndentNeeded(ts, languageKind, initialIndentSetting) {
-    const languageKindIdMap = {
-        [ts.ScriptKind.JS]: 'javascript',
-        [ts.ScriptKind.TS]: 'typescript',
-        [ts.ScriptKind.JSX]: 'javascriptreact',
-        [ts.ScriptKind.TSX]: 'typescriptreact',
-    };
-    return initialIndentSetting[languageKindIdMap[languageKind]] ?? false;
-}
-function getLastImportNode(ts, sourceFile) {
-    let lastImportNode;
-    for (const statement of sourceFile.statements) {
-        if (ts.isImportDeclaration(statement)) {
-            lastImportNode = statement;
-        }
-        else {
-            break;
-        }
-    }
-    return lastImportNode;
-}
-exports.getLastImportNode = getLastImportNode;
-function createAddComponentToOptionEdit(ts, ast, componentName) {
-    const exportDefault = language_core_1.scriptRanges.parseScriptRanges(ts, ast, false, true).exportDefault;
-    if (!exportDefault)
-        return;
-    // https://github.com/microsoft/TypeScript/issues/36174
-    const printer = ts.createPrinter();
-    if (exportDefault.componentsOption && exportDefault.componentsOptionNode) {
-        const newNode = {
-            ...exportDefault.componentsOptionNode,
-            properties: [
-                ...exportDefault.componentsOptionNode.properties,
-                ts.factory.createShorthandPropertyAssignment(componentName),
-            ],
-        };
-        const printText = printer.printNode(ts.EmitHint.Expression, newNode, ast);
-        return {
-            range: exportDefault.componentsOption,
-            newText: unescape(printText.replace(unicodeReg, '%u')),
-        };
-    }
-    else if (exportDefault.args && exportDefault.argsNode) {
-        const newNode = {
-            ...exportDefault.argsNode,
-            properties: [
-                ...exportDefault.argsNode.properties,
-                ts.factory.createShorthandPropertyAssignment(`components: { ${componentName} }`),
-            ],
-        };
-        const printText = printer.printNode(ts.EmitHint.Expression, newNode, ast);
-        return {
-            range: exportDefault.args,
-            newText: unescape(printText.replace(unicodeReg, '%u')),
-        };
-    }
-}
-exports.createAddComponentToOptionEdit = createAddComponentToOptionEdit;
-//# sourceMappingURL=vue-extract-file.js.map

package/out/plugins/vue-template.d.ts

@@ -1,12 +0,0 @@
-import { Service } from '@volar/language-service';
-import * as html from 'vscode-html-languageservice';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-import { VueCompilerOptions } from '../types';
-export declare const create: <S extends Service>(options: {
-    getScanner(service: ReturnType<S>, document: TextDocument): html.Scanner | undefined;
-    updateCustomData(service: ReturnType<S>, extraData: html.IHTMLDataProvider[]): void;
-    baseService: S;
-    isSupportedDocument: (document: TextDocument) => boolean;
-    vueCompilerOptions: VueCompilerOptions;
-}) => Service;
-//# sourceMappingURL=vue-template.d.ts.map