@vue/language-core 3.2.8 → 3.3.0

package/lib/plugins/vue-tsx.js

@@ -50,29 +50,29 @@ const validLangs = new Set(['js', 'jsx', 'ts', 'tsx']);
 const plugin = ({ modules: { typescript: ts }, vueCompilerOptions, }) => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            const lang = computeLang(sfc);
+        getEmbeddedCodes(_fileName, ir) {
+            const lang = computeLang(ir);
             return [{ lang, id: 'script_' + lang }];
         },
-        resolveEmbeddedCode(fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(fileName, ir, embeddedFile) {
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
-                let codegen = exports.tsCodegen.get(sfc);
+                let codegen = exports.tsCodegen.get(ir);
                 if (!codegen) {
-                    exports.tsCodegen.set(sfc, codegen = useCodegen(ts, vueCompilerOptions, fileName, sfc));
+                    exports.tsCodegen.set(ir, codegen = useCodegen(ts, vueCompilerOptions, fileName, ir));
                 }
                 const generatedScript = codegen.getGeneratedScript();
                 embeddedFile.content = [...generatedScript.codes];
             }
         },
     };
-    function computeLang(sfc) {
-        let lang = sfc.scriptSetup?.lang ?? sfc.script?.lang;
-        if (sfc.script && sfc.scriptSetup) {
-            if (sfc.scriptSetup.lang !== 'js') {
-                lang = sfc.scriptSetup.lang;
+    function computeLang(ir) {
+        let lang = ir.scriptSetup?.lang ?? ir.script?.lang;
+        if (ir.script && ir.scriptSetup) {
+            if (ir.scriptSetup.lang !== 'js') {
+                lang = ir.scriptSetup.lang;
             }
             else {
-                lang = sfc.script.lang;
+                lang = ir.script.lang;
             }
         }
         if (lang && validLangs.has(lang)) {
@@ -82,9 +82,9 @@ const plugin = ({ modules: { typescript: ts }, vueCompilerOptions, }) => {
     }
 };
 exports.default = plugin;
-function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
+function useCodegen(ts, vueCompilerOptions, fileName, ir) {
     const getResolvedOptions = (0, alien_signals_1.computed)(() => {
-        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(sfc.comments);
+        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(ir.comments);
         if (options) {
             const resolver = new compilerOptions_1.CompilerOptionsResolver(ts, () => undefined /* does not support resolving target="auto" */);
             resolver.addConfig(options, path.dirname(fileName));
@@ -92,23 +92,23 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         }
         return vueCompilerOptions;
     });
-    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script && validLangs.has(sfc.script.lang)
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, getResolvedOptions())
+    const getScriptRanges = (0, alien_signals_1.computed)(() => ir.script && validLangs.has(ir.script.lang)
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, ir.script.ast, getResolvedOptions())
         : undefined);
-    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup && validLangs.has(sfc.scriptSetup.lang)
-        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())
+    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => ir.scriptSetup && validLangs.has(ir.scriptSetup.lang)
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, ir.scriptSetup.ast, getResolvedOptions())
         : undefined);
     const getImportedComponents = (0, signals_1.computedSet)(() => {
         const names = new Set();
         const scriptSetupRanges = getScriptSetupRanges();
-        if (sfc.scriptSetup && scriptSetupRanges) {
+        if (ir.scriptSetup && scriptSetupRanges) {
             for (const range of scriptSetupRanges.components) {
-                names.add(sfc.scriptSetup.content.slice(range.start, range.end));
+                names.add(ir.scriptSetup.content.slice(range.start, range.end));
             }
             const scriptRange = getScriptRanges();
-            if (sfc.script && scriptRange) {
+            if (ir.script && scriptRange) {
                 for (const range of scriptRange.components) {
-                    names.add(sfc.script.content.slice(range.start, range.end));
+                    names.add(ir.script.content.slice(range.start, range.end));
                 }
             }
         }
@@ -142,12 +142,12 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
     const getComponentName = (0, alien_signals_1.computed)(() => {
         let name;
         const componentOptions = getScriptRanges()?.exportDefault?.options;
-        if (sfc.script && componentOptions?.name) {
-            name = sfc.script.content.slice(componentOptions.name.start + 1, componentOptions.name.end - 1);
+        if (ir.script && componentOptions?.name) {
+            name = ir.script.content.slice(componentOptions.name.start + 1, componentOptions.name.end - 1);
         }
         else {
             const { defineOptions } = getScriptSetupRanges() ?? {};
-            if (sfc.scriptSetup && defineOptions?.name) {
+            if (ir.scriptSetup && defineOptions?.name) {
                 name = defineOptions.name;
             }
             else {
@@ -158,13 +158,13 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         return (0, shared_1.capitalize)((0, shared_1.camelize)(name));
     });
     const getGeneratedTemplate = (0, alien_signals_1.computed)(() => {
-        if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
+        if (getResolvedOptions().skipTemplateCodegen || !ir.template) {
             return;
         }
         return (0, template_1.generateTemplate)({
             typescript: ts,
             vueCompilerOptions: getResolvedOptions(),
-            template: sfc.template,
+            template: ir.template,
             componentName: getComponentName(),
             setupConsts: getSetupConsts(),
             setupRefs: getSetupRefs(),
@@ -175,13 +175,13 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         });
     });
     const getGeneratedStyle = (0, alien_signals_1.computed)(() => {
-        if (!sfc.styles.length) {
+        if (!ir.styles.length) {
             return;
         }
         return (0, style_1.generateStyle)({
             typescript: ts,
             vueCompilerOptions: getResolvedOptions(),
-            styles: sfc.styles,
+            styles: ir.styles,
             setupConsts: getSetupConsts(),
             setupRefs: getSetupRefs(),
         });
@@ -189,17 +189,17 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
     const getSetupExposed = (0, signals_1.computedSet)(() => {
         const allVars = new Set();
         const scriptSetupRanges = getScriptSetupRanges();
-        if (!sfc.scriptSetup || !scriptSetupRanges) {
+        if (!ir.scriptSetup || !scriptSetupRanges) {
             return allVars;
         }
         for (const range of scriptSetupRanges.bindings) {
-            const name = sfc.scriptSetup.content.slice(range.start, range.end);
+            const name = ir.scriptSetup.content.slice(range.start, range.end);
             allVars.add(name);
         }
         const scriptRanges = getScriptRanges();
-        if (sfc.script && scriptRanges) {
+        if (ir.script && scriptRanges) {
             for (const range of scriptRanges.bindings) {
-                const name = sfc.script.content.slice(range.start, range.end);
+                const name = ir.script.content.slice(range.start, range.end);
                 allVars.add(name);
             }
         }
@@ -209,15 +209,15 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         return new Set([
             ...getGeneratedTemplate()?.componentAccessMap.keys() ?? [],
             ...getGeneratedStyle()?.componentAccessMap.keys() ?? [],
-            ...sfc.template?.ast?.components.flatMap(name => [(0, shared_1.camelize)(name), (0, shared_1.capitalize)((0, shared_1.camelize)(name))]) ?? [],
+            ...ir.template?.ast?.components.flatMap(name => [(0, shared_1.camelize)(name), (0, shared_1.capitalize)((0, shared_1.camelize)(name))]) ?? [],
         ].filter(name => allVars.has(name)));
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
         return (0, script_1.generateScript)({
             vueCompilerOptions: getResolvedOptions(),
             fileName,
-            script: sfc.script,
-            scriptSetup: sfc.scriptSetup,
+            script: ir.script,
+            scriptSetup: ir.scriptSetup,
             exposed: getSetupExposed(),
             scriptRanges: getScriptRanges(),
             scriptSetupRanges: getScriptSetupRanges(),

package/lib/template/compile.d.ts

@@ -0,0 +1,2 @@
+import { type CompilerOptions } from '@vue/compiler-dom';
+export declare function compileTemplate(source: string, options: CompilerOptions): import("@vue/compiler-dom").RootNode;

package/lib/template/compile.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileTemplate = compileTemplate;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const transformElement_1 = require("./transforms/transformElement");
+const transformText_1 = require("./transforms/transformText");
+const vFor_1 = require("./transforms/vFor");
+const vIf_1 = require("./transforms/vIf");
+function compileTemplate(source, options) {
+    const [nodeTransforms, directiveTransforms] = (0, compiler_dom_1.getBaseTransformPreset)();
+    const resolvedOptions = {
+        ...options,
+        comments: true,
+        nodeTransforms: [
+            nodeTransforms[0], // transformVBindShorthand
+            vIf_1.transformIf,
+            vFor_1.transformFor,
+            transformElement_1.transformElement,
+            transformText_1.transformText,
+            ...options.nodeTransforms || [],
+        ],
+        directiveTransforms: {
+            ...directiveTransforms,
+            ...options.directiveTransforms,
+        },
+    };
+    const ast = (0, compiler_dom_1.parse)(source, resolvedOptions);
+    (0, compiler_dom_1.transform)(ast, resolvedOptions);
+    return ast;
+}
+//# sourceMappingURL=compile.js.map

package/lib/template/transforms/transformElement.d.ts

@@ -0,0 +1,2 @@
+import { type NodeTransform } from '@vue/compiler-dom';
+export declare const transformElement: NodeTransform;

package/lib/template/transforms/transformElement.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformElement = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const transformElement = (node, context) => {
+    return () => {
+        if (node.type !== compiler_dom_1.NodeTypes.ELEMENT || node.tagType === compiler_dom_1.ElementTypes.TEMPLATE) {
+            return;
+        }
+        const isComponent = node.tagType === compiler_dom_1.ElementTypes.COMPONENT;
+        const isSlotOutlet = node.tagType === compiler_dom_1.ElementTypes.SLOT;
+        for (const prop of node.props) {
+            if (prop.type !== compiler_dom_1.NodeTypes.DIRECTIVE) {
+                continue;
+            }
+            if (prop.name === 'slot') {
+                if (!isComponent) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_MISPLACED, prop.loc));
+                }
+                continue;
+            }
+            const isVBind = prop.name === 'bind';
+            const isVOn = prop.name === 'on';
+            if (!prop.arg && (isVBind || isVOn)) {
+                if (!prop.exp) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(isVBind
+                        ? compiler_dom_1.ErrorCodes.X_V_BIND_NO_EXPRESSION
+                        : compiler_dom_1.ErrorCodes.X_V_ON_NO_EXPRESSION, prop.loc));
+                }
+                continue;
+            }
+            const runtimeDirectives = [];
+            const directiveTransform = context.directiveTransforms[prop.name];
+            if (directiveTransform) {
+                const { needRuntime } = directiveTransform(prop, node, context);
+                if (needRuntime) {
+                    runtimeDirectives.push(prop);
+                }
+            }
+            else if (!(0, shared_1.isBuiltInDirective)(prop.name)) {
+                runtimeDirectives.push(prop);
+            }
+            if (isSlotOutlet && runtimeDirectives.length) {
+                context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET, prop.loc));
+            }
+        }
+        if (isComponent) {
+            let hasTemplateSlots = false;
+            let hasNamedDefaultSlot = false;
+            const implicitDefaultChildren = [];
+            const seenSlotNames = new Set();
+            const onComponentSlot = (0, compiler_dom_1.findDir)(node, 'slot', true);
+            for (const child of node.children) {
+                let slotDir;
+                if (!(0, compiler_dom_1.isTemplateNode)(child) || !(slotDir = (0, compiler_dom_1.findDir)(child, 'slot', true))) {
+                    if (child.type !== compiler_dom_1.NodeTypes.COMMENT) {
+                        implicitDefaultChildren.push(child);
+                    }
+                    continue;
+                }
+                if (onComponentSlot) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE, slotDir.loc));
+                    break;
+                }
+                if ((0, compiler_dom_1.findDir)(child, /^(?:if|else-if|else|for)$/, true)) {
+                    continue;
+                }
+                hasTemplateSlots = true;
+                const staticSlotName = slotDir.arg
+                    ? (0, compiler_dom_1.isStaticExp)(slotDir.arg)
+                        ? slotDir.arg.content
+                        : undefined
+                    : 'default';
+                if (staticSlotName) {
+                    if (seenSlotNames.has(staticSlotName)) {
+                        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES, slotDir.loc));
+                        continue;
+                    }
+                    seenSlotNames.add(staticSlotName);
+                    if (staticSlotName === 'default') {
+                        hasNamedDefaultSlot = true;
+                    }
+                }
+            }
+            if (hasTemplateSlots && hasNamedDefaultSlot
+                && implicitDefaultChildren.some(node => node.type !== compiler_dom_1.NodeTypes.TEXT || !!node.content.trim())) {
+                context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN, implicitDefaultChildren[0].loc));
+            }
+            context.components.add(node.tag);
+        }
+    };
+};
+exports.transformElement = transformElement;
+//# sourceMappingURL=transformElement.js.map

package/lib/template/transforms/transformText.d.ts

@@ -0,0 +1,2 @@
+import { type NodeTransform } from '@vue/compiler-dom';
+export declare const transformText: NodeTransform;

package/lib/template/transforms/transformText.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformText = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const transformText = node => {
+    if (node.type === compiler_dom_1.NodeTypes.ROOT
+        || node.type === compiler_dom_1.NodeTypes.ELEMENT
+        || node.type === compiler_dom_1.NodeTypes.FOR
+        || node.type === compiler_dom_1.NodeTypes.IF_BRANCH) {
+        return () => {
+            const children = node.children;
+            let currentContainer = undefined;
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                if ((0, compiler_dom_1.isText)(child)) {
+                    for (let j = i + 1; j < children.length; j++) {
+                        const next = children[j];
+                        if ((0, compiler_dom_1.isText)(next)) {
+                            currentContainer ??= children[i] = (0, compiler_dom_1.createCompoundExpression)([child], child.loc);
+                            currentContainer.children.push(` + `, next);
+                            children.splice(j, 1);
+                            j--;
+                        }
+                        else {
+                            currentContainer = undefined;
+                            break;
+                        }
+                    }
+                }
+            }
+        };
+    }
+};
+exports.transformText = transformText;
+//# sourceMappingURL=transformText.js.map

package/lib/template/transforms/vFor.d.ts

@@ -0,0 +1 @@
+export declare const transformFor: import("@vue/compiler-dom").NodeTransform;

package/lib/template/transforms/vFor.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformFor = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+exports.transformFor = (0, utils_1.createStructuralDirectiveTransform)('for', (node, dir, context) => {
+    if (!dir.exp) {
+        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_FOR_NO_EXPRESSION, dir.loc));
+        return;
+    }
+    const parseResult = dir.forParseResult;
+    if (!parseResult) {
+        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION, dir.loc));
+        return;
+    }
+    const { source, value, key, index } = parseResult;
+    const forNode = {
+        type: compiler_dom_1.NodeTypes.FOR,
+        loc: dir.loc,
+        source,
+        valueAlias: value,
+        keyAlias: key,
+        objectIndexAlias: index,
+        parseResult,
+        children: [node],
+    };
+    context.replaceNode(forNode);
+    return () => {
+        if ((0, compiler_dom_1.isTemplateNode)(node)) {
+            for (const child of node.children) {
+                if (child.type === compiler_dom_1.NodeTypes.ELEMENT) {
+                    const key = (0, compiler_dom_1.findProp)(child, 'key');
+                    if (key) {
+                        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT, key.loc));
+                        break;
+                    }
+                }
+            }
+        }
+    };
+});
+//# sourceMappingURL=vFor.js.map

