You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1225 lines
34 KiB
1225 lines
34 KiB
/**
|
|
* @vue/server-renderer v3.5.12
|
|
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
|
* @license MIT
|
|
**/
|
|
import { createVNode, ssrUtils, ssrContextKey, warn as warn$2, Fragment, Static, Comment, Text, mergeProps, createApp, initDirectivesForSSR } from 'vue';
|
|
import { isOn, isRenderableAttrValue, isSVGTag, propsToAttrMap, isBooleanAttr, includeBooleanAttr, isSSRSafeAttrName, escapeHtml, normalizeClass, isString, normalizeStyle, stringifyStyle, makeMap, isArray, toDisplayString, extend, isFunction, EMPTY_OBJ, getGlobalThis, NOOP, isObject, looseEqual, looseIndexOf, isPromise, escapeHtmlComment, isVoidTag } from '@vue/shared';
|
|
export { includeBooleanAttr as ssrIncludeBooleanAttr } from '@vue/shared';
|
|
|
|
const shouldIgnoreProp = /* @__PURE__ */ makeMap(
|
|
`,key,ref,innerHTML,textContent,ref_key,ref_for`
|
|
);
|
|
function ssrRenderAttrs(props, tag) {
|
|
let ret = "";
|
|
for (const key in props) {
|
|
if (shouldIgnoreProp(key) || 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 if (key === "className") {
|
|
ret += ` class="${String(value)}"`;
|
|
} else {
|
|
ret += ssrRenderDynamicAttr(key, value, tag);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
function ssrRenderDynamicAttr(key, value, tag) {
|
|
if (!isRenderableAttrValue(value)) {
|
|
return ``;
|
|
}
|
|
const attrKey = tag && (tag.indexOf("-") > 0 || isSVGTag(tag)) ? key : propsToAttrMap[key] || key.toLowerCase();
|
|
if (isBooleanAttr(attrKey)) {
|
|
return includeBooleanAttr(value) ? ` ${attrKey}` : ``;
|
|
} else if (isSSRSafeAttrName(attrKey)) {
|
|
return value === "" ? ` ${attrKey}` : ` ${attrKey}="${escapeHtml(value)}"`;
|
|
} else {
|
|
console.warn(
|
|
`[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`
|
|
);
|
|
return ``;
|
|
}
|
|
}
|
|
function ssrRenderAttr(key, value) {
|
|
if (!isRenderableAttrValue(value)) {
|
|
return ``;
|
|
}
|
|
return ` ${key}="${escapeHtml(value)}"`;
|
|
}
|
|
function ssrRenderClass(raw) {
|
|
return escapeHtml(normalizeClass(raw));
|
|
}
|
|
function ssrRenderStyle(raw) {
|
|
if (!raw) {
|
|
return "";
|
|
}
|
|
if (isString(raw)) {
|
|
return escapeHtml(raw);
|
|
}
|
|
const styles = normalizeStyle(raw);
|
|
return escapeHtml(stringifyStyle(styles));
|
|
}
|
|
|
|
function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
|
|
return renderComponentVNode(
|
|
createVNode(comp, props, children),
|
|
parentComponent,
|
|
slotScopeId
|
|
);
|
|
}
|
|
|
|
const { ensureValidVNode } = ssrUtils;
|
|
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 (isArray(ret)) {
|
|
const validSlotContent = ensureValidVNode(ret);
|
|
if (validSlotContent) {
|
|
renderVNodeChildren(
|
|
push,
|
|
validSlotContent,
|
|
parentComponent,
|
|
slotScopeId
|
|
);
|
|
} else if (fallbackRenderFn) {
|
|
fallbackRenderFn();
|
|
}
|
|
} 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\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[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 start anchor--><!--teleport anchor-->`;
|
|
} else {
|
|
const { getBuffer, push } = createBuffer();
|
|
push(`<!--teleport start anchor-->`);
|
|
contentRenderFn(push);
|
|
push(`<!--teleport anchor-->`);
|
|
teleportContent = getBuffer();
|
|
}
|
|
targetBuffer.splice(bufferIndex, 0, teleportContent);
|
|
parentPush("<!--teleport end-->");
|
|
}
|
|
|
|
function ssrInterpolate(value) {
|
|
return escapeHtml(toDisplayString(value));
|
|
}
|
|
|
|
let activeSub;
|
|
let batchDepth = 0;
|
|
let batchedSub;
|
|
function startBatch() {
|
|
batchDepth++;
|
|
}
|
|
function endBatch() {
|
|
if (--batchDepth > 0) {
|
|
return;
|
|
}
|
|
let error;
|
|
while (batchedSub) {
|
|
let e = batchedSub;
|
|
batchedSub = void 0;
|
|
while (e) {
|
|
const next = e.next;
|
|
e.next = void 0;
|
|
e.flags &= ~8;
|
|
if (e.flags & 1) {
|
|
try {
|
|
;
|
|
e.trigger();
|
|
} catch (err) {
|
|
if (!error) error = err;
|
|
}
|
|
}
|
|
e = next;
|
|
}
|
|
}
|
|
if (error) throw error;
|
|
}
|
|
let shouldTrack = true;
|
|
const trackStack = [];
|
|
function pauseTracking() {
|
|
trackStack.push(shouldTrack);
|
|
shouldTrack = false;
|
|
}
|
|
function resetTracking() {
|
|
const last = trackStack.pop();
|
|
shouldTrack = last === void 0 ? true : last;
|
|
}
|
|
|
|
class Dep {
|
|
constructor(computed) {
|
|
this.computed = computed;
|
|
this.version = 0;
|
|
/**
|
|
* Link between this dep and the current active effect
|
|
*/
|
|
this.activeLink = void 0;
|
|
/**
|
|
* Doubly linked list representing the subscribing effects (tail)
|
|
*/
|
|
this.subs = void 0;
|
|
/**
|
|
* For object property deps cleanup
|
|
*/
|
|
this.map = void 0;
|
|
this.key = void 0;
|
|
/**
|
|
* Subscriber counter
|
|
*/
|
|
this.sc = 0;
|
|
if (!!(process.env.NODE_ENV !== "production")) {
|
|
this.subsHead = void 0;
|
|
}
|
|
}
|
|
track(debugInfo) {
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
trigger(debugInfo) {
|
|
this.version++;
|
|
this.notify(debugInfo);
|
|
}
|
|
notify(debugInfo) {
|
|
startBatch();
|
|
try {
|
|
if (!!(process.env.NODE_ENV !== "production")) {
|
|
for (let head = this.subsHead; head; head = head.nextSub) {
|
|
if (head.sub.onTrigger && !(head.sub.flags & 8)) {
|
|
head.sub.onTrigger(
|
|
extend(
|
|
{
|
|
effect: head.sub
|
|
},
|
|
debugInfo
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
for (let link = this.subs; link; link = link.prevSub) {
|
|
if (link.sub.notify()) {
|
|
;
|
|
link.sub.dep.notify();
|
|
}
|
|
}
|
|
} finally {
|
|
endBatch();
|
|
}
|
|
}
|
|
}
|
|
const targetMap = /* @__PURE__ */ new WeakMap();
|
|
Symbol(
|
|
!!(process.env.NODE_ENV !== "production") ? "Object iterate" : ""
|
|
);
|
|
Symbol(
|
|
!!(process.env.NODE_ENV !== "production") ? "Map keys iterate" : ""
|
|
);
|
|
Symbol(
|
|
!!(process.env.NODE_ENV !== "production") ? "Array iterate" : ""
|
|
);
|
|
function track(target, type, key) {
|
|
if (shouldTrack && activeSub) {
|
|
let depsMap = targetMap.get(target);
|
|
if (!depsMap) {
|
|
targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
|
|
}
|
|
let dep = depsMap.get(key);
|
|
if (!dep) {
|
|
depsMap.set(key, dep = new Dep());
|
|
dep.map = depsMap;
|
|
dep.key = key;
|
|
}
|
|
if (!!(process.env.NODE_ENV !== "production")) {
|
|
dep.track({
|
|
target,
|
|
type,
|
|
key
|
|
});
|
|
} else {
|
|
dep.track();
|
|
}
|
|
}
|
|
}
|
|
|
|
function isProxy(value) {
|
|
return value ? !!value["__v_raw"] : false;
|
|
}
|
|
function toRaw(observed) {
|
|
const raw = observed && observed["__v_raw"];
|
|
return raw ? toRaw(raw) : observed;
|
|
}
|
|
|
|
function isRef(r) {
|
|
return r ? r["__v_isRef"] === true : false;
|
|
}
|
|
|
|
const stack = [];
|
|
function pushWarningContext$1(vnode) {
|
|
stack.push(vnode);
|
|
}
|
|
function popWarningContext$1() {
|
|
stack.pop();
|
|
}
|
|
let isWarning = false;
|
|
function warn$1(msg, ...args) {
|
|
if (isWarning) return;
|
|
isWarning = true;
|
|
pauseTracking();
|
|
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,
|
|
[
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
msg + args.map((a) => {
|
|
var _a, _b;
|
|
return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
|
|
}).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 && // avoid spamming console during tests
|
|
true) {
|
|
warnArgs.push(`
|
|
`, ...formatTrace(trace));
|
|
}
|
|
console.warn(...warnArgs);
|
|
}
|
|
resetTracking();
|
|
isWarning = false;
|
|
}
|
|
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 (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 (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",
|
|
[15]: "component update",
|
|
[16]: "app unmount cleanup function"
|
|
};
|
|
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;
|
|
const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
|
|
if (instance) {
|
|
let cur = instance.parent;
|
|
const exposedInstance = instance.proxy;
|
|
const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings[type] : `https://vuejs.org/error-reference/#runtime-${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;
|
|
}
|
|
if (errorHandler) {
|
|
pauseTracking();
|
|
callWithErrorHandling(errorHandler, null, 10, [
|
|
err,
|
|
exposedInstance,
|
|
errorInfo
|
|
]);
|
|
resetTracking();
|
|
return;
|
|
}
|
|
}
|
|
logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
|
|
}
|
|
function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
|
|
if (!!(process.env.NODE_ENV !== "production")) {
|
|
const info = ErrorTypeStrings[type];
|
|
if (contextVNode) {
|
|
pushWarningContext$1(contextVNode);
|
|
}
|
|
warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
|
|
if (contextVNode) {
|
|
popWarningContext$1();
|
|
}
|
|
if (throwInDev) {
|
|
throw err;
|
|
} else {
|
|
console.error(err);
|
|
}
|
|
} else if (throwInProd) {
|
|
throw err;
|
|
} else {
|
|
console.error(err);
|
|
}
|
|
}
|
|
|
|
let devtools;
|
|
let buffer = [];
|
|
function setDevtoolsHook(hook, target) {
|
|
var _a, _b;
|
|
devtools = hook;
|
|
if (devtools) {
|
|
devtools.enabled = true;
|
|
buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
|
|
buffer = [];
|
|
} else if (
|
|
// handle late devtools injection - only do this if we are in an actual
|
|
// browser environment to avoid the timer handle stalling test runner exit
|
|
// (#4815)
|
|
typeof window !== "undefined" && // some envs mock window but not fully
|
|
window.HTMLElement && // also exclude jsdom
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
!((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
|
|
) {
|
|
const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
|
|
replay.push((newHook) => {
|
|
setDevtoolsHook(newHook, target);
|
|
});
|
|
setTimeout(() => {
|
|
if (!devtools) {
|
|
target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
|
|
buffer = [];
|
|
}
|
|
}, 3e3);
|
|
} else {
|
|
buffer = [];
|
|
}
|
|
}
|
|
|
|
{
|
|
const g = 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
|
|
);
|
|
}
|
|
!!(process.env.NODE_ENV !== "production") ? {
|
|
get(target, key) {
|
|
track(target, "get", "");
|
|
return target[key];
|
|
},
|
|
set() {
|
|
warn$1(`setupContext.attrs is readonly.`);
|
|
return false;
|
|
},
|
|
deleteProperty() {
|
|
warn$1(`setupContext.attrs is readonly.`);
|
|
return false;
|
|
}
|
|
} : {
|
|
get(target, key) {
|
|
track(target, "get", "");
|
|
return target[key];
|
|
}
|
|
};
|
|
const classifyRE = /(?:^|[-_])(\w)/g;
|
|
const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
|
|
function getComponentName(Component, includeInferred = true) {
|
|
return 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`;
|
|
}
|
|
function isClassComponent(value) {
|
|
return isFunction(value) && "__vccOpts" in value;
|
|
}
|
|
|
|
const warn = !!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
|
|
!!(process.env.NODE_ENV !== "production") || true ? devtools : void 0;
|
|
!!(process.env.NODE_ENV !== "production") || true ? setDevtoolsHook : NOOP;
|
|
|
|
function ssrRenderList(source, renderItem) {
|
|
if (isArray(source) || isString(source)) {
|
|
for (let i = 0, l = source.length; i < l; i++) {
|
|
renderItem(source[i], i);
|
|
}
|
|
} else if (typeof source === "number") {
|
|
if (!!(process.env.NODE_ENV !== "production") && !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 (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: ssrUtils.getComponentPublicInstance(instance.$),
|
|
value,
|
|
oldValue: void 0,
|
|
arg,
|
|
modifiers
|
|
},
|
|
null
|
|
) || {};
|
|
}
|
|
return {};
|
|
}
|
|
|
|
const ssrLooseEqual = looseEqual;
|
|
function ssrLooseContain(arr, value) {
|
|
return looseIndexOf(arr, value) > -1;
|
|
}
|
|
function ssrRenderDynamicModel(type, model, value) {
|
|
switch (type) {
|
|
case "radio":
|
|
return looseEqual(model, value) ? " checked" : "";
|
|
case "checkbox":
|
|
return (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 looseEqual(model, value) ? { checked: true } : null;
|
|
case "checkbox":
|
|
return (isArray(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
|
|
default:
|
|
return { value: model };
|
|
}
|
|
}
|
|
|
|
function ssrCompile(template, instance) {
|
|
{
|
|
throw new Error(
|
|
`On-the-fly template compilation is not supported in the ESM build of @vue/server-renderer. All templates must be pre-compiled into render functions.`
|
|
);
|
|
}
|
|
}
|
|
|
|
const {
|
|
createComponentInstance,
|
|
setCurrentRenderingInstance,
|
|
setupComponent,
|
|
renderComponentRoot,
|
|
normalizeVNode,
|
|
pushWarningContext,
|
|
popWarningContext
|
|
} = ssrUtils;
|
|
function createBuffer() {
|
|
let appendable = false;
|
|
const buffer = [];
|
|
return {
|
|
getBuffer() {
|
|
return buffer;
|
|
},
|
|
push(item) {
|
|
const isStringItem = isString(item);
|
|
if (appendable && isStringItem) {
|
|
buffer[buffer.length - 1] += item;
|
|
return;
|
|
}
|
|
buffer.push(item);
|
|
appendable = isStringItem;
|
|
if (isPromise(item) || isArray(item) && item.hasAsync) {
|
|
buffer.hasAsync = true;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
|
|
const instance = vnode.component = createComponentInstance(
|
|
vnode,
|
|
parentComponent,
|
|
null
|
|
);
|
|
if (!!(process.env.NODE_ENV !== "production")) pushWarningContext(vnode);
|
|
const res = setupComponent(
|
|
instance,
|
|
true
|
|
/* isSSR */
|
|
);
|
|
if (!!(process.env.NODE_ENV !== "production")) popWarningContext();
|
|
const hasAsyncSetup = isPromise(res);
|
|
let prefetches = instance.sp;
|
|
if (hasAsyncSetup || prefetches) {
|
|
const p = Promise.resolve(res).then(() => {
|
|
if (hasAsyncSetup) prefetches = instance.sp;
|
|
if (prefetches) {
|
|
return Promise.all(
|
|
prefetches.map((prefetch) => prefetch.call(instance.proxy))
|
|
);
|
|
}
|
|
}).catch(NOOP);
|
|
return p.then(() => renderComponentSubTree(instance, slotScopeId));
|
|
} else {
|
|
return renderComponentSubTree(instance, slotScopeId);
|
|
}
|
|
}
|
|
function renderComponentSubTree(instance, slotScopeId) {
|
|
if (!!(process.env.NODE_ENV !== "production")) pushWarningContext(instance.vnode);
|
|
const comp = instance.type;
|
|
const { getBuffer, push } = createBuffer();
|
|
if (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 === NOOP) && !instance.ssrRender && !comp.ssrRender && isString(comp.template)) {
|
|
comp.ssrRender = ssrCompile(comp.template);
|
|
}
|
|
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 };
|
|
const slotScopeIdList = slotScopeId.trim().split(" ");
|
|
for (let i = 0; i < slotScopeIdList.length; i++) {
|
|
attrs[slotScopeIdList[i]] = "";
|
|
}
|
|
}
|
|
const prev = setCurrentRenderingInstance(instance);
|
|
try {
|
|
ssrRender(
|
|
instance.proxy,
|
|
push,
|
|
instance,
|
|
attrs,
|
|
// compiler-optimized bindings
|
|
instance.props,
|
|
instance.setupState,
|
|
instance.data,
|
|
instance.ctx
|
|
);
|
|
} finally {
|
|
setCurrentRenderingInstance(prev);
|
|
}
|
|
} else if (instance.render && instance.render !== NOOP) {
|
|
renderVNode(
|
|
push,
|
|
instance.subTree = renderComponentRoot(instance),
|
|
instance,
|
|
slotScopeId
|
|
);
|
|
} else {
|
|
const componentName = comp.name || comp.__file || `<Anonymous>`;
|
|
warn$2(`Component ${componentName} is missing template or render function.`);
|
|
push(`<!---->`);
|
|
}
|
|
}
|
|
if (!!(process.env.NODE_ENV !== "production")) popWarningContext();
|
|
return getBuffer();
|
|
}
|
|
function renderVNode(push, vnode, parentComponent, slotScopeId) {
|
|
const { type, shapeFlag, children, dirs, props } = vnode;
|
|
if (dirs) {
|
|
vnode.props = applySSRDirectives(vnode, props, dirs);
|
|
}
|
|
switch (type) {
|
|
case Text:
|
|
push(escapeHtml(children));
|
|
break;
|
|
case Comment:
|
|
push(
|
|
children ? `<!--${escapeHtmlComment(children)}-->` : `<!---->`
|
|
);
|
|
break;
|
|
case Static:
|
|
push(children);
|
|
break;
|
|
case 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 {
|
|
warn$2(
|
|
"[@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 } = vnode;
|
|
let openTag = `<${tag}`;
|
|
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 (!isVoidTag(tag)) {
|
|
let hasChildrenOverride = false;
|
|
if (props) {
|
|
if (props.innerHTML) {
|
|
hasChildrenOverride = true;
|
|
push(props.innerHTML);
|
|
} else if (props.textContent) {
|
|
hasChildrenOverride = true;
|
|
push(escapeHtml(props.textContent));
|
|
} else if (tag === "textarea" && props.value) {
|
|
hasChildrenOverride = true;
|
|
push(escapeHtml(props.value));
|
|
}
|
|
}
|
|
if (!hasChildrenOverride) {
|
|
if (shapeFlag & 8) {
|
|
push(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 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) {
|
|
warn$2(`[@vue/server-renderer] Teleport is missing target prop.`);
|
|
}
|
|
return [];
|
|
}
|
|
if (!isString(target)) {
|
|
warn$2(
|
|
`[@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 } = ssrUtils;
|
|
function nestedUnrollBuffer(buffer, parentRet, startIndex) {
|
|
if (!buffer.hasAsync) {
|
|
return parentRet + unrollBufferSync$1(buffer);
|
|
}
|
|
let ret = parentRet;
|
|
for (let i = startIndex; i < buffer.length; i += 1) {
|
|
const item = buffer[i];
|
|
if (isString(item)) {
|
|
ret += item;
|
|
continue;
|
|
}
|
|
if (isPromise(item)) {
|
|
return item.then((nestedItem) => {
|
|
buffer[i] = nestedItem;
|
|
return nestedUnrollBuffer(buffer, ret, i);
|
|
});
|
|
}
|
|
const result = nestedUnrollBuffer(item, ret, 0);
|
|
if (isPromise(result)) {
|
|
return result.then((nestedItem) => {
|
|
buffer[i] = nestedItem;
|
|
return nestedUnrollBuffer(buffer, "", i);
|
|
});
|
|
}
|
|
ret = result;
|
|
}
|
|
return ret;
|
|
}
|
|
function unrollBuffer$1(buffer) {
|
|
return nestedUnrollBuffer(buffer, "", 0);
|
|
}
|
|
function unrollBufferSync$1(buffer) {
|
|
let ret = "";
|
|
for (let i = 0; i < buffer.length; i++) {
|
|
let item = buffer[i];
|
|
if (isString(item)) {
|
|
ret += item;
|
|
} else {
|
|
ret += unrollBufferSync$1(item);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
async function renderToString(input, context = {}) {
|
|
if (isVNode$1(input)) {
|
|
return renderToString(createApp({ render: () => input }), context);
|
|
}
|
|
const vnode = createVNode(input._component, input._props);
|
|
vnode.appContext = input._context;
|
|
input.provide(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 } = ssrUtils;
|
|
async function unrollBuffer(buffer, stream) {
|
|
if (buffer.hasAsync) {
|
|
for (let i = 0; i < buffer.length; i++) {
|
|
let item = buffer[i];
|
|
if (isPromise(item)) {
|
|
item = await item;
|
|
}
|
|
if (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 (isString(item)) {
|
|
stream.push(item);
|
|
} else {
|
|
unrollBufferSync(item, stream);
|
|
}
|
|
}
|
|
}
|
|
function renderToSimpleStream(input, context, stream) {
|
|
if (isVNode(input)) {
|
|
return renderToSimpleStream(
|
|
createApp({ render: () => input }),
|
|
context,
|
|
stream
|
|
);
|
|
}
|
|
const vnode = createVNode(input._component, input._props);
|
|
vnode.appContext = input._context;
|
|
input.provide(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 = {}) {
|
|
{
|
|
throw new Error(
|
|
`ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.`
|
|
);
|
|
}
|
|
}
|
|
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 = 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();
|
|
}
|
|
});
|
|
}
|
|
|
|
initDirectivesForSSR();
|
|
|
|
export { pipeToNodeWritable, pipeToWebWritable, renderToNodeStream, renderToSimpleStream, renderToStream, renderToString, renderToWebStream, ssrGetDirectiveProps, ssrGetDynamicModelProps, ssrInterpolate, ssrLooseContain, ssrLooseEqual, ssrRenderAttr, ssrRenderAttrs, ssrRenderClass, ssrRenderComponent, ssrRenderDynamicAttr, ssrRenderDynamicModel, ssrRenderList, ssrRenderSlot, ssrRenderSlotInner, ssrRenderStyle, ssrRenderSuspense, ssrRenderTeleport, renderVNode as ssrRenderVNode };
|