@vue/compiler-ssr 3.2.31 → 3.2.34-beta.1

package/dist/compiler-ssr.cjs.js

@@ -9,6 +9,7 @@ const SSR_INTERPOLATE = Symbol(`ssrInterpolate`);
 const SSR_RENDER_VNODE = Symbol(`ssrRenderVNode`);
 const SSR_RENDER_COMPONENT = Symbol(`ssrRenderComponent`);
 const SSR_RENDER_SLOT = Symbol(`ssrRenderSlot`);
+const SSR_RENDER_SLOT_INNER = Symbol(`ssrRenderSlotInner`);
 const SSR_RENDER_CLASS = Symbol(`ssrRenderClass`);
 const SSR_RENDER_STYLE = Symbol(`ssrRenderStyle`);
 const SSR_RENDER_ATTRS = Symbol(`ssrRenderAttrs`);
@@ -28,6 +29,7 @@ const ssrHelpers = {
     [SSR_RENDER_VNODE]: `ssrRenderVNode`,
     [SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
     [SSR_RENDER_SLOT]: `ssrRenderSlot`,
+    [SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
     [SSR_RENDER_CLASS]: `ssrRenderClass`,
     [SSR_RENDER_STYLE]: `ssrRenderStyle`,
     [SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
@@ -121,7 +123,20 @@ const ssrTransformSlotOutlet = (node, context) => {
         if (context.scopeId && context.slotted !== false) {
             args.push(`"${context.scopeId}-s"`);
         }
-        node.ssrCodegenNode = compilerDom.createCallExpression(context.helper(SSR_RENDER_SLOT), args);
+        let method = SSR_RENDER_SLOT;
+        // #3989
+        // check if this is a single slot inside a transition wrapper - since
+        // transition will unwrap the slot fragment into a single vnode at runtime,
+        // we need to avoid rendering the slot as a fragment.
+        const parent = context.parent;
+        if (parent &&
+            parent.type === 1 /* ELEMENT */ &&
+            parent.tagType === 1 /* COMPONENT */ &&
+            compilerDom.resolveComponentType(parent, context, true) === compilerDom.TRANSITION &&
+            parent.children.filter(c => c.type === 1 /* ELEMENT */).length === 1) {
+            method = SSR_RENDER_SLOT_INNER;
+        }
+        node.ssrCodegenNode = compilerDom.createCallExpression(context.helper(method), args);
     }
 };
 function ssrProcessSlotOutlet(node, context) {
@@ -677,16 +692,25 @@ function ssrProcessComponent(node, context) {
 const rawOptionsMap = new WeakMap();
 const [baseNodeTransforms, baseDirectiveTransforms] = compilerDom.getBaseTransformPreset(true);
 const vnodeNodeTransforms = [...baseNodeTransforms, ...compilerDom.DOMNodeTransforms];
-const vnodeDirectiveTransforms = Object.assign(Object.assign({}, baseDirectiveTransforms), compilerDom.DOMDirectiveTransforms);
+const vnodeDirectiveTransforms = {
+    ...baseDirectiveTransforms,
+    ...compilerDom.DOMDirectiveTransforms
+};
 function createVNodeSlotBranch(props, children, parentContext) {
     // apply a sub-transform using vnode-based transforms.
     const rawOptions = rawOptionsMap.get(parentContext.root);
-    const subOptions = Object.assign(Object.assign({}, rawOptions), { 
+    const subOptions = {
+        ...rawOptions,
         // overwrite with vnode-based transforms
         nodeTransforms: [
             ...vnodeNodeTransforms,
             ...(rawOptions.nodeTransforms || [])
-        ], directiveTransforms: Object.assign(Object.assign({}, vnodeDirectiveTransforms), (rawOptions.directiveTransforms || {})) });
+        ],
+        directiveTransforms: {
+            ...vnodeDirectiveTransforms,
+            ...(rawOptions.directiveTransforms || {})
+        }
+    };
     // wrap the children with a wrapper template for proper children treatment.
     const wrapperNode = {
         type: 1 /* ELEMENT */,
@@ -720,8 +744,8 @@ function subTransform(node, options, parentContext) {
     // like normal render functions
     childContext.ssr = false;
     // inherit parent scope analysis state
-    childContext.scopes = Object.assign({}, parentContext.scopes);
-    childContext.identifiers = Object.assign({}, parentContext.identifiers);
+    childContext.scopes = { ...parentContext.scopes };
+    childContext.identifiers = { ...parentContext.identifiers };
     childContext.imports = parentContext.imports;
     // traverse
     compilerDom.traverseNode(childRoot, childContext);
@@ -1111,16 +1135,27 @@ function injectCssVars(node) {
 }
 
 function compile(template, options = {}) {
-    options = Object.assign(Object.assign(Object.assign({}, options), compilerDom.parserOptions), { ssr: true, inSSR: true, scopeId: options.mode === 'function' ? null : options.scopeId, 
+    options = {
+        ...options,
+        // apply DOM-specific parsing options
+        ...compilerDom.parserOptions,
+        ssr: true,
+        inSSR: true,
+        scopeId: options.mode === 'function' ? null : options.scopeId,
         // always prefix since compiler-ssr doesn't have size concern
-        prefixIdentifiers: true, 
+        prefixIdentifiers: true,
         // disable optimizations that are unnecessary for ssr
-        cacheHandlers: false, hoistStatic: false });
+        cacheHandlers: false,
+        hoistStatic: false
+    };
     const ast = compilerDom.baseParse(template, options);
     // Save raw options for AST. This is needed when performing sub-transforms
     // on slot vnode branches.
     rawOptionsMap.set(ast, options);
-    compilerDom.transform(ast, Object.assign(Object.assign({}, options), { hoistStatic: false, nodeTransforms: [
+    compilerDom.transform(ast, {
+        ...options,
+        hoistStatic: false,
+        nodeTransforms: [
             ssrTransformIf,
             ssrTransformFor,
             compilerDom.trackVForSlotScopes,
@@ -1133,14 +1168,21 @@ function compile(template, options = {}) {
             compilerDom.trackSlotScopes,
             compilerDom.transformStyle,
             ...(options.nodeTransforms || []) // user transforms
-        ], directiveTransforms: Object.assign({ 
+        ],
+        directiveTransforms: {
             // reusing core v-bind
-            bind: compilerDom.transformBind, 
+            bind: compilerDom.transformBind,
             // model and show has dedicated SSR handling
-            model: ssrTransformModel, show: ssrTransformShow, 
+            model: ssrTransformModel,
+            show: ssrTransformShow,
             // the following are ignored during SSR
-            on: compilerDom.noopDirectiveTransform, cloak: compilerDom.noopDirectiveTransform, once: compilerDom.noopDirectiveTransform, memo: compilerDom.noopDirectiveTransform }, (options.directiveTransforms || {}) // user transforms
-        ) }));
+            on: compilerDom.noopDirectiveTransform,
+            cloak: compilerDom.noopDirectiveTransform,
+            once: compilerDom.noopDirectiveTransform,
+            memo: compilerDom.noopDirectiveTransform,
+            ...(options.directiveTransforms || {}) // user transforms
+        }
+    });
     // traverse the template AST and convert into SSR codegen AST
     // by replacing ast.codegenNode.
     ssrCodegenTransform(ast, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-ssr",
-  "version": "3.2.31",
+  "version": "3.2.34-beta.1",
   "description": "@vue/compiler-ssr",
   "main": "dist/compiler-ssr.cjs.js",
   "types": "dist/compiler-ssr.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-ssr#readme",
   "dependencies": {
-    "@vue/shared": "3.2.31",
-    "@vue/compiler-dom": "3.2.31"
+    "@vue/shared": "3.2.34-beta.1",
+    "@vue/compiler-dom": "3.2.34-beta.1"
   }
 }