@vue/compiler-ssr 3.1.3 → 3.1.4

package/dist/compiler-ssr.cjs.js

@@ -397,25 +397,16 @@ function ssrProcessComponent(node, context) {
 const rawOptionsMap = new WeakMap();
 const [baseNodeTransforms, baseDirectiveTransforms] = compilerDom.getBaseTransformPreset(true);
 const vnodeNodeTransforms = [...baseNodeTransforms, ...compilerDom.DOMNodeTransforms];
-const vnodeDirectiveTransforms = {
-    ...baseDirectiveTransforms,
-    ...compilerDom.DOMDirectiveTransforms
-};
+const vnodeDirectiveTransforms = Object.assign(Object.assign({}, baseDirectiveTransforms), compilerDom.DOMDirectiveTransforms);
 function createVNodeSlotBranch(props, children, parentContext) {
     // apply a sub-transform using vnode-based transforms.
     const rawOptions = rawOptionsMap.get(parentContext.root);
-    const subOptions = {
-        ...rawOptions,
+    const subOptions = Object.assign(Object.assign({}, rawOptions), { 
         // overwrite with vnode-based transforms
         nodeTransforms: [
             ...vnodeNodeTransforms,
             ...(rawOptions.nodeTransforms || [])
-        ],
-        directiveTransforms: {
-            ...vnodeDirectiveTransforms,
-            ...(rawOptions.directiveTransforms || {})
-        }
-    };
+        ], directiveTransforms: Object.assign(Object.assign({}, vnodeDirectiveTransforms), (rawOptions.directiveTransforms || {})) });
     // wrap the children with a wrapper template for proper children treatment.
     const wrapperNode = {
         type: 1 /* ELEMENT */,
@@ -449,8 +440,8 @@ function subTransform(node, options, parentContext) {
     // like normal render functions
     childContext.ssr = false;
     // inherit parent scope analysis state
-    childContext.scopes = { ...parentContext.scopes };
-    childContext.identifiers = { ...parentContext.identifiers };
+    childContext.scopes = Object.assign({}, parentContext.scopes);
+    childContext.identifiers = Object.assign({}, parentContext.identifiers);
     childContext.imports = parentContext.imports;
     // traverse
     compilerDom.traverseNode(childRoot, childContext);
@@ -1094,26 +1085,16 @@ function injectCssVars(node) {
 }
 
 function compile(template, options = {}) {
-    options = {
-        ...options,
-        // apply DOM-specific parsing options
-        ...compilerDom.parserOptions,
-        ssr: true,
-        scopeId: options.mode === 'function' ? null : options.scopeId,
+    options = Object.assign(Object.assign(Object.assign({}, options), compilerDom.parserOptions), { ssr: 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, {
-        ...options,
-        hoistStatic: false,
-        nodeTransforms: [
+    compilerDom.transform(ast, Object.assign(Object.assign({}, options), { hoistStatic: false, nodeTransforms: [
             ssrTransformIf,
             ssrTransformFor,
             compilerDom.trackVForSlotScopes,
@@ -1126,20 +1107,14 @@ function compile(template, options = {}) {
             compilerDom.trackSlotScopes,
             compilerDom.transformStyle,
             ...(options.nodeTransforms || []) // user transforms
-        ],
-        directiveTransforms: {
+        ], directiveTransforms: Object.assign({ 
             // 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,
-            ...(options.directiveTransforms || {}) // user transforms
-        }
-    });
+            on: compilerDom.noopDirectiveTransform, cloak: compilerDom.noopDirectiveTransform, once: 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.1.3",
+  "version": "3.1.4",
   "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/vue-next/tree/master/packages/compiler-ssr#readme",
   "dependencies": {
-    "@vue/shared": "3.1.3",
-    "@vue/compiler-dom": "3.1.3"
+    "@vue/shared": "3.1.4",
+    "@vue/compiler-dom": "3.1.4"
   }
 }