@vue/language-core 2.0.0 → 2.0.2

package/lib/plugins/file-html.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sfcBlockReg = /\<(script|style)\b([\s\S]*?)\>([\s\S]*?)\<\/\1\>/g;
+const langReg = /\blang\s*=\s*(['\"]?)(\S*)\b\1/;
+const plugin = () => {
+    return {
+        version: 2,
+        parseSFC(fileName, content) {
+            if (fileName.endsWith('.html')) {
+                let sfc = {
+                    descriptor: {
+                        filename: fileName,
+                        source: content,
+                        template: null,
+                        script: null,
+                        scriptSetup: null,
+                        styles: [],
+                        customBlocks: [],
+                        cssVars: [],
+                        shouldForceReload: () => false,
+                        slotted: false,
+                    },
+                    errors: [],
+                };
+                let templateContent = content;
+                for (const match of content.matchAll(sfcBlockReg)) {
+                    const matchText = match[0];
+                    const tag = match[1];
+                    const attrs = match[2];
+                    const lang = attrs.match(langReg)?.[2];
+                    const content = match[3];
+                    const contentStart = match.index + matchText.indexOf(content);
+                    if (tag === 'style') {
+                        sfc.descriptor.styles.push({
+                            attrs: {},
+                            content,
+                            loc: {
+                                start: { column: -1, line: -1, offset: contentStart },
+                                end: { column: -1, line: -1, offset: contentStart + content.length },
+                                source: content,
+                            },
+                            type: 'style',
+                            lang,
+                        });
+                    }
+                    // ignore `<script src="...">`
+                    else if (tag === 'script' && attrs.indexOf('src=') === -1) {
+                        let type = attrs.indexOf('type=') >= 0 ? 'scriptSetup' : 'script';
+                        sfc.descriptor[type] = {
+                            attrs: {},
+                            content,
+                            loc: {
+                                start: { column: -1, line: -1, offset: contentStart },
+                                end: { column: -1, line: -1, offset: contentStart + content.length },
+                                source: content,
+                            },
+                            type: 'script',
+                            lang,
+                        };
+                    }
+                    templateContent = templateContent.substring(0, match.index) + ' '.repeat(matchText.length) + templateContent.substring(match.index + matchText.length);
+                }
+                sfc.descriptor.template = {
+                    attrs: {},
+                    content: templateContent,
+                    loc: {
+                        start: { column: -1, line: -1, offset: 0 },
+                        end: { column: -1, line: -1, offset: templateContent.length },
+                        source: templateContent,
+                    },
+                    type: 'template',
+                    ast: {},
+                };
+                return sfc;
+            }
+            ;
+        }
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-html.js.map

package/lib/plugins/file-md.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/file-md.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const language_core_1 = require("@volar/language-core");
+const parseSfc_1 = require("../utils/parseSfc");
+const codeblockReg = /(`{3,})[\s\S]+?\1/g;
+const inlineCodeblockReg = /`[^\n`]+?`/g;
+const scriptSetupReg = /\\\<[\s\S]+?\>\n?/g;
+const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
+const angleBracketReg = /\<\S*\:\S*\>/g;
+const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
+const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
+const plugin = () => {
+    return {
+        version: 2,
+        parseSFC(fileName, content) {
+            if (fileName.endsWith('.md')) {
+                content = content
+                    // code block
+                    .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
+                    // inline code block
+                    .replace(inlineCodeblockReg, match => `\`${' '.repeat(match.length - 2)}\``)
+                    // # \<script setup>
+                    .replace(scriptSetupReg, match => ' '.repeat(match.length))
+                    // <<< https://vitepress.dev/guide/markdown#import-code-snippets
+                    .replace(codeSnippetImportReg, match => ' '.repeat(match.length));
+                const codes = [];
+                for (const match of content.matchAll(sfcBlockReg)) {
+                    if (match.index !== undefined) {
+                        const matchText = match[0];
+                        codes.push([matchText, undefined, match.index]);
+                        codes.push('\n\n');
+                        content = content.substring(0, match.index) + ' '.repeat(matchText.length) + content.substring(match.index + matchText.length);
+                    }
+                }
+                content = content
+                    // angle bracket: <http://foo.com>
+                    .replace(angleBracketReg, match => ' '.repeat(match.length))
+                    // [foo](http://foo.com)
+                    .replace(linkReg, match => ' '.repeat(match.length));
+                codes.push('<template>\n');
+                codes.push([content, undefined, 0]);
+                codes.push('\n</template>');
+                const file2VueSourceMap = new language_core_1.SourceMap((0, language_core_1.buildMappings)(codes));
+                const sfc = (0, parseSfc_1.parse)((0, language_core_1.toString)(codes));
+                if (sfc.descriptor.template) {
+                    transformRange(sfc.descriptor.template);
+                }
+                if (sfc.descriptor.script) {
+                    transformRange(sfc.descriptor.script);
+                }
+                if (sfc.descriptor.scriptSetup) {
+                    transformRange(sfc.descriptor.scriptSetup);
+                }
+                for (const style of sfc.descriptor.styles) {
+                    transformRange(style);
+                }
+                for (const customBlock of sfc.descriptor.customBlocks) {
+                    transformRange(customBlock);
+                }
+                return sfc;
+                function transformRange(block) {
+                    block.loc.start.offset = file2VueSourceMap.getSourceOffset(block.loc.start.offset)?.[0] ?? -1;
+                    block.loc.end.offset = file2VueSourceMap.getSourceOffset(block.loc.end.offset)?.[0] ?? -1;
+                }
+            }
+            ;
+        }
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-md.js.map

package/lib/plugins/file-vue.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/file-vue.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = (_ctx) => {
+    return {
+        version: 2,
+        parseSFC(_fileName, content) {
+            return (0, parseSfc_1.parse)(content);
+        },
+        updateSFC(sfc, change) {
+            const blocks = [
+                sfc.descriptor.template,
+                sfc.descriptor.script,
+                sfc.descriptor.scriptSetup,
+                ...sfc.descriptor.styles,
+                ...sfc.descriptor.customBlocks,
+            ].filter((block) => !!block);
+            const hitBlock = blocks.find(block => change.start >= block.loc.start.offset && change.end <= block.loc.end.offset);
+            if (!hitBlock) {
+                return;
+            }
+            const oldContent = hitBlock.content;
+            const newContent = hitBlock.content =
+                hitBlock.content.substring(0, change.start - hitBlock.loc.start.offset)
+                    + change.newText
+                    + hitBlock.content.substring(change.end - hitBlock.loc.start.offset);
+            // #3449
+            const endTagRegex = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
+            const insertedEndTag = !!oldContent.match(endTagRegex) !== !!newContent.match(endTagRegex);
+            if (insertedEndTag) {
+                return;
+            }
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            for (const block of blocks) {
+                if (block.loc.start.offset > change.end) {
+                    block.loc.start.offset += lengthDiff;
+                }
+                if (block.loc.end.offset >= change.end) {
+                    block.loc.end.offset += lengthDiff;
+                }
+            }
+            return sfc;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-vue.js.map

package/lib/plugins/vue-sfc-customblocks.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-sfc-customblocks.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../generators/utils");
+const plugin = () => {
+    return {
+        version: 2,
+        getEmbeddedCodes(_fileName, sfc) {
+            return sfc.customBlocks.map((customBlock, i) => ({
+                id: 'customBlock_' + i,
+                lang: customBlock.lang,
+            }));
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id.startsWith('customBlock_')) {
+                const index = parseInt(embeddedFile.id.slice('customBlock_'.length));
+                const customBlock = sfc.customBlocks[index];
+                embeddedFile.content.push([
+                    customBlock.content,
+                    customBlock.name,
+                    0,
+                    (0, utils_1.enableAllFeatures)({}),
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-customblocks.js.map

package/lib/plugins/vue-sfc-scripts.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-sfc-scripts.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../generators/utils");
+const plugin = () => {
+    return {
+        version: 2,
+        getEmbeddedCodes(_fileName, sfc) {
+            const names = [];
+            if (sfc.script) {
+                names.push({ id: 'scriptFormat', lang: sfc.script.lang });
+            }
+            if (sfc.scriptSetup) {
+                names.push({ id: 'scriptSetupFormat', lang: sfc.scriptSetup.lang });
+            }
+            return names;
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            const script = embeddedFile.id === 'scriptFormat' ? sfc.script
+                : embeddedFile.id === 'scriptSetupFormat' ? sfc.scriptSetup
+                    : undefined;
+            if (script) {
+                embeddedFile.content.push([
+                    script.content,
+                    script.name,
+                    0,
+                    (0, utils_1.disableAllFeatures)({
+                        structure: true,
+                        format: true,
+                    }),
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-scripts.js.map

package/lib/plugins/vue-sfc-styles.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-sfc-styles.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../generators/utils");
+const plugin = () => {
+    return {
+        version: 2,
+        getEmbeddedCodes(_fileName, sfc) {
+            return sfc.styles.map((style, i) => ({
+                id: 'style_' + i,
+                lang: style.lang,
+            }));
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id.startsWith('style_')) {
+                const index = parseInt(embeddedFile.id.slice('style_'.length));
+                const style = sfc.styles[index];
+                embeddedFile.content.push([
+                    style.content,
+                    style.name,
+                    0,
+                    (0, utils_1.enableAllFeatures)({}),
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-styles.js.map

package/lib/plugins/vue-sfc-template.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-sfc-template.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../generators/utils");
+const plugin = () => {
+    return {
+        version: 2,
+        getEmbeddedCodes(_fileName, sfc) {
+            if (sfc.template) {
+                return [{
+                        id: 'template',
+                        lang: sfc.template.lang,
+                    }];
+            }
+            return [];
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id === 'template' && sfc.template) {
+                embeddedFile.content.push([
+                    sfc.template.content,
+                    sfc.template.name,
+                    0,
+                    (0, utils_1.enableAllFeatures)({}),
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-template.js.map

package/lib/plugins/vue-template-html.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-template-html.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin = ({ modules }) => {
+    return {
+        version: 2,
+        compileSFCTemplate(lang, template, options) {
+            if (lang === 'html') {
+                const compiler = modules['@vue/compiler-dom'];
+                return compiler.compile(template, {
+                    ...options,
+                    comments: true,
+                });
+            }
+        },
+        updateSFCTemplate(oldResult, change) {
+            const CompilerDOM = modules['@vue/compiler-dom'];
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            let hitNodes = [];
+            if (tryUpdateNode(oldResult.ast) && hitNodes.length) {
+                hitNodes = hitNodes.sort((a, b) => a.loc.source.length - b.loc.source.length);
+                const hitNode = hitNodes[0];
+                if (hitNode.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                    return oldResult;
+                }
+            }
+            function tryUpdateNode(node) {
+                if (withinChangeRange(node.loc)) {
+                    hitNodes.push(node);
+                }
+                if (tryUpdateNodeLoc(node.loc)) {
+                    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+                        if (withinChangeRange(node.loc)) {
+                            // if not self closing, should not hit tag name
+                            const start = node.loc.start.offset + 2;
+                            const end = node.loc.start.offset + node.loc.source.lastIndexOf('</');
+                            if (!withinChangeRange({ start: { offset: start }, end: { offset: end }, source: '' })) {
+                                return false;
+                            }
+                        }
+                        for (const prop of node.props) {
+                            if (!tryUpdateNode(prop)) {
+                                return false;
+                            }
+                        }
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+                        if (node.value && !tryUpdateNode(node.value)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.DIRECTIVE) {
+                        if (node.arg && withinChangeRange(node.arg.loc) && node.name === 'slot') {
+                            return false;
+                        }
+                        if (node.exp && withinChangeRange(node.exp.loc) && node.name === 'for') { // #2266
+                            return false;
+                        }
+                        if (node.arg && !tryUpdateNode(node.arg)) {
+                            return false;
+                        }
+                        if (node.exp && !tryUpdateNode(node.exp)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
+                        if (!tryUpdateNode(node.content)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
+                        for (const childNode of node.children) {
+                            if (typeof childNode === 'object') {
+                                if (!tryUpdateNode(childNode)) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.IF) {
+                        for (const branch of node.branches) {
+                            if (branch.condition && !tryUpdateNode(branch.condition)) {
+                                return false;
+                            }
+                            for (const child of branch.children) {
+                                if (!tryUpdateNode(child)) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+                        for (const child of [
+                            node.parseResult.source,
+                            node.parseResult.value,
+                            node.parseResult.key,
+                            node.parseResult.index,
+                        ]) {
+                            if (child && !tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
+                        if (!tryUpdateNode(node.content)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                        if (withinChangeRange(node.loc)) { // TODO: review this (slot name?)
+                            if (node.isStatic) {
+                                return false;
+                            }
+                            else {
+                                node.content = node.loc.source;
+                            }
+                        }
+                    }
+                    return true;
+                }
+                return false;
+            }
+            function tryUpdateNodeLoc(loc) {
+                delete loc.__endOffset;
+                if (withinChangeRange(loc)) {
+                    loc.source =
+                        loc.source.substring(0, change.start - loc.start.offset)
+                            + change.newText
+                            + loc.source.substring(change.end - loc.start.offset);
+                    loc.__endOffset = loc.end.offset;
+                    loc.end.offset += lengthDiff;
+                    return true;
+                }
+                else if (change.end <= loc.start.offset) {
+                    loc.__endOffset = loc.end.offset;
+                    loc.start.offset += lengthDiff;
+                    loc.end.offset += lengthDiff;
+                    return true;
+                }
+                else if (change.start >= loc.end.offset) {
+                    return true; // no need update
+                }
+                return false;
+            }
+            function withinChangeRange(loc) {
+                const originalLocEnd = loc.__endOffset ?? loc.end.offset;
+                return change.start >= loc.start.offset && change.end <= originalLocEnd;
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-template-html.js.map

package/lib/plugins/vue-tsx.d.ts

@@ -0,0 +1,80 @@
+import { Mapping, StackNode } from '@volar/language-core';
+import type { Code, Sfc, VueLanguagePlugin } from '../types';
+export declare const tsCodegen: WeakMap<Sfc, {
+    scriptRanges: () => {
+        exportDefault: (import("../types").TextRange & {
+            expression: import("../types").TextRange;
+            args: import("../types").TextRange;
+            argsNode: import("typescript").ObjectLiteralExpression | undefined;
+            componentsOption: import("../types").TextRange | undefined;
+            componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
+            nameOption: import("../types").TextRange | undefined;
+        }) | undefined;
+        bindings: import("../types").TextRange[];
+    } | undefined;
+    scriptSetupRanges: () => {
+        leadingCommentEndOffset: number;
+        importSectionEndOffset: number;
+        bindings: import("../types").TextRange[];
+        props: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            } & {
+                statement: import("../types").TextRange;
+            }) | undefined;
+            withDefaults?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        slots: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        emits: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        expose: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        defineProp: {
+            name: import("../types").TextRange | undefined;
+            nameIsString: boolean;
+            type: import("../types").TextRange | undefined;
+            defaultValue: import("../types").TextRange | undefined;
+            required: boolean;
+            isModel?: boolean | undefined;
+        }[];
+    } | undefined;
+    lang: () => string;
+    generatedScript: () => {
+        codes: Code[];
+        codeStacks: StackNode[];
+        linkedCodeMappings: Mapping<any>[];
+    };
+    generatedTemplate: () => {
+        codes: Code[];
+        codeStacks: string[];
+        formatCodes: Code[];
+        formatCodeStacks: string[];
+        cssCodes: Code[];
+        cssCodeStacks: string[];
+        tagOffsetsMap: Map<string, number[]>;
+        accessedGlobalVariables: Set<string>;
+        hasSlot: boolean;
+    } | undefined;
+}>;
+declare const plugin: VueLanguagePlugin;
+export default plugin;