| | |
| | |
| | |
| | |
| | |
| | 'use strict'; |
| |
|
| | Object.defineProperty(exports, '__esModule', { value: true }); |
| |
|
| | 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 = _interopNamespaceDefault(Vue); |
| |
|
| | const shouldIgnoreProp = shared.makeMap( |
| | `,key,ref,innerHTML,textContent,ref_key,ref_for` |
| | ); |
| | function ssrRenderAttrs(props, tag) { |
| | let ret = ""; |
| | for (const key in props) { |
| | if (shouldIgnoreProp(key) || shared.isOn(key) || tag === "textarea" && key === "value") { |
| | continue; |
| | } |
| | const value = props[key]; |
| | if (key === "class") { |
| | ret += ` class="${ssrRenderClass(value)}"`; |
| | } else if (key === "style") { |
| | ret += ` style="${ssrRenderStyle(value)}"`; |
| | } else { |
| | ret += ssrRenderDynamicAttr(key, value, tag); |
| | } |
| | } |
| | return ret; |
| | } |
| | function ssrRenderDynamicAttr(key, value, tag) { |
| | if (!shared.isRenderableAttrValue(value)) { |
| | return ``; |
| | } |
| | const attrKey = tag && (tag.indexOf("-") > 0 || shared.isSVGTag(tag)) ? key : shared.propsToAttrMap[key] || key.toLowerCase(); |
| | if (shared.isBooleanAttr(attrKey)) { |
| | return shared.includeBooleanAttr(value) ? ` ${attrKey}` : ``; |
| | } else if (shared.isSSRSafeAttrName(attrKey)) { |
| | return value === "" ? ` ${attrKey}` : ` ${attrKey}="${shared.escapeHtml(value)}"`; |
| | } else { |
| | console.warn( |
| | `[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}` |
| | ); |
| | return ``; |
| | } |
| | } |
| | function ssrRenderAttr(key, value) { |
| | if (!shared.isRenderableAttrValue(value)) { |
| | return ``; |
| | } |
| | return ` ${key}="${shared.escapeHtml(value)}"`; |
| | } |
| | function ssrRenderClass(raw) { |
| | return shared.escapeHtml(shared.normalizeClass(raw)); |
| | } |
| | function ssrRenderStyle(raw) { |
| | if (!raw) { |
| | return ""; |
| | } |
| | if (shared.isString(raw)) { |
| | return shared.escapeHtml(raw); |
| | } |
| | const styles = shared.normalizeStyle(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) { |
| | 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)) { |
| | renderVNodeChildren(push, ret, parentComponent, slotScopeId); |
| | } else { |
| | 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 { |
| | let start = 0; |
| | let end = slotBuffer.length; |
| | if (transition && slotBuffer[0] === "<!--[-->" && slotBuffer[end - 1] === "<!--]-->") { |
| | start++; |
| | end--; |
| | } |
| | for (let i = start; i < end; 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.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] = []); |
| | 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 toRaw(observed) { |
| | const raw = observed && observed["__v_raw"]; |
| | return raw ? toRaw(raw) : observed; |
| | } |
| |
|
| | function isRef(r) { |
| | return !!(r && r.__v_isRef === true); |
| | } |
| |
|
| | const stack = []; |
| | function pushWarningContext(vnode) { |
| | stack.push(vnode); |
| | } |
| | function popWarningContext() { |
| | stack.pop(); |
| | } |
| | function warn$1(msg, ...args) { |
| | const instance = stack.length ? stack[stack.length - 1].component : null; |
| | const appWarnHandler = instance && instance.appContext.config.warnHandler; |
| | const trace = getComponentTrace(); |
| | if (appWarnHandler) { |
| | callWithErrorHandling( |
| | appWarnHandler, |
| | instance, |
| | 11, |
| | [ |
| | msg + args.join(""), |
| | instance && instance.proxy, |
| | trace.map( |
| | ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>` |
| | ).join("\n"), |
| | trace |
| | ] |
| | ); |
| | } else { |
| | const warnArgs = [`[Vue warn]: ${msg}`, ...args]; |
| | if (trace.length && |
| | true) { |
| | warnArgs.push(` |
| | `, ...formatTrace(trace)); |
| | } |
| | console.warn(...warnArgs); |
| | } |
| | } |
| | function getComponentTrace() { |
| | let currentVNode = stack[stack.length - 1]; |
| | if (!currentVNode) { |
| | return []; |
| | } |
| | const normalizedStack = []; |
| | while (currentVNode) { |
| | const last = normalizedStack[0]; |
| | if (last && last.vnode === currentVNode) { |
| | last.recurseCount++; |
| | } else { |
| | normalizedStack.push({ |
| | vnode: currentVNode, |
| | recurseCount: 0 |
| | }); |
| | } |
| | const parentInstance = currentVNode.component && currentVNode.component.parent; |
| | currentVNode = parentInstance && parentInstance.vnode; |
| | } |
| | return normalizedStack; |
| | } |
| | function formatTrace(trace) { |
| | const logs = []; |
| | trace.forEach((entry, i) => { |
| | logs.push(...i === 0 ? [] : [` |
| | `], ...formatTraceEntry(entry)); |
| | }); |
| | return logs; |
| | } |
| | function formatTraceEntry({ vnode, recurseCount }) { |
| | const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; |
| | const isRoot = vnode.component ? vnode.component.parent == null : false; |
| | const open = ` at <${formatComponentName( |
| | vnode.component, |
| | vnode.type, |
| | isRoot |
| | )}`; |
| | const close = `>` + postfix; |
| | return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; |
| | } |
| | function formatProps(props) { |
| | const res = []; |
| | const keys = Object.keys(props); |
| | keys.slice(0, 3).forEach((key) => { |
| | res.push(...formatProp(key, props[key])); |
| | }); |
| | if (keys.length > 3) { |
| | res.push(` ...`); |
| | } |
| | return res; |
| | } |
| | function formatProp(key, value, raw) { |
| | if (shared.isString(value)) { |
| | value = JSON.stringify(value); |
| | return raw ? value : [`${key}=${value}`]; |
| | } else if (typeof value === "number" || typeof value === "boolean" || value == null) { |
| | return raw ? value : [`${key}=${value}`]; |
| | } else if (isRef(value)) { |
| | value = formatProp(key, toRaw(value.value), true); |
| | return raw ? value : [`${key}=Ref<`, value, `>`]; |
| | } else if (shared.isFunction(value)) { |
| | return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; |
| | } else { |
| | value = toRaw(value); |
| | return raw ? value : [`${key}=`, value]; |
| | } |
| | } |
| |
|
| | const ErrorTypeStrings = { |
| | ["sp"]: "serverPrefetch hook", |
| | ["bc"]: "beforeCreate hook", |
| | ["c"]: "created hook", |
| | ["bm"]: "beforeMount hook", |
| | ["m"]: "mounted hook", |
| | ["bu"]: "beforeUpdate hook", |
| | ["u"]: "updated", |
| | ["bum"]: "beforeUnmount hook", |
| | ["um"]: "unmounted hook", |
| | ["a"]: "activated hook", |
| | ["da"]: "deactivated hook", |
| | ["ec"]: "errorCaptured hook", |
| | ["rtc"]: "renderTracked hook", |
| | ["rtg"]: "renderTriggered hook", |
| | [0]: "setup function", |
| | [1]: "render function", |
| | [2]: "watcher getter", |
| | [3]: "watcher callback", |
| | [4]: "watcher cleanup function", |
| | [5]: "native event handler", |
| | [6]: "component event handler", |
| | [7]: "vnode hook", |
| | [8]: "directive hook", |
| | [9]: "transition hook", |
| | [10]: "app errorHandler", |
| | [11]: "app warnHandler", |
| | [12]: "ref function", |
| | [13]: "async component loader", |
| | [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ." |
| | }; |
| | function callWithErrorHandling(fn, instance, type, args) { |
| | try { |
| | return args ? fn(...args) : fn(); |
| | } catch (err) { |
| | handleError(err, instance, type); |
| | } |
| | } |
| | function handleError(err, instance, type, throwInDev = true) { |
| | const contextVNode = instance ? instance.vnode : null; |
| | if (instance) { |
| | let cur = instance.parent; |
| | const exposedInstance = instance.proxy; |
| | const errorInfo = ErrorTypeStrings[type] ; |
| | while (cur) { |
| | const errorCapturedHooks = cur.ec; |
| | if (errorCapturedHooks) { |
| | for (let i = 0; i < errorCapturedHooks.length; i++) { |
| | if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { |
| | return; |
| | } |
| | } |
| | } |
| | cur = cur.parent; |
| | } |
| | const appErrorHandler = instance.appContext.config.errorHandler; |
| | if (appErrorHandler) { |
| | callWithErrorHandling( |
| | appErrorHandler, |
| | null, |
| | 10, |
| | [err, exposedInstance, errorInfo] |
| | ); |
| | return; |
| | } |
| | } |
| | logError(err, type, contextVNode, throwInDev); |
| | } |
| | function logError(err, type, contextVNode, throwInDev = true) { |
| | { |
| | const info = ErrorTypeStrings[type]; |
| | if (contextVNode) { |
| | pushWarningContext(contextVNode); |
| | } |
| | warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`); |
| | if (contextVNode) { |
| | popWarningContext(); |
| | } |
| | if (throwInDev) { |
| | throw err; |
| | } else { |
| | console.error(err); |
| | } |
| | } |
| | } |
| |
|
| | { |
| | const g = shared.getGlobalThis(); |
| | const registerGlobalSetter = (key, setter) => { |
| | let setters; |
| | if (!(setters = g[key])) |
| | setters = g[key] = []; |
| | setters.push(setter); |
| | return (v) => { |
| | if (setters.length > 1) |
| | setters.forEach((set) => set(v)); |
| | else |
| | setters[0](v); |
| | }; |
| | }; |
| | registerGlobalSetter( |
| | `__VUE_INSTANCE_SETTERS__`, |
| | (v) => v |
| | ); |
| | registerGlobalSetter( |
| | `__VUE_SSR_SETTERS__`, |
| | (v) => v |
| | ); |
| | } |
| | const classifyRE = /(?:^|[-_])(\w)/g; |
| | const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, ""); |
| | function getComponentName(Component, includeInferred = true) { |
| | return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name; |
| | } |
| | function formatComponentName(instance, Component, isRoot = false) { |
| | let name = getComponentName(Component); |
| | if (!name && Component.__file) { |
| | const match = Component.__file.match(/([^/\\]+)\.\w+$/); |
| | if (match) { |
| | name = match[1]; |
| | } |
| | } |
| | if (!name && instance && instance.parent) { |
| | const inferFromRegistry = (registry) => { |
| | for (const key in registry) { |
| | if (registry[key] === Component) { |
| | return key; |
| | } |
| | } |
| | }; |
| | name = inferFromRegistry( |
| | instance.components || instance.parent.type.components |
| | ) || inferFromRegistry(instance.appContext.components); |
| | } |
| | return name ? classify(name) : isRoot ? `App` : `Anonymous`; |
| | } |
| |
|
| | const warn = warn$1 ; |
| |
|
| | 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") { |
| | if (!Number.isInteger(source)) { |
| | warn(`The v-for range expect an integer value but got ${source}.`); |
| | return; |
| | } |
| | 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: void 0, |
| | arg, |
| | modifiers |
| | }, |
| | null |
| | ) || {}; |
| | } |
| | return {}; |
| | } |
| |
|
| | const ssrLooseEqual = shared.looseEqual; |
| | function ssrLooseContain(arr, value) { |
| | return shared.looseIndexOf(arr, value) > -1; |
| | } |
| | 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: |
| | return ssrRenderAttr("value", 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: |
| | return { value: model }; |
| | } |
| | } |
| |
|
| | var helpers = 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) { |
| | const Component = instance.type; |
| | const { isCustomElement, compilerOptions } = instance.appContext.config; |
| | const { delimiters, compilerOptions: componentCompilerOptions } = Component; |
| | const finalCompilerOptions = shared.extend( |
| | shared.extend( |
| | { |
| | isCustomElement, |
| | delimiters |
| | }, |
| | compilerOptions |
| | ), |
| | componentCompilerOptions |
| | ); |
| | finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || shared.NO; |
| | finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || shared.NO; |
| | const cacheKey = JSON.stringify( |
| | { |
| | template, |
| | compilerOptions: finalCompilerOptions |
| | }, |
| | (key, value) => { |
| | return shared.isFunction(value) ? value.toString() : value; |
| | } |
| | ); |
| | const cached = compileCache[cacheKey]; |
| | if (cached) { |
| | return cached; |
| | } |
| | finalCompilerOptions.onError = (err) => { |
| | { |
| | const message = `[@vue/server-renderer] Template compilation error: ${err.message}`; |
| | const codeFrame = err.loc && shared.generateCodeFrame( |
| | template, |
| | err.loc.start.offset, |
| | err.loc.end.offset |
| | ); |
| | Vue.warn(codeFrame ? `${message} |
| | ${codeFrame}` : message); |
| | } |
| | }; |
| | const { code } = compilerSsr.compile(template, finalCompilerOptions); |
| | 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; |
| | function createBuffer() { |
| | let appendable = false; |
| | const buffer = []; |
| | return { |
| | getBuffer() { |
| | return buffer; |
| | }, |
| | push(item) { |
| | const isStringItem = shared.isString(item); |
| | if (appendable && isStringItem) { |
| | buffer[buffer.length - 1] += item; |
| | } else { |
| | buffer.push(item); |
| | } |
| | appendable = isStringItem; |
| | if (shared.isPromise(item) || shared.isArray(item) && item.hasAsync) { |
| | buffer.hasAsync = true; |
| | } |
| | } |
| | }; |
| | } |
| | function renderComponentVNode(vnode, parentComponent = null, slotScopeId) { |
| | const instance = createComponentInstance(vnode, parentComponent, null); |
| | const res = setupComponent( |
| | instance, |
| | true |
| | |
| | ); |
| | const hasAsyncSetup = shared.isPromise(res); |
| | const prefetches = instance.sp; |
| | if (hasAsyncSetup || prefetches) { |
| | let p = hasAsyncSetup ? res : Promise.resolve(); |
| | if (prefetches) { |
| | p = p.then( |
| | () => Promise.all( |
| | prefetches.map((prefetch) => prefetch.call(instance.proxy)) |
| | ) |
| | ).catch(shared.NOOP); |
| | } |
| | return p.then(() => renderComponentSubTree(instance, slotScopeId)); |
| | } else { |
| | return renderComponentSubTree(instance, slotScopeId); |
| | } |
| | } |
| | function renderComponentSubTree(instance, slotScopeId) { |
| | const comp = instance.type; |
| | const { getBuffer, push } = createBuffer(); |
| | if (shared.isFunction(comp)) { |
| | let root = renderComponentRoot(instance); |
| | if (!comp.props) { |
| | for (const key in instance.attrs) { |
| | if (key.startsWith(`data-v-`)) { |
| | (root.props || (root.props = {}))[key] = ``; |
| | } |
| | } |
| | } |
| | renderVNode(push, instance.subTree = root, instance, slotScopeId); |
| | } else { |
| | if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) { |
| | comp.ssrRender = ssrCompile(comp.template, instance); |
| | } |
| | for (const e of instance.scope.effects) { |
| | if (e.computed) { |
| | e.computed._dirty = true; |
| | e.computed._cacheable = true; |
| | } |
| | } |
| | const ssrRender = instance.ssrRender || comp.ssrRender; |
| | if (ssrRender) { |
| | let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0; |
| | let hasCloned = false; |
| | let cur = instance; |
| | while (true) { |
| | const scopeId = cur.vnode.scopeId; |
| | if (scopeId) { |
| | if (!hasCloned) { |
| | attrs = { ...attrs }; |
| | hasCloned = true; |
| | } |
| | attrs[scopeId] = ""; |
| | } |
| | const parent = cur.parent; |
| | if (parent && parent.subTree && parent.subTree === cur.vnode) { |
| | cur = parent; |
| | } else { |
| | break; |
| | } |
| | } |
| | if (slotScopeId) { |
| | if (!hasCloned) |
| | attrs = { ...attrs }; |
| | attrs[slotScopeId.trim()] = ""; |
| | } |
| | const prev = setCurrentRenderingInstance(instance); |
| | try { |
| | ssrRender( |
| | instance.proxy, |
| | push, |
| | instance, |
| | attrs, |
| | |
| | instance.props, |
| | instance.setupState, |
| | instance.data, |
| | instance.ctx |
| | ); |
| | } finally { |
| | setCurrentRenderingInstance(prev); |
| | } |
| | } else if (instance.render && instance.render !== shared.NOOP) { |
| | renderVNode( |
| | push, |
| | instance.subTree = renderComponentRoot(instance), |
| | instance, |
| | slotScopeId |
| | ); |
| | } else { |
| | const componentName = comp.name || comp.__file || `<Anonymous>`; |
| | Vue.warn(`Component ${componentName} is missing template or render function.`); |
| | push(`<!---->`); |
| | } |
| | } |
| | return getBuffer(); |
| | } |
| | function renderVNode(push, vnode, parentComponent, slotScopeId) { |
| | const { type, shapeFlag, children } = vnode; |
| | switch (type) { |
| | case Vue.Text: |
| | push(shared.escapeHtml(children)); |
| | break; |
| | case Vue.Comment: |
| | push( |
| | children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->` |
| | ); |
| | break; |
| | case Vue.Static: |
| | push(children); |
| | break; |
| | case Vue.Fragment: |
| | if (vnode.slotScopeIds) { |
| | slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" "); |
| | } |
| | push(`<!--[-->`); |
| | renderVNodeChildren( |
| | push, |
| | children, |
| | parentComponent, |
| | slotScopeId |
| | ); |
| | push(`<!--]-->`); |
| | break; |
| | default: |
| | if (shapeFlag & 1) { |
| | renderElementVNode(push, vnode, parentComponent, slotScopeId); |
| | } else if (shapeFlag & 6) { |
| | push(renderComponentVNode(vnode, parentComponent, slotScopeId)); |
| | } else if (shapeFlag & 64) { |
| | renderTeleportVNode(push, vnode, parentComponent, slotScopeId); |
| | } else if (shapeFlag & 128) { |
| | renderVNode(push, vnode.ssContent, parentComponent, slotScopeId); |
| | } else { |
| | Vue.warn( |
| | "[@vue/server-renderer] Invalid VNode type:", |
| | type, |
| | `(${typeof type})` |
| | ); |
| | } |
| | } |
| | } |
| | function renderVNodeChildren(push, children, parentComponent, slotScopeId) { |
| | for (let i = 0; i < children.length; i++) { |
| | renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId); |
| | } |
| | } |
| | function renderElementVNode(push, vnode, parentComponent, slotScopeId) { |
| | const tag = vnode.type; |
| | let { props, children, shapeFlag, scopeId, dirs } = vnode; |
| | let openTag = `<${tag}`; |
| | if (dirs) { |
| | props = applySSRDirectives(vnode, props, dirs); |
| | } |
| | if (props) { |
| | openTag += ssrRenderAttrs(props, tag); |
| | } |
| | if (scopeId) { |
| | openTag += ` ${scopeId}`; |
| | } |
| | let curParent = parentComponent; |
| | let curVnode = vnode; |
| | while (curParent && curVnode === curParent.subTree) { |
| | curVnode = curParent.vnode; |
| | if (curVnode.scopeId) { |
| | openTag += ` ${curVnode.scopeId}`; |
| | } |
| | curParent = curParent.parent; |
| | } |
| | if (slotScopeId) { |
| | openTag += ` ${slotScopeId}`; |
| | } |
| | push(openTag + `>`); |
| | if (!shared.isVoidTag(tag)) { |
| | let hasChildrenOverride = false; |
| | if (props) { |
| | if (props.innerHTML) { |
| | hasChildrenOverride = true; |
| | push(props.innerHTML); |
| | } else if (props.textContent) { |
| | hasChildrenOverride = true; |
| | push(shared.escapeHtml(props.textContent)); |
| | } else if (tag === "textarea" && props.value) { |
| | hasChildrenOverride = true; |
| | push(shared.escapeHtml(props.value)); |
| | } |
| | } |
| | if (!hasChildrenOverride) { |
| | if (shapeFlag & 8) { |
| | push(shared.escapeHtml(children)); |
| | } else if (shapeFlag & 16) { |
| | renderVNodeChildren( |
| | push, |
| | children, |
| | parentComponent, |
| | slotScopeId |
| | ); |
| | } |
| | } |
| | push(`</${tag}>`); |
| | } |
| | } |
| | function applySSRDirectives(vnode, rawProps, dirs) { |
| | const toMerge = []; |
| | for (let i = 0; i < dirs.length; i++) { |
| | const binding = dirs[i]; |
| | const { |
| | dir: { getSSRProps } |
| | } = binding; |
| | if (getSSRProps) { |
| | const props = getSSRProps(binding, vnode); |
| | if (props) |
| | toMerge.push(props); |
| | } |
| | } |
| | 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.`); |
| | } |
| | return []; |
| | } |
| | if (!shared.isString(target)) { |
| | Vue.warn( |
| | `[@vue/server-renderer] Teleport target must be a query selector string.` |
| | ); |
| | return []; |
| | } |
| | ssrRenderTeleport( |
| | push, |
| | (push2) => { |
| | renderVNodeChildren( |
| | push2, |
| | vnode.children, |
| | parentComponent, |
| | slotScopeId |
| | ); |
| | }, |
| | target, |
| | disabled || disabled === "", |
| | parentComponent |
| | ); |
| | } |
| |
|
| | const { isVNode: isVNode$1 } = Vue.ssrUtils; |
| | async function unrollBuffer$1(buffer) { |
| | if (buffer.hasAsync) { |
| | let ret = ""; |
| | for (let i = 0; i < buffer.length; i++) { |
| | let item = buffer[i]; |
| | if (shared.isPromise(item)) { |
| | item = await item; |
| | } |
| | if (shared.isString(item)) { |
| | ret += item; |
| | } else { |
| | ret += await unrollBuffer$1(item); |
| | } |
| | } |
| | return ret; |
| | } else { |
| | return unrollBufferSync$1(buffer); |
| | } |
| | } |
| | function unrollBufferSync$1(buffer) { |
| | let ret = ""; |
| | for (let i = 0; i < buffer.length; i++) { |
| | let item = buffer[i]; |
| | if (shared.isString(item)) { |
| | ret += item; |
| | } else { |
| | ret += unrollBufferSync$1(item); |
| | } |
| | } |
| | return ret; |
| | } |
| | async function renderToString(input, context = {}) { |
| | if (isVNode$1(input)) { |
| | return renderToString(Vue.createApp({ render: () => input }), context); |
| | } |
| | const vnode = Vue.createVNode(input._component, input._props); |
| | vnode.appContext = input._context; |
| | input.provide(Vue.ssrContextKey, context); |
| | const buffer = await renderComponentVNode(vnode); |
| | const result = await unrollBuffer$1(buffer); |
| | await resolveTeleports(context); |
| | if (context.__watcherHandles) { |
| | for (const unwatch of context.__watcherHandles) { |
| | unwatch(); |
| | } |
| | } |
| | return result; |
| | } |
| | async function resolveTeleports(context) { |
| | if (context.__teleportBuffers) { |
| | context.teleports = context.teleports || {}; |
| | for (const key in context.__teleportBuffers) { |
| | context.teleports[key] = await unrollBuffer$1( |
| | await Promise.all([context.__teleportBuffers[key]]) |
| | ); |
| | } |
| | } |
| | } |
| |
|
| | const { isVNode } = Vue.ssrUtils; |
| | async function unrollBuffer(buffer, stream) { |
| | if (buffer.hasAsync) { |
| | for (let i = 0; i < buffer.length; i++) { |
| | let item = buffer[i]; |
| | if (shared.isPromise(item)) { |
| | item = await item; |
| | } |
| | if (shared.isString(item)) { |
| | stream.push(item); |
| | } else { |
| | await unrollBuffer(item, stream); |
| | } |
| | } |
| | } else { |
| | unrollBufferSync(buffer, stream); |
| | } |
| | } |
| | function unrollBufferSync(buffer, stream) { |
| | for (let i = 0; i < buffer.length; i++) { |
| | let item = buffer[i]; |
| | if (shared.isString(item)) { |
| | stream.push(item); |
| | } else { |
| | unrollBufferSync(item, stream); |
| | } |
| | } |
| | } |
| | function renderToSimpleStream(input, context, stream) { |
| | if (isVNode(input)) { |
| | return renderToSimpleStream( |
| | Vue.createApp({ render: () => input }), |
| | context, |
| | stream |
| | ); |
| | } |
| | const vnode = Vue.createVNode(input._component, input._props); |
| | vnode.appContext = input._context; |
| | input.provide(Vue.ssrContextKey, context); |
| | Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => { |
| | if (context.__watcherHandles) { |
| | for (const unwatch of context.__watcherHandles) { |
| | unwatch(); |
| | } |
| | } |
| | }).then(() => stream.push(null)).catch((error) => { |
| | stream.destroy(error); |
| | }); |
| | return stream; |
| | } |
| | function renderToStream(input, context = {}) { |
| | console.warn( |
| | `[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.` |
| | ); |
| | return renderToNodeStream(input, context); |
| | } |
| | function renderToNodeStream(input, context = {}) { |
| | const stream = new (require("node:stream")).Readable({ read() { |
| | } }) ; |
| | if (!stream) { |
| | throw new Error( |
| | `ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.` |
| | ); |
| | } |
| | return renderToSimpleStream(input, context, stream); |
| | } |
| | function pipeToNodeWritable(input, context = {}, writable) { |
| | renderToSimpleStream(input, context, { |
| | push(content) { |
| | if (content != null) { |
| | writable.write(content); |
| | } else { |
| | writable.end(); |
| | } |
| | }, |
| | destroy(err) { |
| | writable.destroy(err); |
| | } |
| | }); |
| | } |
| | function renderToWebStream(input, context = {}) { |
| | if (typeof ReadableStream !== "function") { |
| | throw new Error( |
| | `ReadableStream constructor is not available in the global scope. If the target environment does support web streams, consider using pipeToWebWritable() with an existing WritableStream instance instead.` |
| | ); |
| | } |
| | const encoder = new TextEncoder(); |
| | let cancelled = false; |
| | return new ReadableStream({ |
| | start(controller) { |
| | renderToSimpleStream(input, context, { |
| | push(content) { |
| | if (cancelled) |
| | return; |
| | if (content != null) { |
| | controller.enqueue(encoder.encode(content)); |
| | } else { |
| | controller.close(); |
| | } |
| | }, |
| | destroy(err) { |
| | controller.error(err); |
| | } |
| | }); |
| | }, |
| | cancel() { |
| | cancelled = true; |
| | } |
| | }); |
| | } |
| | function pipeToWebWritable(input, context = {}, writable) { |
| | const writer = writable.getWriter(); |
| | const encoder = new TextEncoder(); |
| | let hasReady = false; |
| | try { |
| | hasReady = shared.isPromise(writer.ready); |
| | } catch (e) { |
| | } |
| | renderToSimpleStream(input, context, { |
| | async push(content) { |
| | if (hasReady) { |
| | await writer.ready; |
| | } |
| | if (content != null) { |
| | return writer.write(encoder.encode(content)); |
| | } else { |
| | return writer.close(); |
| | } |
| | }, |
| | destroy(err) { |
| | console.log(err); |
| | writer.close(); |
| | } |
| | }); |
| | } |
| |
|
| | Vue.initDirectivesForSSR(); |
| |
|
| | exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr; |
| | exports.pipeToNodeWritable = pipeToNodeWritable; |
| | exports.pipeToWebWritable = pipeToWebWritable; |
| | exports.renderToNodeStream = renderToNodeStream; |
| | exports.renderToSimpleStream = renderToSimpleStream; |
| | exports.renderToStream = renderToStream; |
| | exports.renderToString = renderToString; |
| | exports.renderToWebStream = renderToWebStream; |
| | exports.ssrGetDirectiveProps = ssrGetDirectiveProps; |
| | exports.ssrGetDynamicModelProps = ssrGetDynamicModelProps; |
| | exports.ssrInterpolate = ssrInterpolate; |
| | exports.ssrLooseContain = ssrLooseContain; |
| | exports.ssrLooseEqual = ssrLooseEqual; |
| | exports.ssrRenderAttr = ssrRenderAttr; |
| | exports.ssrRenderAttrs = ssrRenderAttrs; |
| | exports.ssrRenderClass = ssrRenderClass; |
| | exports.ssrRenderComponent = ssrRenderComponent; |
| | exports.ssrRenderDynamicAttr = ssrRenderDynamicAttr; |
| | exports.ssrRenderDynamicModel = ssrRenderDynamicModel; |
| | exports.ssrRenderList = ssrRenderList; |
| | exports.ssrRenderSlot = ssrRenderSlot; |
| | exports.ssrRenderSlotInner = ssrRenderSlotInner; |
| | exports.ssrRenderStyle = ssrRenderStyle; |
| | exports.ssrRenderSuspense = ssrRenderSuspense; |
| | exports.ssrRenderTeleport = ssrRenderTeleport; |
| | exports.ssrRenderVNode = renderVNode; |
| |
|