package/lib/template/transforms/vIf.d.ts

@@ -0,0 +1 @@
+export declare const transformIf: import("@vue/compiler-dom").NodeTransform;

package/lib/template/transforms/vIf.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformIf = void 0;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+exports.transformIf = (0, utils_1.createStructuralDirectiveTransform)(/^(?:if|else-if|else)$/, (node, dir, context) => {
+    if (dir.name !== 'else'
+        && (!dir.exp || !dir.exp.content.trim())) {
+        context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_IF_NO_EXPRESSION, dir.loc));
+    }
+    if (dir.name === 'if') {
+        const branch = createIfBranch(node, dir);
+        const ifNode = {
+            type: compiler_dom_1.NodeTypes.IF,
+            loc: (0, utils_1.cloneLoc)(node.loc),
+            branches: [branch],
+        };
+        context.replaceNode(ifNode);
+    }
+    else {
+        const siblings = context.parent.children;
+        const comments = [];
+        let i = siblings.indexOf(node);
+        while (i-- >= -1) {
+            const sibling = siblings[i];
+            if (sibling?.type === compiler_dom_1.NodeTypes.COMMENT) {
+                context.removeNode(sibling);
+                comments.unshift(sibling);
+                continue;
+            }
+            if (sibling?.type === compiler_dom_1.NodeTypes.TEXT && !sibling.content.trim().length) {
+                context.removeNode(sibling);
+                continue;
+            }
+            if (sibling?.type === compiler_dom_1.NodeTypes.IF) {
+                if (!sibling.branches.at(-1).condition) {
+                    context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_ELSE_NO_ADJACENT_IF, node.loc));
+                }
+                context.removeNode();
+                const branch = createIfBranch(node, dir);
+                if (comments.length) {
+                    branch.children.unshift(...comments);
+                }
+                if (branch.userKey) {
+                    for (const { userKey } of sibling.branches) {
+                        if (isSameKey(userKey, branch.userKey)) {
+                            context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_IF_SAME_KEY, branch.userKey.loc));
+                        }
+                    }
+                }
+                sibling.branches.push(branch);
+                (0, compiler_dom_1.traverseNode)(branch, context);
+                context.currentNode = null;
+            }
+            else {
+                context.onError((0, compiler_dom_1.createCompilerError)(compiler_dom_1.ErrorCodes.X_V_ELSE_NO_ADJACENT_IF, node.loc));
+            }
+            break;
+        }
+    }
+});
+function createIfBranch(node, dir) {
+    return {
+        type: compiler_dom_1.NodeTypes.IF_BRANCH,
+        loc: node.loc,
+        condition: dir.name === 'else' ? undefined : dir.exp,
+        children: [node],
+        userKey: (0, compiler_dom_1.findProp)(node, 'key'),
+    };
+}
+function isSameKey(a, b) {
+    if (!a || a.type !== b.type) {
+        return false;
+    }
+    if (a.type === compiler_dom_1.NodeTypes.ATTRIBUTE) {
+        if (a.value.content !== b.value.content) {
+            return false;
+        }
+    }
+    else {
+        const exp = a.exp;
+        const branchExp = b.exp;
+        if (exp.type !== branchExp.type
+            || exp.type !== compiler_dom_1.NodeTypes.SIMPLE_EXPRESSION
+            || exp.isStatic !== branchExp.isStatic
+            || exp.content !== branchExp.content) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=vIf.js.map

package/lib/template/utils.d.ts

@@ -0,0 +1,3 @@
+import { type NodeTransform, type SourceLocation, type StructuralDirectiveTransform } from '@vue/compiler-dom';
+export declare function createStructuralDirectiveTransform(name: string | RegExp, fn: StructuralDirectiveTransform): NodeTransform;
+export declare function cloneLoc(loc: SourceLocation): SourceLocation;

package/lib/template/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
+exports.cloneLoc = cloneLoc;
+const compiler_dom_1 = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+function createStructuralDirectiveTransform(name, fn) {
+    const matches = (0, shared_1.isString)(name)
+        ? (n) => n === name
+        : (n) => name.test(n);
+    return (node, context) => {
+        if (node.type === compiler_dom_1.NodeTypes.ELEMENT) {
+            const { props } = node;
+            const exitFns = [];
+            for (let i = 0; i < props.length; i++) {
+                const prop = props[i];
+                if (prop.type === compiler_dom_1.NodeTypes.DIRECTIVE && matches(prop.name)) {
+                    props.splice(i, 1);
+                    i--;
+                    const onExit = fn(node, prop, context);
+                    if (onExit) {
+                        exitFns.push(onExit);
+                    }
+                }
+            }
+            return exitFns;
+        }
+    };
+}
+function cloneLoc(loc) {
+    return {
+        start: { ...loc.start },
+        end: { ...loc.end },
+        source: loc.source,
+    };
+}
+//# sourceMappingURL=utils.js.map