@vue/server-renderer 3.2.45 → 3.2.46

package/dist/server-renderer.cjs.prod.js

@@ -1,11 +1,22 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var vue = require('vue');
+var Vue = require('vue');
 var shared = require('@vue/shared');
 var compilerSsr = require('@vue/compiler-ssr');
 
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    for (var k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Vue__namespace = /*#__PURE__*/_interopNamespaceDefault(Vue);
+
 // leading comma for empty string ""
 const shouldIgnoreProp = shared.makeMap(`,key,ref,innerHTML,textContent,ref_key,ref_for`);
 function ssrRenderAttrs(props, tag) {
@@ -77,6 +88,207 @@ function ssrRenderStyle(raw) {
     return shared.escapeHtml(shared.stringifyStyle(styles));
 }
 
+function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
+    return renderComponentVNode(Vue.createVNode(comp, props, children), parentComponent, slotScopeId);
+}
+
+function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
+    // template-compiled slots are always rendered as fragments
+    push(`<!--[-->`);
+    ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId);
+    push(`<!--]-->`);
+}
+function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
+    const slotFn = slots[slotName];
+    if (slotFn) {
+        const slotBuffer = [];
+        const bufferedPush = (item) => {
+            slotBuffer.push(item);
+        };
+        const ret = slotFn(slotProps, bufferedPush, parentComponent, slotScopeId ? ' ' + slotScopeId : '');
+        if (shared.isArray(ret)) {
+            // normal slot
+            renderVNodeChildren(push, ret, parentComponent, slotScopeId);
+        }
+        else {
+            // ssr slot.
+            // check if the slot renders all comments, in which case use the fallback
+            let isEmptySlot = true;
+            if (transition) {
+                isEmptySlot = false;
+            }
+            else {
+                for (let i = 0; i < slotBuffer.length; i++) {
+                    if (!isComment(slotBuffer[i])) {
+                        isEmptySlot = false;
+                        break;
+                    }
+                }
+            }
+            if (isEmptySlot) {
+                if (fallbackRenderFn) {
+                    fallbackRenderFn();
+                }
+            }
+            else {
+                for (let i = 0; i < slotBuffer.length; i++) {
+                    push(slotBuffer[i]);
+                }
+            }
+        }
+    }
+    else if (fallbackRenderFn) {
+        fallbackRenderFn();
+    }
+}
+const commentTestRE = /^<!--.*-->$/s;
+const commentRE = /<!--[^]*?-->/gm;
+function isComment(item) {
+    if (typeof item !== 'string' || !commentTestRE.test(item))
+        return false;
+    // if item is '<!---->' or '<!--[-->' or '<!--]-->', return true directly
+    if (item.length <= 8)
+        return true;
+    return !item.replace(commentRE, '').trim();
+}
+
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+    parentPush('<!--teleport start-->');
+    const context = parentComponent.appContext.provides[Vue.ssrContextKey];
+    const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+    const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
+    // record current index of the target buffer to handle nested teleports
+    // since the parent needs to be rendered before the child
+    const bufferIndex = targetBuffer.length;
+    let teleportContent;
+    if (disabled) {
+        contentRenderFn(parentPush);
+        teleportContent = `<!--teleport anchor-->`;
+    }
+    else {
+        const { getBuffer, push } = createBuffer();
+        contentRenderFn(push);
+        push(`<!--teleport anchor-->`);
+        teleportContent = getBuffer();
+    }
+    targetBuffer.splice(bufferIndex, 0, teleportContent);
+    parentPush('<!--teleport end-->');
+}
+
+function ssrInterpolate(value) {
+    return shared.escapeHtml(shared.toDisplayString(value));
+}
+
+function ssrRenderList(source, renderItem) {
+    if (shared.isArray(source) || shared.isString(source)) {
+        for (let i = 0, l = source.length; i < l; i++) {
+            renderItem(source[i], i);
+        }
+    }
+    else if (typeof source === 'number') {
+        for (let i = 0; i < source; i++) {
+            renderItem(i + 1, i);
+        }
+    }
+    else if (shared.isObject(source)) {
+        if (source[Symbol.iterator]) {
+            const arr = Array.from(source);
+            for (let i = 0, l = arr.length; i < l; i++) {
+                renderItem(arr[i], i);
+            }
+        }
+        else {
+            const keys = Object.keys(source);
+            for (let i = 0, l = keys.length; i < l; i++) {
+                const key = keys[i];
+                renderItem(source[key], key, i);
+            }
+        }
+    }
+}
+
+async function ssrRenderSuspense(push, { default: renderContent }) {
+    if (renderContent) {
+        renderContent();
+    }
+    else {
+        push(`<!---->`);
+    }
+}
+
+function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
+    if (typeof dir !== 'function' && dir.getSSRProps) {
+        return (dir.getSSRProps({
+            dir,
+            instance,
+            value,
+            oldValue: undefined,
+            arg,
+            modifiers
+        }, null) || {});
+    }
+    return {};
+}
+
+const ssrLooseEqual = shared.looseEqual;
+function ssrLooseContain(arr, value) {
+    return shared.looseIndexOf(arr, value) > -1;
+}
+// for <input :type="type" v-model="model" value="value">
+function ssrRenderDynamicModel(type, model, value) {
+    switch (type) {
+        case 'radio':
+            return shared.looseEqual(model, value) ? ' checked' : '';
+        case 'checkbox':
+            return (shared.isArray(model) ? ssrLooseContain(model, value) : model)
+                ? ' checked'
+                : '';
+        default:
+            // text types
+            return ssrRenderAttr('value', model);
+    }
+}
+// for <input v-bind="obj" v-model="model">
+function ssrGetDynamicModelProps(existingProps = {}, model) {
+    const { type, value } = existingProps;
+    switch (type) {
+        case 'radio':
+            return shared.looseEqual(model, value) ? { checked: true } : null;
+        case 'checkbox':
+            return (shared.isArray(model) ? ssrLooseContain(model, value) : model)
+                ? { checked: true }
+                : null;
+        default:
+            // text types
+            return { value: model };
+    }
+}
+
+// internal runtime helpers
+
+var helpers = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ssrGetDirectiveProps: ssrGetDirectiveProps,
+  ssrGetDynamicModelProps: ssrGetDynamicModelProps,
+  ssrIncludeBooleanAttr: shared.includeBooleanAttr,
+  ssrInterpolate: ssrInterpolate,
+  ssrLooseContain: ssrLooseContain,
+  ssrLooseEqual: ssrLooseEqual,
+  ssrRenderAttr: ssrRenderAttr,
+  ssrRenderAttrs: ssrRenderAttrs,
+  ssrRenderClass: ssrRenderClass,
+  ssrRenderComponent: ssrRenderComponent,
+  ssrRenderDynamicAttr: ssrRenderDynamicAttr,
+  ssrRenderDynamicModel: ssrRenderDynamicModel,
+  ssrRenderList: ssrRenderList,
+  ssrRenderSlot: ssrRenderSlot,
+  ssrRenderSlotInner: ssrRenderSlotInner,
+  ssrRenderStyle: ssrRenderStyle,
+  ssrRenderSuspense: ssrRenderSuspense,
+  ssrRenderTeleport: ssrRenderTeleport,
+  ssrRenderVNode: renderVNode
+});
+
 const compileCache = Object.create(null);
 function ssrCompile(template, instance) {
     // TODO: This is copied from runtime-core/src/component.ts and should probably be refactored
@@ -106,33 +318,15 @@ function ssrCompile(template, instance) {
         }
     };
     const { code } = compilerSsr.compile(template, finalCompilerOptions);
