@vue/compiler-sfc 3.2.7 → 3.2.11

package/dist/compiler-sfc.cjs.js

@@ -1438,6 +1438,10 @@ function compileScript(sfc, options) {
                     `${DEFINE_PROPS} declaration.`, node);
             }
             propsRuntimeDefaults = node.arguments[1];
+            if (!propsRuntimeDefaults ||
+                propsRuntimeDefaults.type !== 'ObjectExpression') {
+                error(`The 2nd argument of ${WITH_DEFAULTS} must be an object literal.`, propsRuntimeDefaults || node);
+            }
         }
         else {
             error(`${WITH_DEFAULTS}' first argument must be a ${DEFINE_PROPS} call.`, node.arguments[0] || node);
@@ -1488,7 +1492,10 @@ function compileScript(sfc, options) {
                     return isQualifiedType(node.declaration);
                 }
             };
-            for (const node of scriptSetupAst.body) {
+            const body = scriptAst
+                ? [...scriptSetupAst.body, ...scriptAst.body]
+                : scriptSetupAst.body;
+            for (const node of body) {
                 const qualified = isQualifiedType(node);
                 if (qualified) {
                     return qualified;
@@ -1528,17 +1535,24 @@ function compileScript(sfc, options) {
         s.overwrite(node.start + startOffset, node.argument.start + startOffset, `${isStatement ? `;` : ``}(([__temp,__restore]=${helper(`withAsyncContext`)}(()=>(`);
         s.appendLeft(node.end + startOffset, `))),__temp=await __temp,__restore()${isStatement ? `` : `,__temp`})`);
     }
+    /**
+     * check defaults. If the default object is an object literal with only
+     * static properties, we can directly generate more optimzied default
+     * declarations. Otherwise we will have to fallback to runtime merging.
+     */
+    function checkStaticDefaults() {
+        return (propsRuntimeDefaults &&
+            propsRuntimeDefaults.type === 'ObjectExpression' &&
+            propsRuntimeDefaults.properties.every(node => (node.type === 'ObjectProperty' && !node.computed) ||
+                node.type === 'ObjectMethod'));
+    }
     function genRuntimeProps(props) {
         const keys = Object.keys(props);
         if (!keys.length) {
             return ``;
         }
-        // check defaults. If the default object is an object literal with only
-        // static properties, we can directly generate more optimzied default
-        // decalrations. Otherwise we will have to fallback to runtime merging.
-        const hasStaticDefaults = propsRuntimeDefaults &&
-            propsRuntimeDefaults.type === 'ObjectExpression' &&
-            propsRuntimeDefaults.properties.every(node => node.type === 'ObjectProperty' && !node.computed);
+        const hasStaticDefaults = checkStaticDefaults();
+        const scriptSetupSource = scriptSetup.content;
         let propsDecls = `{
     ${keys
             .map(key => {
@@ -1546,8 +1560,13 @@ function compileScript(sfc, options) {
             if (hasStaticDefaults) {
                 const prop = propsRuntimeDefaults.properties.find((node) => node.key.name === key);
                 if (prop) {
-                    // prop has corresponding static default value
-                    defaultString = `default: ${source.slice(prop.value.start + startOffset, prop.value.end + startOffset)}`;
+                    if (prop.type === 'ObjectProperty') {
+                        // prop has corresponding static default value
+                        defaultString = `default: ${scriptSetupSource.slice(prop.value.start, prop.value.end)}`;
+                    }
+                    else {
+                        defaultString = `default() ${scriptSetupSource.slice(prop.body.start, prop.body.end)}`;
+                    }
                 }
             }
             {
@@ -1559,7 +1578,38 @@ function compileScript(sfc, options) {
         if (propsRuntimeDefaults && !hasStaticDefaults) {
             propsDecls = `${helper('mergeDefaults')}(${propsDecls}, ${source.slice(propsRuntimeDefaults.start + startOffset, propsRuntimeDefaults.end + startOffset)})`;
         }
-        return `\n  props: ${propsDecls} as unknown as undefined,`;
+        return `\n  props: ${propsDecls},`;
+    }
+    function genSetupPropsType(node) {
+        const scriptSetupSource = scriptSetup.content;
+        if (checkStaticDefaults()) {
+            // if withDefaults() is used, we need to remove the optional flags
+            // on props that have default values
+            let res = `{ `;
+            const members = node.type === 'TSTypeLiteral' ? node.members : node.body;
+            for (const m of members) {
+                if ((m.type === 'TSPropertySignature' ||
+                    m.type === 'TSMethodSignature') &&
+                    m.typeAnnotation &&
+                    m.key.type === 'Identifier') {
+                    if (propsRuntimeDefaults.properties.some((p) => p.key.name === m.key.name)) {
+                        res +=
+                            m.key.name +
+                                (m.type === 'TSMethodSignature' ? '()' : '') +
+                                scriptSetupSource.slice(m.typeAnnotation.start, m.typeAnnotation.end) +
+                                ', ';
+                    }
+                    else {
+                        res +=
+                            scriptSetupSource.slice(m.start, m.typeAnnotation.end) + `, `;
+                    }
+                }
+            }
+            return (res.length ? res.slice(0, -2) : res) + ` }`;
+        }
+        else {
+            return scriptSetupSource.slice(node.start, node.end);
+        }
     }
     // 1. process normal <script> first if it exists
     let scriptAst;
@@ -1756,7 +1806,7 @@ function compileScript(sfc, options) {
                 }
             }
         }
-        // walk decalrations to record declared bindings
+        // walk declarations to record declared bindings
         if ((node.type === 'VariableDeclaration' ||
             node.type === 'FunctionDeclaration' ||
             node.type === 'ClassDeclaration') &&
@@ -1879,17 +1929,20 @@ function compileScript(sfc, options) {
     // 9. finalize setup() argument signature
     let args = `__props`;
     if (propsTypeDecl) {
-        args += `: ${scriptSetup.content.slice(propsTypeDecl.start, propsTypeDecl.end)}`;
+        // mark as any and only cast on assignment
+        // since the user defined complex types may be incompatible with the
+        // inferred type from generated runtime declarations
+        args += `: any`;
     }
     // inject user assignment of props
     // we use a default __props so that template expressions referencing props
     // can use it directly
     if (propsIdentifier) {
-        s.prependRight(startOffset, `\nconst ${propsIdentifier} = __props`);
+        s.prependRight(startOffset, `\nconst ${propsIdentifier} = __props${propsTypeDecl ? ` as ${genSetupPropsType(propsTypeDecl)}` : ``}`);
     }
     // inject temp variables for async context preservation
     if (hasAwait) {
-        const any = isTS ? `:any` : ``;
+        const any = isTS ? `: any` : ``;
         s.prependRight(startOffset, `\nlet __temp${any}, __restore${any}\n`);
     }
     const destructureElements = hasDefineExposeCall || !options.inlineTemplate ? [`expose`] : [];
@@ -2230,6 +2283,7 @@ function inferRuntimeType(node, declaredTypes) {
                     case 'Map':
                     case 'WeakSet':
                     case 'WeakMap':
+                    case 'Date':
                         return [node.typeName.name];
                     case 'Record':
                     case 'Partial':
@@ -2297,7 +2351,7 @@ function genRuntimeEmits(emits) {
     return emits.size
         ? `\n  emits: [${Array.from(emits)
             .map(p => JSON.stringify(p))
-            .join(', ')}] as unknown as undefined,`
+            .join(', ')}],`
         : ``;
 }
 function isCallOf(node, test) {