-    return (compileCache[cacheKey] = Function('require', code)(require));
-}
-
-function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
-    parentPush('<!--teleport start-->');
-    const context = parentComponent.appContext.provides[vue.ssrContextKey];
-    const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
-    const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
-    // record current index of the target buffer to handle nested teleports
-    // since the parent needs to be rendered before the child
-    const bufferIndex = targetBuffer.length;
-    let teleportContent;
-    if (disabled) {
-        contentRenderFn(parentPush);
-        teleportContent = `<!--teleport anchor-->`;
-    }
-    else {
-        const { getBuffer, push } = createBuffer();
-        contentRenderFn(push);
-        push(`<!--teleport anchor-->`);
-        teleportContent = getBuffer();
-    }
-    targetBuffer.splice(bufferIndex, 0, teleportContent);
-    parentPush('<!--teleport end-->');
+    const requireMap = {
+        vue: Vue__namespace,
+        'vue/server-renderer': helpers
+    };
+    const fakeRequire = (id) => requireMap[id];
+    return (compileCache[cacheKey] = Function('require', code)(fakeRequire));
 }
 
-const { createComponentInstance, setCurrentRenderingInstance, setupComponent, renderComponentRoot, normalizeVNode } = vue.ssrUtils;
+const { createComponentInstance, setCurrentRenderingInstance, setupComponent, renderComponentRoot, normalizeVNode } = Vue.ssrUtils;
 // Each component has a buffer array.
 // A buffer array can contain one of the following:
 // - plain string
@@ -261,7 +455,7 @@ function renderComponentSubTree(instance, slotScopeId) {
         }
         else {
             const componentName = comp.name || comp.__file || `<Anonymous>`;
-            vue.warn(`Component ${componentName} is missing template or render function.`);
+            Vue.warn(`Component ${componentName} is missing template or render function.`);
             push(`<!---->`);
         }
     }
@@ -270,16 +464,16 @@ function renderComponentSubTree(instance, slotScopeId) {
 function renderVNode(push, vnode, parentComponent, slotScopeId) {
     const { type, shapeFlag, children } = vnode;
     switch (type) {
-        case vue.Text:
+        case Vue.Text:
             push(shared.escapeHtml(children));
             break;
-        case vue.Comment:
+        case Vue.Comment:
             push(children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->`);
             break;
-        case vue.Static:
+        case Vue.Static:
             push(children);
             break;
-        case vue.Fragment:
+        case Vue.Fragment:
             if (vnode.slotScopeIds) {
                 slotScopeId =
                     (slotScopeId ? slotScopeId + ' ' : '') + vnode.slotScopeIds.join(' ');
@@ -302,7 +496,7 @@ function renderVNode(push, vnode, parentComponent, slotScopeId) {
                 renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
             }
             else {
-                vue.warn('[@vue/server-renderer] Invalid VNode type:', type, `(${typeof type})`);
+                Vue.warn('[@vue/server-renderer] Invalid VNode type:', type, `(${typeof type})`);
             }
     }
 }
@@ -376,19 +570,19 @@ function applySSRDirectives(vnode, rawProps, dirs) {
                 toMerge.push(props);
         }
     }
-    return vue.mergeProps(rawProps || {}, ...toMerge);
+    return Vue.mergeProps(rawProps || {}, ...toMerge);
 }
 function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
     const target = vnode.props && vnode.props.to;
     const disabled = vnode.props && vnode.props.disabled;
     if (!target) {
         if (!disabled) {
-            vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
+            Vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
         }
         return [];
     }
     if (!shared.isString(target)) {
-        vue.warn(`[@vue/server-renderer] Teleport target must be a query selector string.`);
+        Vue.warn(`[@vue/server-renderer] Teleport target must be a query selector string.`);
         return [];
     }
     ssrRenderTeleport(push, push => {
@@ -396,8 +590,8 @@ function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
     }, target, disabled || disabled === '', parentComponent);
 }
 
-const { isVNode } = vue.ssrUtils;
-async function unrollBuffer(buffer) {
+const { isVNode: isVNode$1 } = Vue.ssrUtils;
+async function unrollBuffer$1(buffer) {
     if (buffer.hasAsync) {
         let ret = '';
         for (let i = 0; i < buffer.length; i++) {
@@ -409,7 +603,7 @@ async function unrollBuffer(buffer) {
                 ret += item;
             }
             else {
-                ret += await unrollBuffer(item);
+                ret += await unrollBuffer$1(item);
             }
         }
         return ret;
@@ -417,10 +611,10 @@ async function unrollBuffer(buffer) {
     else {
         // sync buffer can be more efficiently unrolled without unnecessary await
         // ticks
-        return unrollBufferSync(buffer);
+        return unrollBufferSync$1(buffer);
     }
 }
-function unrollBufferSync(buffer) {
+function unrollBufferSync$1(buffer) {
     let ret = '';
     for (let i = 0; i < buffer.length; i++) {
         let item = buffer[i];
@@ -429,23 +623,23 @@ function unrollBufferSync(buffer) {
         }
         else {
             // since this is a sync buffer, child buffers are never promises
-            ret += unrollBufferSync(item);
+            ret += unrollBufferSync$1(item);
         }
     }
     return ret;
 }
 async function renderToString(input, context = {}) {
-    if (isVNode(input)) {
+    if (isVNode$1(input)) {
         // raw vnode, wrap with app (for context)
-        return renderToString(vue.createApp({ render: () => input }), context);
+        return renderToString(Vue.createApp({ render: () => input }), context);
     }
     // rendering an app
-    const vnode = vue.createVNode(input._component, input._props);
+    const vnode = Vue.createVNode(input._component, input._props);
     vnode.appContext = input._context;
     // provide the ssr context to the tree
-    input.provide(vue.ssrContextKey, context);
+    input.provide(Vue.ssrContextKey, context);
     const buffer = await renderComponentVNode(vnode);
-    const result = await unrollBuffer(buffer);
+    const result = await unrollBuffer$1(buffer);
     await resolveTeleports(context);
     if (context.__watcherHandles) {
         for (const unwatch of context.__watcherHandles) {
@@ -460,13 +654,13 @@ async function resolveTeleports(context) {
         for (const key in context.__teleportBuffers) {
             // note: it's OK to await sequentially here because the Promises were
             // created eagerly in parallel.
-            context.teleports[key] = await unrollBuffer(await Promise.all([context.__teleportBuffers[key]]));
+            context.teleports[key] = await unrollBuffer$1(await Promise.all([context.__teleportBuffers[key]]));
         }
     }
 }
 
-const { isVNode: isVNode$1 } = vue.ssrUtils;
-async function unrollBuffer$1(buffer, stream) {
+const { isVNode } = Vue.ssrUtils;
+async function unrollBuffer(buffer, stream) {
     if (buffer.hasAsync) {
         for (let i = 0; i < buffer.length; i++) {
             let item = buffer[i];
@@ -477,17 +671,17 @@ async function unrollBuffer$1(buffer, stream) {
                 stream.push(item);
             }
             else {
-                await unrollBuffer$1(item, stream);
+                await unrollBuffer(item, stream);
             }
         }
     }
     else {
         // sync buffer can be more efficiently unrolled without unnecessary await
         // ticks
-        unrollBufferSync$1(buffer, stream);
+        unrollBufferSync(buffer, stream);
     }
 }
-function unrollBufferSync$1(buffer, stream) {
+function unrollBufferSync(buffer, stream) {
     for (let i = 0; i < buffer.length; i++) {
         let item = buffer[i];
         if (shared.isString(item)) {
@@ -495,22 +689,22 @@ function unrollBufferSync$1(buffer, stream) {
         }
         else {
             // since this is a sync buffer, child buffers are never promises
-            unrollBufferSync$1(item, stream);
+            unrollBufferSync(item, stream);
         }
     }
 }
 function renderToSimpleStream(input, context, stream) {
-    if (isVNode$1(input)) {
+    if (isVNode(input)) {
         // raw vnode, wrap with app (for context)
-        return renderToSimpleStream(vue.createApp({ render: () => input }), context, stream);
+        return renderToSimpleStream(Vue.createApp({ render: () => input }), context, stream);
     }
     // rendering an app
-    const vnode = vue.createVNode(input._component, input._props);
+    const vnode = Vue.createVNode(input._component, input._props);
     vnode.appContext = input._context;
     // provide the ssr context to the tree
-    input.provide(vue.ssrContextKey, context);
+    input.provide(Vue.ssrContextKey, context);
     Promise.resolve(renderComponentVNode(vnode))
-        .then(buffer => unrollBuffer$1(buffer, stream))
+        .then(buffer => unrollBuffer(buffer, stream))
         .then(() => resolveTeleports(context))
         .then(() => {
         if (context.__watcherHandles) {
@@ -617,160 +811,7 @@ function pipeToWebWritable(input, context = {}, writable) {
     });
 }
 
-function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
-    return renderComponentVNode(vue.createVNode(comp, props, children), parentComponent, slotScopeId);
-}
-
-function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
-    // template-compiled slots are always rendered as fragments
-    push(`<!--[-->`);
-    ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId);
-    push(`<!--]-->`);
-}
-function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
-    const slotFn = slots[slotName];
-    if (slotFn) {
-        const slotBuffer = [];
-        const bufferedPush = (item) => {
-            slotBuffer.push(item);
-        };
-        const ret = slotFn(slotProps, bufferedPush, parentComponent, slotScopeId ? ' ' + slotScopeId : '');
-        if (shared.isArray(ret)) {
-            // normal slot
-            renderVNodeChildren(push, ret, parentComponent, slotScopeId);
-        }
-        else {
-            // ssr slot.
-            // check if the slot renders all comments, in which case use the fallback
-            let isEmptySlot = true;
-            if (transition) {
-                isEmptySlot = false;
-            }
-            else {
-                for (let i = 0; i < slotBuffer.length; i++) {
-                    if (!isComment(slotBuffer[i])) {
-                        isEmptySlot = false;
-                        break;
-                    }
-                }
-            }
-            if (isEmptySlot) {
-                if (fallbackRenderFn) {
-                    fallbackRenderFn();
-                }
-            }
-            else {
-                for (let i = 0; i < slotBuffer.length; i++) {
-                    push(slotBuffer[i]);
-                }
-            }
-        }
-    }
-    else if (fallbackRenderFn) {
-        fallbackRenderFn();
-    }
-}
-const commentTestRE = /^<!--.*-->$/s;
-const commentRE = /<!--[^]*?-->/gm;
-function isComment(item) {
-    if (typeof item !== 'string' || !commentTestRE.test(item))
-        return false;
-    // if item is '<!---->' or '<!--[-->' or '<!--]-->', return true directly
-    if (item.length <= 8)
-        return true;
-    return !item.replace(commentRE, '').trim();
-}
-
-function ssrInterpolate(value) {
-    return shared.escapeHtml(shared.toDisplayString(value));
-}
-
-function ssrRenderList(source, renderItem) {
-    if (shared.isArray(source) || shared.isString(source)) {
-        for (let i = 0, l = source.length; i < l; i++) {
-            renderItem(source[i], i);
-        }
-    }
-    else if (typeof source === 'number') {
-        for (let i = 0; i < source; i++) {
-            renderItem(i + 1, i);
-        }
-    }
-    else if (shared.isObject(source)) {
-        if (source[Symbol.iterator]) {
-            const arr = Array.from(source);
-            for (let i = 0, l = arr.length; i < l; i++) {
-                renderItem(arr[i], i);
-            }
-        }
-        else {
-            const keys = Object.keys(source);
-            for (let i = 0, l = keys.length; i < l; i++) {
-                const key = keys[i];
-                renderItem(source[key], key, i);
-            }
-        }
-    }
-}
-
-async function ssrRenderSuspense(push, { default: renderContent }) {
-    if (renderContent) {
-        renderContent();
-    }
-    else {
-        push(`<!---->`);
-    }
-}
-
-function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
-    if (typeof dir !== 'function' && dir.getSSRProps) {
-        return (dir.getSSRProps({
-            dir,
-            instance,
-            value,
-            oldValue: undefined,
-            arg,
-            modifiers
-        }, null) || {});
-    }
-    return {};
-}
-
-const ssrLooseEqual = shared.looseEqual;
-function ssrLooseContain(arr, value) {
-    return shared.looseIndexOf(arr, value) > -1;
-}
-// for <input :type="type" v-model="model" value="value">
-function ssrRenderDynamicModel(type, model, value) {
-    switch (type) {
-        case 'radio':
-            return shared.looseEqual(model, value) ? ' checked' : '';
-        case 'checkbox':
-            return (shared.isArray(model) ? ssrLooseContain(model, value) : model)
-                ? ' checked'
-                : '';
-        default:
-            // text types
-            return ssrRenderAttr('value', model);
-    }
-}
-// for <input v-bind="obj" v-model="model">
-function ssrGetDynamicModelProps(existingProps = {}, model) {
-    const { type, value } = existingProps;
-    switch (type) {
-        case 'radio':
-            return shared.looseEqual(model, value) ? { checked: true } : null;
-        case 'checkbox':
-            return (shared.isArray(model) ? ssrLooseContain(model, value) : model)
-                ? { checked: true }
-                : null;
-        default:
-            // text types
-            return { value: model };
-    }
-}
-
-vue.initDirectivesForSSR();
+Vue.initDirectivesForSSR();
 
 exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr;
 exports.pipeToNodeWritable = pipeToNodeWritable;