[57e58a3] | 1 | /**
|
---|
| 2 | * @vue/server-renderer v3.5.13
|
---|
| 3 | * (c) 2018-present Yuxi (Evan) You and Vue contributors
|
---|
| 4 | * @license MIT
|
---|
| 5 | **/
|
---|
| 6 | 'use strict';
|
---|
| 7 |
|
---|
| 8 | Object.defineProperty(exports, '__esModule', { value: true });
|
---|
| 9 |
|
---|
| 10 | var Vue = require('vue');
|
---|
| 11 | var shared = require('@vue/shared');
|
---|
| 12 | var compilerSsr = require('@vue/compiler-ssr');
|
---|
| 13 |
|
---|
| 14 | function _interopNamespaceDefault(e) {
|
---|
| 15 | var n = Object.create(null);
|
---|
| 16 | if (e) {
|
---|
| 17 | for (var k in e) {
|
---|
| 18 | n[k] = e[k];
|
---|
| 19 | }
|
---|
| 20 | }
|
---|
| 21 | n.default = e;
|
---|
| 22 | return Object.freeze(n);
|
---|
| 23 | }
|
---|
| 24 |
|
---|
| 25 | var Vue__namespace = /*#__PURE__*/_interopNamespaceDefault(Vue);
|
---|
| 26 |
|
---|
| 27 | const shouldIgnoreProp = /* @__PURE__ */ shared.makeMap(
|
---|
| 28 | `,key,ref,innerHTML,textContent,ref_key,ref_for`
|
---|
| 29 | );
|
---|
| 30 | function ssrRenderAttrs(props, tag) {
|
---|
| 31 | let ret = "";
|
---|
| 32 | for (const key in props) {
|
---|
| 33 | if (shouldIgnoreProp(key) || shared.isOn(key) || tag === "textarea" && key === "value") {
|
---|
| 34 | continue;
|
---|
| 35 | }
|
---|
| 36 | const value = props[key];
|
---|
| 37 | if (key === "class") {
|
---|
| 38 | ret += ` class="${ssrRenderClass(value)}"`;
|
---|
| 39 | } else if (key === "style") {
|
---|
| 40 | ret += ` style="${ssrRenderStyle(value)}"`;
|
---|
| 41 | } else if (key === "className") {
|
---|
| 42 | ret += ` class="${String(value)}"`;
|
---|
| 43 | } else {
|
---|
| 44 | ret += ssrRenderDynamicAttr(key, value, tag);
|
---|
| 45 | }
|
---|
| 46 | }
|
---|
| 47 | return ret;
|
---|
| 48 | }
|
---|
| 49 | function ssrRenderDynamicAttr(key, value, tag) {
|
---|
| 50 | if (!shared.isRenderableAttrValue(value)) {
|
---|
| 51 | return ``;
|
---|
| 52 | }
|
---|
| 53 | const attrKey = tag && (tag.indexOf("-") > 0 || shared.isSVGTag(tag)) ? key : shared.propsToAttrMap[key] || key.toLowerCase();
|
---|
| 54 | if (shared.isBooleanAttr(attrKey)) {
|
---|
| 55 | return shared.includeBooleanAttr(value) ? ` ${attrKey}` : ``;
|
---|
| 56 | } else if (shared.isSSRSafeAttrName(attrKey)) {
|
---|
| 57 | return value === "" ? ` ${attrKey}` : ` ${attrKey}="${shared.escapeHtml(value)}"`;
|
---|
| 58 | } else {
|
---|
| 59 | console.warn(
|
---|
| 60 | `[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`
|
---|
| 61 | );
|
---|
| 62 | return ``;
|
---|
| 63 | }
|
---|
| 64 | }
|
---|
| 65 | function ssrRenderAttr(key, value) {
|
---|
| 66 | if (!shared.isRenderableAttrValue(value)) {
|
---|
| 67 | return ``;
|
---|
| 68 | }
|
---|
| 69 | return ` ${key}="${shared.escapeHtml(value)}"`;
|
---|
| 70 | }
|
---|
| 71 | function ssrRenderClass(raw) {
|
---|
| 72 | return shared.escapeHtml(shared.normalizeClass(raw));
|
---|
| 73 | }
|
---|
| 74 | function ssrRenderStyle(raw) {
|
---|
| 75 | if (!raw) {
|
---|
| 76 | return "";
|
---|
| 77 | }
|
---|
| 78 | if (shared.isString(raw)) {
|
---|
| 79 | return shared.escapeHtml(raw);
|
---|
| 80 | }
|
---|
| 81 | const styles = shared.normalizeStyle(raw);
|
---|
| 82 | return shared.escapeHtml(shared.stringifyStyle(styles));
|
---|
| 83 | }
|
---|
| 84 |
|
---|
| 85 | function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
|
---|
| 86 | return renderComponentVNode(
|
---|
| 87 | Vue.createVNode(comp, props, children),
|
---|
| 88 | parentComponent,
|
---|
| 89 | slotScopeId
|
---|
| 90 | );
|
---|
| 91 | }
|
---|
| 92 |
|
---|
| 93 | const { ensureValidVNode } = Vue.ssrUtils;
|
---|
| 94 | function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
|
---|
| 95 | push(`<!--[-->`);
|
---|
| 96 | ssrRenderSlotInner(
|
---|
| 97 | slots,
|
---|
| 98 | slotName,
|
---|
| 99 | slotProps,
|
---|
| 100 | fallbackRenderFn,
|
---|
| 101 | push,
|
---|
| 102 | parentComponent,
|
---|
| 103 | slotScopeId
|
---|
| 104 | );
|
---|
| 105 | push(`<!--]-->`);
|
---|
| 106 | }
|
---|
| 107 | function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
|
---|
| 108 | const slotFn = slots[slotName];
|
---|
| 109 | if (slotFn) {
|
---|
| 110 | const slotBuffer = [];
|
---|
| 111 | const bufferedPush = (item) => {
|
---|
| 112 | slotBuffer.push(item);
|
---|
| 113 | };
|
---|
| 114 | const ret = slotFn(
|
---|
| 115 | slotProps,
|
---|
| 116 | bufferedPush,
|
---|
| 117 | parentComponent,
|
---|
| 118 | slotScopeId ? " " + slotScopeId : ""
|
---|
| 119 | );
|
---|
| 120 | if (shared.isArray(ret)) {
|
---|
| 121 | const validSlotContent = ensureValidVNode(ret);
|
---|
| 122 | if (validSlotContent) {
|
---|
| 123 | renderVNodeChildren(
|
---|
| 124 | push,
|
---|
| 125 | validSlotContent,
|
---|
| 126 | parentComponent,
|
---|
| 127 | slotScopeId
|
---|
| 128 | );
|
---|
| 129 | } else if (fallbackRenderFn) {
|
---|
| 130 | fallbackRenderFn();
|
---|
| 131 | }
|
---|
| 132 | } else {
|
---|
| 133 | let isEmptySlot = true;
|
---|
| 134 | if (transition) {
|
---|
| 135 | isEmptySlot = false;
|
---|
| 136 | } else {
|
---|
| 137 | for (let i = 0; i < slotBuffer.length; i++) {
|
---|
| 138 | if (!isComment(slotBuffer[i])) {
|
---|
| 139 | isEmptySlot = false;
|
---|
| 140 | break;
|
---|
| 141 | }
|
---|
| 142 | }
|
---|
| 143 | }
|
---|
| 144 | if (isEmptySlot) {
|
---|
| 145 | if (fallbackRenderFn) {
|
---|
| 146 | fallbackRenderFn();
|
---|
| 147 | }
|
---|
| 148 | } else {
|
---|
| 149 | let start = 0;
|
---|
| 150 | let end = slotBuffer.length;
|
---|
| 151 | if (transition && slotBuffer[0] === "<!--[-->" && slotBuffer[end - 1] === "<!--]-->") {
|
---|
| 152 | start++;
|
---|
| 153 | end--;
|
---|
| 154 | }
|
---|
| 155 | for (let i = start; i < end; i++) {
|
---|
| 156 | push(slotBuffer[i]);
|
---|
| 157 | }
|
---|
| 158 | }
|
---|
| 159 | }
|
---|
| 160 | } else if (fallbackRenderFn) {
|
---|
| 161 | fallbackRenderFn();
|
---|
| 162 | }
|
---|
| 163 | }
|
---|
| 164 | const commentTestRE = /^<!--[\s\S]*-->$/;
|
---|
| 165 | const commentRE = /<!--[^]*?-->/gm;
|
---|
| 166 | function isComment(item) {
|
---|
| 167 | if (typeof item !== "string" || !commentTestRE.test(item)) return false;
|
---|
| 168 | if (item.length <= 8) return true;
|
---|
| 169 | return !item.replace(commentRE, "").trim();
|
---|
| 170 | }
|
---|
| 171 |
|
---|
| 172 | function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
|
---|
| 173 | parentPush("<!--teleport start-->");
|
---|
| 174 | const context = parentComponent.appContext.provides[Vue.ssrContextKey];
|
---|
| 175 | const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
|
---|
| 176 | const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
|
---|
| 177 | const bufferIndex = targetBuffer.length;
|
---|
| 178 | let teleportContent;
|
---|
| 179 | if (disabled) {
|
---|
| 180 | contentRenderFn(parentPush);
|
---|
| 181 | teleportContent = `<!--teleport start anchor--><!--teleport anchor-->`;
|
---|
| 182 | } else {
|
---|
| 183 | const { getBuffer, push } = createBuffer();
|
---|
| 184 | push(`<!--teleport start anchor-->`);
|
---|
| 185 | contentRenderFn(push);
|
---|
| 186 | push(`<!--teleport anchor-->`);
|
---|
| 187 | teleportContent = getBuffer();
|
---|
| 188 | }
|
---|
| 189 | targetBuffer.splice(bufferIndex, 0, teleportContent);
|
---|
| 190 | parentPush("<!--teleport end-->");
|
---|
| 191 | }
|
---|
| 192 |
|
---|
| 193 | function ssrInterpolate(value) {
|
---|
| 194 | return shared.escapeHtml(shared.toDisplayString(value));
|
---|
| 195 | }
|
---|
| 196 |
|
---|
| 197 | function toRaw(observed) {
|
---|
| 198 | const raw = observed && observed["__v_raw"];
|
---|
| 199 | return raw ? toRaw(raw) : observed;
|
---|
| 200 | }
|
---|
| 201 |
|
---|
| 202 | function isRef(r) {
|
---|
| 203 | return r ? r["__v_isRef"] === true : false;
|
---|
| 204 | }
|
---|
| 205 |
|
---|
| 206 | const stack = [];
|
---|
| 207 | function pushWarningContext$1(vnode) {
|
---|
| 208 | stack.push(vnode);
|
---|
| 209 | }
|
---|
| 210 | function popWarningContext$1() {
|
---|
| 211 | stack.pop();
|
---|
| 212 | }
|
---|
| 213 | let isWarning = false;
|
---|
| 214 | function warn$1(msg, ...args) {
|
---|
| 215 | if (isWarning) return;
|
---|
| 216 | isWarning = true;
|
---|
| 217 | const instance = stack.length ? stack[stack.length - 1].component : null;
|
---|
| 218 | const appWarnHandler = instance && instance.appContext.config.warnHandler;
|
---|
| 219 | const trace = getComponentTrace();
|
---|
| 220 | if (appWarnHandler) {
|
---|
| 221 | callWithErrorHandling(
|
---|
| 222 | appWarnHandler,
|
---|
| 223 | instance,
|
---|
| 224 | 11,
|
---|
| 225 | [
|
---|
| 226 | // eslint-disable-next-line no-restricted-syntax
|
---|
| 227 | msg + args.map((a) => {
|
---|
| 228 | var _a, _b;
|
---|
| 229 | return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
|
---|
| 230 | }).join(""),
|
---|
| 231 | instance && instance.proxy,
|
---|
| 232 | trace.map(
|
---|
| 233 | ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
|
---|
| 234 | ).join("\n"),
|
---|
| 235 | trace
|
---|
| 236 | ]
|
---|
| 237 | );
|
---|
| 238 | } else {
|
---|
| 239 | const warnArgs = [`[Vue warn]: ${msg}`, ...args];
|
---|
| 240 | if (trace.length && // avoid spamming console during tests
|
---|
| 241 | true) {
|
---|
| 242 | warnArgs.push(`
|
---|
| 243 | `, ...formatTrace(trace));
|
---|
| 244 | }
|
---|
| 245 | console.warn(...warnArgs);
|
---|
| 246 | }
|
---|
| 247 | isWarning = false;
|
---|
| 248 | }
|
---|
| 249 | function getComponentTrace() {
|
---|
| 250 | let currentVNode = stack[stack.length - 1];
|
---|
| 251 | if (!currentVNode) {
|
---|
| 252 | return [];
|
---|
| 253 | }
|
---|
| 254 | const normalizedStack = [];
|
---|
| 255 | while (currentVNode) {
|
---|
| 256 | const last = normalizedStack[0];
|
---|
| 257 | if (last && last.vnode === currentVNode) {
|
---|
| 258 | last.recurseCount++;
|
---|
| 259 | } else {
|
---|
| 260 | normalizedStack.push({
|
---|
| 261 | vnode: currentVNode,
|
---|
| 262 | recurseCount: 0
|
---|
| 263 | });
|
---|
| 264 | }
|
---|
| 265 | const parentInstance = currentVNode.component && currentVNode.component.parent;
|
---|
| 266 | currentVNode = parentInstance && parentInstance.vnode;
|
---|
| 267 | }
|
---|
| 268 | return normalizedStack;
|
---|
| 269 | }
|
---|
| 270 | function formatTrace(trace) {
|
---|
| 271 | const logs = [];
|
---|
| 272 | trace.forEach((entry, i) => {
|
---|
| 273 | logs.push(...i === 0 ? [] : [`
|
---|
| 274 | `], ...formatTraceEntry(entry));
|
---|
| 275 | });
|
---|
| 276 | return logs;
|
---|
| 277 | }
|
---|
| 278 | function formatTraceEntry({ vnode, recurseCount }) {
|
---|
| 279 | const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
|
---|
| 280 | const isRoot = vnode.component ? vnode.component.parent == null : false;
|
---|
| 281 | const open = ` at <${formatComponentName(
|
---|
| 282 | vnode.component,
|
---|
| 283 | vnode.type,
|
---|
| 284 | isRoot
|
---|
| 285 | )}`;
|
---|
| 286 | const close = `>` + postfix;
|
---|
| 287 | return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
|
---|
| 288 | }
|
---|
| 289 | function formatProps(props) {
|
---|
| 290 | const res = [];
|
---|
| 291 | const keys = Object.keys(props);
|
---|
| 292 | keys.slice(0, 3).forEach((key) => {
|
---|
| 293 | res.push(...formatProp(key, props[key]));
|
---|
| 294 | });
|
---|
| 295 | if (keys.length > 3) {
|
---|
| 296 | res.push(` ...`);
|
---|
| 297 | }
|
---|
| 298 | return res;
|
---|
| 299 | }
|
---|
| 300 | function formatProp(key, value, raw) {
|
---|
| 301 | if (shared.isString(value)) {
|
---|
| 302 | value = JSON.stringify(value);
|
---|
| 303 | return raw ? value : [`${key}=${value}`];
|
---|
| 304 | } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
|
---|
| 305 | return raw ? value : [`${key}=${value}`];
|
---|
| 306 | } else if (isRef(value)) {
|
---|
| 307 | value = formatProp(key, toRaw(value.value), true);
|
---|
| 308 | return raw ? value : [`${key}=Ref<`, value, `>`];
|
---|
| 309 | } else if (shared.isFunction(value)) {
|
---|
| 310 | return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
|
---|
| 311 | } else {
|
---|
| 312 | value = toRaw(value);
|
---|
| 313 | return raw ? value : [`${key}=`, value];
|
---|
| 314 | }
|
---|
| 315 | }
|
---|
| 316 |
|
---|
| 317 | const ErrorTypeStrings = {
|
---|
| 318 | ["sp"]: "serverPrefetch hook",
|
---|
| 319 | ["bc"]: "beforeCreate hook",
|
---|
| 320 | ["c"]: "created hook",
|
---|
| 321 | ["bm"]: "beforeMount hook",
|
---|
| 322 | ["m"]: "mounted hook",
|
---|
| 323 | ["bu"]: "beforeUpdate hook",
|
---|
| 324 | ["u"]: "updated",
|
---|
| 325 | ["bum"]: "beforeUnmount hook",
|
---|
| 326 | ["um"]: "unmounted hook",
|
---|
| 327 | ["a"]: "activated hook",
|
---|
| 328 | ["da"]: "deactivated hook",
|
---|
| 329 | ["ec"]: "errorCaptured hook",
|
---|
| 330 | ["rtc"]: "renderTracked hook",
|
---|
| 331 | ["rtg"]: "renderTriggered hook",
|
---|
| 332 | [0]: "setup function",
|
---|
| 333 | [1]: "render function",
|
---|
| 334 | [2]: "watcher getter",
|
---|
| 335 | [3]: "watcher callback",
|
---|
| 336 | [4]: "watcher cleanup function",
|
---|
| 337 | [5]: "native event handler",
|
---|
| 338 | [6]: "component event handler",
|
---|
| 339 | [7]: "vnode hook",
|
---|
| 340 | [8]: "directive hook",
|
---|
| 341 | [9]: "transition hook",
|
---|
| 342 | [10]: "app errorHandler",
|
---|
| 343 | [11]: "app warnHandler",
|
---|
| 344 | [12]: "ref function",
|
---|
| 345 | [13]: "async component loader",
|
---|
| 346 | [14]: "scheduler flush",
|
---|
| 347 | [15]: "component update",
|
---|
| 348 | [16]: "app unmount cleanup function"
|
---|
| 349 | };
|
---|
| 350 | function callWithErrorHandling(fn, instance, type, args) {
|
---|
| 351 | try {
|
---|
| 352 | return args ? fn(...args) : fn();
|
---|
| 353 | } catch (err) {
|
---|
| 354 | handleError(err, instance, type);
|
---|
| 355 | }
|
---|
| 356 | }
|
---|
| 357 | function handleError(err, instance, type, throwInDev = true) {
|
---|
| 358 | const contextVNode = instance ? instance.vnode : null;
|
---|
| 359 | const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || shared.EMPTY_OBJ;
|
---|
| 360 | if (instance) {
|
---|
| 361 | let cur = instance.parent;
|
---|
| 362 | const exposedInstance = instance.proxy;
|
---|
| 363 | const errorInfo = ErrorTypeStrings[type] ;
|
---|
| 364 | while (cur) {
|
---|
| 365 | const errorCapturedHooks = cur.ec;
|
---|
| 366 | if (errorCapturedHooks) {
|
---|
| 367 | for (let i = 0; i < errorCapturedHooks.length; i++) {
|
---|
| 368 | if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
|
---|
| 369 | return;
|
---|
| 370 | }
|
---|
| 371 | }
|
---|
| 372 | }
|
---|
| 373 | cur = cur.parent;
|
---|
| 374 | }
|
---|
| 375 | if (errorHandler) {
|
---|
| 376 | callWithErrorHandling(errorHandler, null, 10, [
|
---|
| 377 | err,
|
---|
| 378 | exposedInstance,
|
---|
| 379 | errorInfo
|
---|
| 380 | ]);
|
---|
| 381 | return;
|
---|
| 382 | }
|
---|
| 383 | }
|
---|
| 384 | logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
|
---|
| 385 | }
|
---|
| 386 | function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
|
---|
| 387 | {
|
---|
| 388 | const info = ErrorTypeStrings[type];
|
---|
| 389 | if (contextVNode) {
|
---|
| 390 | pushWarningContext$1(contextVNode);
|
---|
| 391 | }
|
---|
| 392 | warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
|
---|
| 393 | if (contextVNode) {
|
---|
| 394 | popWarningContext$1();
|
---|
| 395 | }
|
---|
| 396 | if (throwInDev) {
|
---|
| 397 | throw err;
|
---|
| 398 | } else {
|
---|
| 399 | console.error(err);
|
---|
| 400 | }
|
---|
| 401 | }
|
---|
| 402 | }
|
---|
| 403 |
|
---|
| 404 | {
|
---|
| 405 | const g = shared.getGlobalThis();
|
---|
| 406 | const registerGlobalSetter = (key, setter) => {
|
---|
| 407 | let setters;
|
---|
| 408 | if (!(setters = g[key])) setters = g[key] = [];
|
---|
| 409 | setters.push(setter);
|
---|
| 410 | return (v) => {
|
---|
| 411 | if (setters.length > 1) setters.forEach((set) => set(v));
|
---|
| 412 | else setters[0](v);
|
---|
| 413 | };
|
---|
| 414 | };
|
---|
| 415 | registerGlobalSetter(
|
---|
| 416 | `__VUE_INSTANCE_SETTERS__`,
|
---|
| 417 | (v) => v
|
---|
| 418 | );
|
---|
| 419 | registerGlobalSetter(
|
---|
| 420 | `__VUE_SSR_SETTERS__`,
|
---|
| 421 | (v) => v
|
---|
| 422 | );
|
---|
| 423 | }
|
---|
| 424 | const classifyRE = /(?:^|[-_])(\w)/g;
|
---|
| 425 | const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
|
---|
| 426 | function getComponentName(Component, includeInferred = true) {
|
---|
| 427 | return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
|
---|
| 428 | }
|
---|
| 429 | function formatComponentName(instance, Component, isRoot = false) {
|
---|
| 430 | let name = getComponentName(Component);
|
---|
| 431 | if (!name && Component.__file) {
|
---|
| 432 | const match = Component.__file.match(/([^/\\]+)\.\w+$/);
|
---|
| 433 | if (match) {
|
---|
| 434 | name = match[1];
|
---|
| 435 | }
|
---|
| 436 | }
|
---|
| 437 | if (!name && instance && instance.parent) {
|
---|
| 438 | const inferFromRegistry = (registry) => {
|
---|
| 439 | for (const key in registry) {
|
---|
| 440 | if (registry[key] === Component) {
|
---|
| 441 | return key;
|
---|
| 442 | }
|
---|
| 443 | }
|
---|
| 444 | };
|
---|
| 445 | name = inferFromRegistry(
|
---|
| 446 | instance.components || instance.parent.type.components
|
---|
| 447 | ) || inferFromRegistry(instance.appContext.components);
|
---|
| 448 | }
|
---|
| 449 | return name ? classify(name) : isRoot ? `App` : `Anonymous`;
|
---|
| 450 | }
|
---|
| 451 |
|
---|
| 452 | const warn = warn$1 ;
|
---|
| 453 |
|
---|
| 454 | function ssrRenderList(source, renderItem) {
|
---|
| 455 | if (shared.isArray(source) || shared.isString(source)) {
|
---|
| 456 | for (let i = 0, l = source.length; i < l; i++) {
|
---|
| 457 | renderItem(source[i], i);
|
---|
| 458 | }
|
---|
| 459 | } else if (typeof source === "number") {
|
---|
| 460 | if (!Number.isInteger(source)) {
|
---|
| 461 | warn(`The v-for range expect an integer value but got ${source}.`);
|
---|
| 462 | return;
|
---|
| 463 | }
|
---|
| 464 | for (let i = 0; i < source; i++) {
|
---|
| 465 | renderItem(i + 1, i);
|
---|
| 466 | }
|
---|
| 467 | } else if (shared.isObject(source)) {
|
---|
| 468 | if (source[Symbol.iterator]) {
|
---|
| 469 | const arr = Array.from(source);
|
---|
| 470 | for (let i = 0, l = arr.length; i < l; i++) {
|
---|
| 471 | renderItem(arr[i], i);
|
---|
| 472 | }
|
---|
| 473 | } else {
|
---|
| 474 | const keys = Object.keys(source);
|
---|
| 475 | for (let i = 0, l = keys.length; i < l; i++) {
|
---|
| 476 | const key = keys[i];
|
---|
| 477 | renderItem(source[key], key, i);
|
---|
| 478 | }
|
---|
| 479 | }
|
---|
| 480 | }
|
---|
| 481 | }
|
---|
| 482 |
|
---|
| 483 | async function ssrRenderSuspense(push, { default: renderContent }) {
|
---|
| 484 | if (renderContent) {
|
---|
| 485 | renderContent();
|
---|
| 486 | } else {
|
---|
| 487 | push(`<!---->`);
|
---|
| 488 | }
|
---|
| 489 | }
|
---|
| 490 |
|
---|
| 491 | function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
|
---|
| 492 | if (typeof dir !== "function" && dir.getSSRProps) {
|
---|
| 493 | return dir.getSSRProps(
|
---|
| 494 | {
|
---|
| 495 | dir,
|
---|
| 496 | instance: Vue.ssrUtils.getComponentPublicInstance(instance.$),
|
---|
| 497 | value,
|
---|
| 498 | oldValue: void 0,
|
---|
| 499 | arg,
|
---|
| 500 | modifiers
|
---|
| 501 | },
|
---|
| 502 | null
|
---|
| 503 | ) || {};
|
---|
| 504 | }
|
---|
| 505 | return {};
|
---|
| 506 | }
|
---|
| 507 |
|
---|
| 508 | const ssrLooseEqual = shared.looseEqual;
|
---|
| 509 | function ssrLooseContain(arr, value) {
|
---|
| 510 | return shared.looseIndexOf(arr, value) > -1;
|
---|
| 511 | }
|
---|
| 512 | function ssrRenderDynamicModel(type, model, value) {
|
---|
| 513 | switch (type) {
|
---|
| 514 | case "radio":
|
---|
| 515 | return shared.looseEqual(model, value) ? " checked" : "";
|
---|
| 516 | case "checkbox":
|
---|
| 517 | return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? " checked" : "";
|
---|
| 518 | default:
|
---|
| 519 | return ssrRenderAttr("value", model);
|
---|
| 520 | }
|
---|
| 521 | }
|
---|
| 522 | function ssrGetDynamicModelProps(existingProps = {}, model) {
|
---|
| 523 | const { type, value } = existingProps;
|
---|
| 524 | switch (type) {
|
---|
| 525 | case "radio":
|
---|
| 526 | return shared.looseEqual(model, value) ? { checked: true } : null;
|
---|
| 527 | case "checkbox":
|
---|
| 528 | return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
|
---|
| 529 | default:
|
---|
| 530 | return { value: model };
|
---|
| 531 | }
|
---|
| 532 | }
|
---|
| 533 |
|
---|
| 534 | var helpers = /*#__PURE__*/Object.freeze({
|
---|
| 535 | __proto__: null,
|
---|
| 536 | ssrGetDirectiveProps: ssrGetDirectiveProps,
|
---|
| 537 | ssrGetDynamicModelProps: ssrGetDynamicModelProps,
|
---|
| 538 | ssrIncludeBooleanAttr: shared.includeBooleanAttr,
|
---|
| 539 | ssrInterpolate: ssrInterpolate,
|
---|
| 540 | ssrLooseContain: ssrLooseContain,
|
---|
| 541 | ssrLooseEqual: ssrLooseEqual,
|
---|
| 542 | ssrRenderAttr: ssrRenderAttr,
|
---|
| 543 | ssrRenderAttrs: ssrRenderAttrs,
|
---|
| 544 | ssrRenderClass: ssrRenderClass,
|
---|
| 545 | ssrRenderComponent: ssrRenderComponent,
|
---|
| 546 | ssrRenderDynamicAttr: ssrRenderDynamicAttr,
|
---|
| 547 | ssrRenderDynamicModel: ssrRenderDynamicModel,
|
---|
| 548 | ssrRenderList: ssrRenderList,
|
---|
| 549 | ssrRenderSlot: ssrRenderSlot,
|
---|
| 550 | ssrRenderSlotInner: ssrRenderSlotInner,
|
---|
| 551 | ssrRenderStyle: ssrRenderStyle,
|
---|
| 552 | ssrRenderSuspense: ssrRenderSuspense,
|
---|
| 553 | ssrRenderTeleport: ssrRenderTeleport,
|
---|
| 554 | ssrRenderVNode: renderVNode
|
---|
| 555 | });
|
---|
| 556 |
|
---|
| 557 | const compileCache = /* @__PURE__ */ Object.create(null);
|
---|
| 558 | function ssrCompile(template, instance) {
|
---|
| 559 | const Component = instance.type;
|
---|
| 560 | const { isCustomElement, compilerOptions } = instance.appContext.config;
|
---|
| 561 | const { delimiters, compilerOptions: componentCompilerOptions } = Component;
|
---|
| 562 | const finalCompilerOptions = shared.extend(
|
---|
| 563 | shared.extend(
|
---|
| 564 | {
|
---|
| 565 | isCustomElement,
|
---|
| 566 | delimiters
|
---|
| 567 | },
|
---|
| 568 | compilerOptions
|
---|
| 569 | ),
|
---|
| 570 | componentCompilerOptions
|
---|
| 571 | );
|
---|
| 572 | finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || shared.NO;
|
---|
| 573 | finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || shared.NO;
|
---|
| 574 | const cacheKey = JSON.stringify(
|
---|
| 575 | {
|
---|
| 576 | template,
|
---|
| 577 | compilerOptions: finalCompilerOptions
|
---|
| 578 | },
|
---|
| 579 | (key, value) => {
|
---|
| 580 | return shared.isFunction(value) ? value.toString() : value;
|
---|
| 581 | }
|
---|
| 582 | );
|
---|
| 583 | const cached = compileCache[cacheKey];
|
---|
| 584 | if (cached) {
|
---|
| 585 | return cached;
|
---|
| 586 | }
|
---|
| 587 | finalCompilerOptions.onError = (err) => {
|
---|
| 588 | {
|
---|
| 589 | const message = `[@vue/server-renderer] Template compilation error: ${err.message}`;
|
---|
| 590 | const codeFrame = err.loc && shared.generateCodeFrame(
|
---|
| 591 | template,
|
---|
| 592 | err.loc.start.offset,
|
---|
| 593 | err.loc.end.offset
|
---|
| 594 | );
|
---|
| 595 | Vue.warn(codeFrame ? `${message}
|
---|
| 596 | ${codeFrame}` : message);
|
---|
| 597 | }
|
---|
| 598 | };
|
---|
| 599 | const { code } = compilerSsr.compile(template, finalCompilerOptions);
|
---|
| 600 | const requireMap = {
|
---|
| 601 | vue: Vue__namespace,
|
---|
| 602 | "vue/server-renderer": helpers
|
---|
| 603 | };
|
---|
| 604 | const fakeRequire = (id) => requireMap[id];
|
---|
| 605 | return compileCache[cacheKey] = Function("require", code)(fakeRequire);
|
---|
| 606 | }
|
---|
| 607 |
|
---|
| 608 | const {
|
---|
| 609 | createComponentInstance,
|
---|
| 610 | setCurrentRenderingInstance,
|
---|
| 611 | setupComponent,
|
---|
| 612 | renderComponentRoot,
|
---|
| 613 | normalizeVNode,
|
---|
| 614 | pushWarningContext,
|
---|
| 615 | popWarningContext
|
---|
| 616 | } = Vue.ssrUtils;
|
---|
| 617 | function createBuffer() {
|
---|
| 618 | let appendable = false;
|
---|
| 619 | const buffer = [];
|
---|
| 620 | return {
|
---|
| 621 | getBuffer() {
|
---|
| 622 | return buffer;
|
---|
| 623 | },
|
---|
| 624 | push(item) {
|
---|
| 625 | const isStringItem = shared.isString(item);
|
---|
| 626 | if (appendable && isStringItem) {
|
---|
| 627 | buffer[buffer.length - 1] += item;
|
---|
| 628 | return;
|
---|
| 629 | }
|
---|
| 630 | buffer.push(item);
|
---|
| 631 | appendable = isStringItem;
|
---|
| 632 | if (shared.isPromise(item) || shared.isArray(item) && item.hasAsync) {
|
---|
| 633 | buffer.hasAsync = true;
|
---|
| 634 | }
|
---|
| 635 | }
|
---|
| 636 | };
|
---|
| 637 | }
|
---|
| 638 | function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
|
---|
| 639 | const instance = vnode.component = createComponentInstance(
|
---|
| 640 | vnode,
|
---|
| 641 | parentComponent,
|
---|
| 642 | null
|
---|
| 643 | );
|
---|
| 644 | pushWarningContext(vnode);
|
---|
| 645 | const res = setupComponent(
|
---|
| 646 | instance,
|
---|
| 647 | true
|
---|
| 648 | /* isSSR */
|
---|
| 649 | );
|
---|
| 650 | popWarningContext();
|
---|
| 651 | const hasAsyncSetup = shared.isPromise(res);
|
---|
| 652 | let prefetches = instance.sp;
|
---|
| 653 | if (hasAsyncSetup || prefetches) {
|
---|
| 654 | const p = Promise.resolve(res).then(() => {
|
---|
| 655 | if (hasAsyncSetup) prefetches = instance.sp;
|
---|
| 656 | if (prefetches) {
|
---|
| 657 | return Promise.all(
|
---|
| 658 | prefetches.map((prefetch) => prefetch.call(instance.proxy))
|
---|
| 659 | );
|
---|
| 660 | }
|
---|
| 661 | }).catch(shared.NOOP);
|
---|
| 662 | return p.then(() => renderComponentSubTree(instance, slotScopeId));
|
---|
| 663 | } else {
|
---|
| 664 | return renderComponentSubTree(instance, slotScopeId);
|
---|
| 665 | }
|
---|
| 666 | }
|
---|
| 667 | function renderComponentSubTree(instance, slotScopeId) {
|
---|
| 668 | pushWarningContext(instance.vnode);
|
---|
| 669 | const comp = instance.type;
|
---|
| 670 | const { getBuffer, push } = createBuffer();
|
---|
| 671 | if (shared.isFunction(comp)) {
|
---|
| 672 | let root = renderComponentRoot(instance);
|
---|
| 673 | if (!comp.props) {
|
---|
| 674 | for (const key in instance.attrs) {
|
---|
| 675 | if (key.startsWith(`data-v-`)) {
|
---|
| 676 | (root.props || (root.props = {}))[key] = ``;
|
---|
| 677 | }
|
---|
| 678 | }
|
---|
| 679 | }
|
---|
| 680 | renderVNode(push, instance.subTree = root, instance, slotScopeId);
|
---|
| 681 | } else {
|
---|
| 682 | if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) {
|
---|
| 683 | comp.ssrRender = ssrCompile(comp.template, instance);
|
---|
| 684 | }
|
---|
| 685 | const ssrRender = instance.ssrRender || comp.ssrRender;
|
---|
| 686 | if (ssrRender) {
|
---|
| 687 | let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
|
---|
| 688 | let hasCloned = false;
|
---|
| 689 | let cur = instance;
|
---|
| 690 | while (true) {
|
---|
| 691 | const scopeId = cur.vnode.scopeId;
|
---|
| 692 | if (scopeId) {
|
---|
| 693 | if (!hasCloned) {
|
---|
| 694 | attrs = { ...attrs };
|
---|
| 695 | hasCloned = true;
|
---|
| 696 | }
|
---|
| 697 | attrs[scopeId] = "";
|
---|
| 698 | }
|
---|
| 699 | const parent = cur.parent;
|
---|
| 700 | if (parent && parent.subTree && parent.subTree === cur.vnode) {
|
---|
| 701 | cur = parent;
|
---|
| 702 | } else {
|
---|
| 703 | break;
|
---|
| 704 | }
|
---|
| 705 | }
|
---|
| 706 | if (slotScopeId) {
|
---|
| 707 | if (!hasCloned) attrs = { ...attrs };
|
---|
| 708 | const slotScopeIdList = slotScopeId.trim().split(" ");
|
---|
| 709 | for (let i = 0; i < slotScopeIdList.length; i++) {
|
---|
| 710 | attrs[slotScopeIdList[i]] = "";
|
---|
| 711 | }
|
---|
| 712 | }
|
---|
| 713 | const prev = setCurrentRenderingInstance(instance);
|
---|
| 714 | try {
|
---|
| 715 | ssrRender(
|
---|
| 716 | instance.proxy,
|
---|
| 717 | push,
|
---|
| 718 | instance,
|
---|
| 719 | attrs,
|
---|
| 720 | // compiler-optimized bindings
|
---|
| 721 | instance.props,
|
---|
| 722 | instance.setupState,
|
---|
| 723 | instance.data,
|
---|
| 724 | instance.ctx
|
---|
| 725 | );
|
---|
| 726 | } finally {
|
---|
| 727 | setCurrentRenderingInstance(prev);
|
---|
| 728 | }
|
---|
| 729 | } else if (instance.render && instance.render !== shared.NOOP) {
|
---|
| 730 | renderVNode(
|
---|
| 731 | push,
|
---|
| 732 | instance.subTree = renderComponentRoot(instance),
|
---|
| 733 | instance,
|
---|
| 734 | slotScopeId
|
---|
| 735 | );
|
---|
| 736 | } else {
|
---|
| 737 | const componentName = comp.name || comp.__file || `<Anonymous>`;
|
---|
| 738 | Vue.warn(`Component ${componentName} is missing template or render function.`);
|
---|
| 739 | push(`<!---->`);
|
---|
| 740 | }
|
---|
| 741 | }
|
---|
| 742 | popWarningContext();
|
---|
| 743 | return getBuffer();
|
---|
| 744 | }
|
---|
| 745 | function renderVNode(push, vnode, parentComponent, slotScopeId) {
|
---|
| 746 | const { type, shapeFlag, children, dirs, props } = vnode;
|
---|
| 747 | if (dirs) {
|
---|
| 748 | vnode.props = applySSRDirectives(vnode, props, dirs);
|
---|
| 749 | }
|
---|
| 750 | switch (type) {
|
---|
| 751 | case Vue.Text:
|
---|
| 752 | push(shared.escapeHtml(children));
|
---|
| 753 | break;
|
---|
| 754 | case Vue.Comment:
|
---|
| 755 | push(
|
---|
| 756 | children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->`
|
---|
| 757 | );
|
---|
| 758 | break;
|
---|
| 759 | case Vue.Static:
|
---|
| 760 | push(children);
|
---|
| 761 | break;
|
---|
| 762 | case Vue.Fragment:
|
---|
| 763 | if (vnode.slotScopeIds) {
|
---|
| 764 | slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
|
---|
| 765 | }
|
---|
| 766 | push(`<!--[-->`);
|
---|
| 767 | renderVNodeChildren(
|
---|
| 768 | push,
|
---|
| 769 | children,
|
---|
| 770 | parentComponent,
|
---|
| 771 | slotScopeId
|
---|
| 772 | );
|
---|
| 773 | push(`<!--]-->`);
|
---|
| 774 | break;
|
---|
| 775 | default:
|
---|
| 776 | if (shapeFlag & 1) {
|
---|
| 777 | renderElementVNode(push, vnode, parentComponent, slotScopeId);
|
---|
| 778 | } else if (shapeFlag & 6) {
|
---|
| 779 | push(renderComponentVNode(vnode, parentComponent, slotScopeId));
|
---|
| 780 | } else if (shapeFlag & 64) {
|
---|
| 781 | renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
|
---|
| 782 | } else if (shapeFlag & 128) {
|
---|
| 783 | renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
|
---|
| 784 | } else {
|
---|
| 785 | Vue.warn(
|
---|
| 786 | "[@vue/server-renderer] Invalid VNode type:",
|
---|
| 787 | type,
|
---|
| 788 | `(${typeof type})`
|
---|
| 789 | );
|
---|
| 790 | }
|
---|
| 791 | }
|
---|
| 792 | }
|
---|
| 793 | function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
|
---|
| 794 | for (let i = 0; i < children.length; i++) {
|
---|
| 795 | renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
|
---|
| 796 | }
|
---|
| 797 | }
|
---|
| 798 | function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
|
---|
| 799 | const tag = vnode.type;
|
---|
| 800 | let { props, children, shapeFlag, scopeId } = vnode;
|
---|
| 801 | let openTag = `<${tag}`;
|
---|
| 802 | if (props) {
|
---|
| 803 | openTag += ssrRenderAttrs(props, tag);
|
---|
| 804 | }
|
---|
| 805 | if (scopeId) {
|
---|
| 806 | openTag += ` ${scopeId}`;
|
---|
| 807 | }
|
---|
| 808 | let curParent = parentComponent;
|
---|
| 809 | let curVnode = vnode;
|
---|
| 810 | while (curParent && curVnode === curParent.subTree) {
|
---|
| 811 | curVnode = curParent.vnode;
|
---|
| 812 | if (curVnode.scopeId) {
|
---|
| 813 | openTag += ` ${curVnode.scopeId}`;
|
---|
| 814 | }
|
---|
| 815 | curParent = curParent.parent;
|
---|
| 816 | }
|
---|
| 817 | if (slotScopeId) {
|
---|
| 818 | openTag += ` ${slotScopeId}`;
|
---|
| 819 | }
|
---|
| 820 | push(openTag + `>`);
|
---|
| 821 | if (!shared.isVoidTag(tag)) {
|
---|
| 822 | let hasChildrenOverride = false;
|
---|
| 823 | if (props) {
|
---|
| 824 | if (props.innerHTML) {
|
---|
| 825 | hasChildrenOverride = true;
|
---|
| 826 | push(props.innerHTML);
|
---|
| 827 | } else if (props.textContent) {
|
---|
| 828 | hasChildrenOverride = true;
|
---|
| 829 | push(shared.escapeHtml(props.textContent));
|
---|
| 830 | } else if (tag === "textarea" && props.value) {
|
---|
| 831 | hasChildrenOverride = true;
|
---|
| 832 | push(shared.escapeHtml(props.value));
|
---|
| 833 | }
|
---|
| 834 | }
|
---|
| 835 | if (!hasChildrenOverride) {
|
---|
| 836 | if (shapeFlag & 8) {
|
---|
| 837 | push(shared.escapeHtml(children));
|
---|
| 838 | } else if (shapeFlag & 16) {
|
---|
| 839 | renderVNodeChildren(
|
---|
| 840 | push,
|
---|
| 841 | children,
|
---|
| 842 | parentComponent,
|
---|
| 843 | slotScopeId
|
---|
| 844 | );
|
---|
| 845 | }
|
---|
| 846 | }
|
---|
| 847 | push(`</${tag}>`);
|
---|
| 848 | }
|
---|
| 849 | }
|
---|
| 850 | function applySSRDirectives(vnode, rawProps, dirs) {
|
---|
| 851 | const toMerge = [];
|
---|
| 852 | for (let i = 0; i < dirs.length; i++) {
|
---|
| 853 | const binding = dirs[i];
|
---|
| 854 | const {
|
---|
| 855 | dir: { getSSRProps }
|
---|
| 856 | } = binding;
|
---|
| 857 | if (getSSRProps) {
|
---|
| 858 | const props = getSSRProps(binding, vnode);
|
---|
| 859 | if (props) toMerge.push(props);
|
---|
| 860 | }
|
---|
| 861 | }
|
---|
| 862 | return Vue.mergeProps(rawProps || {}, ...toMerge);
|
---|
| 863 | }
|
---|
| 864 | function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
|
---|
| 865 | const target = vnode.props && vnode.props.to;
|
---|
| 866 | const disabled = vnode.props && vnode.props.disabled;
|
---|
| 867 | if (!target) {
|
---|
| 868 | if (!disabled) {
|
---|
| 869 | Vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
|
---|
| 870 | }
|
---|
| 871 | return [];
|
---|
| 872 | }
|
---|
| 873 | if (!shared.isString(target)) {
|
---|
| 874 | Vue.warn(
|
---|
| 875 | `[@vue/server-renderer] Teleport target must be a query selector string.`
|
---|
| 876 | );
|
---|
| 877 | return [];
|
---|
| 878 | }
|
---|
| 879 | ssrRenderTeleport(
|
---|
| 880 | push,
|
---|
| 881 | (push2) => {
|
---|
| 882 | renderVNodeChildren(
|
---|
| 883 | push2,
|
---|
| 884 | vnode.children,
|
---|
| 885 | parentComponent,
|
---|
| 886 | slotScopeId
|
---|
| 887 | );
|
---|
| 888 | },
|
---|
| 889 | target,
|
---|
| 890 | disabled || disabled === "",
|
---|
| 891 | parentComponent
|
---|
| 892 | );
|
---|
| 893 | }
|
---|
| 894 |
|
---|
| 895 | const { isVNode: isVNode$1 } = Vue.ssrUtils;
|
---|
| 896 | function nestedUnrollBuffer(buffer, parentRet, startIndex) {
|
---|
| 897 | if (!buffer.hasAsync) {
|
---|
| 898 | return parentRet + unrollBufferSync$1(buffer);
|
---|
| 899 | }
|
---|
| 900 | let ret = parentRet;
|
---|
| 901 | for (let i = startIndex; i < buffer.length; i += 1) {
|
---|
| 902 | const item = buffer[i];
|
---|
| 903 | if (shared.isString(item)) {
|
---|
| 904 | ret += item;
|
---|
| 905 | continue;
|
---|
| 906 | }
|
---|
| 907 | if (shared.isPromise(item)) {
|
---|
| 908 | return item.then((nestedItem) => {
|
---|
| 909 | buffer[i] = nestedItem;
|
---|
| 910 | return nestedUnrollBuffer(buffer, ret, i);
|
---|
| 911 | });
|
---|
| 912 | }
|
---|
| 913 | const result = nestedUnrollBuffer(item, ret, 0);
|
---|
| 914 | if (shared.isPromise(result)) {
|
---|
| 915 | return result.then((nestedItem) => {
|
---|
| 916 | buffer[i] = nestedItem;
|
---|
| 917 | return nestedUnrollBuffer(buffer, "", i);
|
---|
| 918 | });
|
---|
| 919 | }
|
---|
| 920 | ret = result;
|
---|
| 921 | }
|
---|
| 922 | return ret;
|
---|
| 923 | }
|
---|
| 924 | function unrollBuffer$1(buffer) {
|
---|
| 925 | return nestedUnrollBuffer(buffer, "", 0);
|
---|
| 926 | }
|
---|
| 927 | function unrollBufferSync$1(buffer) {
|
---|
| 928 | let ret = "";
|
---|
| 929 | for (let i = 0; i < buffer.length; i++) {
|
---|
| 930 | let item = buffer[i];
|
---|
| 931 | if (shared.isString(item)) {
|
---|
| 932 | ret += item;
|
---|
| 933 | } else {
|
---|
| 934 | ret += unrollBufferSync$1(item);
|
---|
| 935 | }
|
---|
| 936 | }
|
---|
| 937 | return ret;
|
---|
| 938 | }
|
---|
| 939 | async function renderToString(input, context = {}) {
|
---|
| 940 | if (isVNode$1(input)) {
|
---|
| 941 | return renderToString(Vue.createApp({ render: () => input }), context);
|
---|
| 942 | }
|
---|
| 943 | const vnode = Vue.createVNode(input._component, input._props);
|
---|
| 944 | vnode.appContext = input._context;
|
---|
| 945 | input.provide(Vue.ssrContextKey, context);
|
---|
| 946 | const buffer = await renderComponentVNode(vnode);
|
---|
| 947 | const result = await unrollBuffer$1(buffer);
|
---|
| 948 | await resolveTeleports(context);
|
---|
| 949 | if (context.__watcherHandles) {
|
---|
| 950 | for (const unwatch of context.__watcherHandles) {
|
---|
| 951 | unwatch();
|
---|
| 952 | }
|
---|
| 953 | }
|
---|
| 954 | return result;
|
---|
| 955 | }
|
---|
| 956 | async function resolveTeleports(context) {
|
---|
| 957 | if (context.__teleportBuffers) {
|
---|
| 958 | context.teleports = context.teleports || {};
|
---|
| 959 | for (const key in context.__teleportBuffers) {
|
---|
| 960 | context.teleports[key] = await unrollBuffer$1(
|
---|
| 961 | await Promise.all([context.__teleportBuffers[key]])
|
---|
| 962 | );
|
---|
| 963 | }
|
---|
| 964 | }
|
---|
| 965 | }
|
---|
| 966 |
|
---|
| 967 | const { isVNode } = Vue.ssrUtils;
|
---|
| 968 | async function unrollBuffer(buffer, stream) {
|
---|
| 969 | if (buffer.hasAsync) {
|
---|
| 970 | for (let i = 0; i < buffer.length; i++) {
|
---|
| 971 | let item = buffer[i];
|
---|
| 972 | if (shared.isPromise(item)) {
|
---|
| 973 | item = await item;
|
---|
| 974 | }
|
---|
| 975 | if (shared.isString(item)) {
|
---|
| 976 | stream.push(item);
|
---|
| 977 | } else {
|
---|
| 978 | await unrollBuffer(item, stream);
|
---|
| 979 | }
|
---|
| 980 | }
|
---|
| 981 | } else {
|
---|
| 982 | unrollBufferSync(buffer, stream);
|
---|
| 983 | }
|
---|
| 984 | }
|
---|
| 985 | function unrollBufferSync(buffer, stream) {
|
---|
| 986 | for (let i = 0; i < buffer.length; i++) {
|
---|
| 987 | let item = buffer[i];
|
---|
| 988 | if (shared.isString(item)) {
|
---|
| 989 | stream.push(item);
|
---|
| 990 | } else {
|
---|
| 991 | unrollBufferSync(item, stream);
|
---|
| 992 | }
|
---|
| 993 | }
|
---|
| 994 | }
|
---|
| 995 | function renderToSimpleStream(input, context, stream) {
|
---|
| 996 | if (isVNode(input)) {
|
---|
| 997 | return renderToSimpleStream(
|
---|
| 998 | Vue.createApp({ render: () => input }),
|
---|
| 999 | context,
|
---|
| 1000 | stream
|
---|
| 1001 | );
|
---|
| 1002 | }
|
---|
| 1003 | const vnode = Vue.createVNode(input._component, input._props);
|
---|
| 1004 | vnode.appContext = input._context;
|
---|
| 1005 | input.provide(Vue.ssrContextKey, context);
|
---|
| 1006 | Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => {
|
---|
| 1007 | if (context.__watcherHandles) {
|
---|
| 1008 | for (const unwatch of context.__watcherHandles) {
|
---|
| 1009 | unwatch();
|
---|
| 1010 | }
|
---|
| 1011 | }
|
---|
| 1012 | }).then(() => stream.push(null)).catch((error) => {
|
---|
| 1013 | stream.destroy(error);
|
---|
| 1014 | });
|
---|
| 1015 | return stream;
|
---|
| 1016 | }
|
---|
| 1017 | function renderToStream(input, context = {}) {
|
---|
| 1018 | console.warn(
|
---|
| 1019 | `[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.`
|
---|
| 1020 | );
|
---|
| 1021 | return renderToNodeStream(input, context);
|
---|
| 1022 | }
|
---|
| 1023 | function renderToNodeStream(input, context = {}) {
|
---|
| 1024 | const stream = new (require("node:stream")).Readable({ read() {
|
---|
| 1025 | } }) ;
|
---|
| 1026 | if (!stream) {
|
---|
| 1027 | throw new Error(
|
---|
| 1028 | `ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.`
|
---|
| 1029 | );
|
---|
| 1030 | }
|
---|
| 1031 | return renderToSimpleStream(input, context, stream);
|
---|
| 1032 | }
|
---|
| 1033 | function pipeToNodeWritable(input, context = {}, writable) {
|
---|
| 1034 | renderToSimpleStream(input, context, {
|
---|
| 1035 | push(content) {
|
---|
| 1036 | if (content != null) {
|
---|
| 1037 | writable.write(content);
|
---|
| 1038 | } else {
|
---|
| 1039 | writable.end();
|
---|
| 1040 | }
|
---|
| 1041 | },
|
---|
| 1042 | destroy(err) {
|
---|
| 1043 | writable.destroy(err);
|
---|
| 1044 | }
|
---|
| 1045 | });
|
---|
| 1046 | }
|
---|
| 1047 | function renderToWebStream(input, context = {}) {
|
---|
| 1048 | if (typeof ReadableStream !== "function") {
|
---|
| 1049 | throw new Error(
|
---|
| 1050 | `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.`
|
---|
| 1051 | );
|
---|
| 1052 | }
|
---|
| 1053 | const encoder = new TextEncoder();
|
---|
| 1054 | let cancelled = false;
|
---|
| 1055 | return new ReadableStream({
|
---|
| 1056 | start(controller) {
|
---|
| 1057 | renderToSimpleStream(input, context, {
|
---|
| 1058 | push(content) {
|
---|
| 1059 | if (cancelled) return;
|
---|
| 1060 | if (content != null) {
|
---|
| 1061 | controller.enqueue(encoder.encode(content));
|
---|
| 1062 | } else {
|
---|
| 1063 | controller.close();
|
---|
| 1064 | }
|
---|
| 1065 | },
|
---|
| 1066 | destroy(err) {
|
---|
| 1067 | controller.error(err);
|
---|
| 1068 | }
|
---|
| 1069 | });
|
---|
| 1070 | },
|
---|
| 1071 | cancel() {
|
---|
| 1072 | cancelled = true;
|
---|
| 1073 | }
|
---|
| 1074 | });
|
---|
| 1075 | }
|
---|
| 1076 | function pipeToWebWritable(input, context = {}, writable) {
|
---|
| 1077 | const writer = writable.getWriter();
|
---|
| 1078 | const encoder = new TextEncoder();
|
---|
| 1079 | let hasReady = false;
|
---|
| 1080 | try {
|
---|
| 1081 | hasReady = shared.isPromise(writer.ready);
|
---|
| 1082 | } catch (e) {
|
---|
| 1083 | }
|
---|
| 1084 | renderToSimpleStream(input, context, {
|
---|
| 1085 | async push(content) {
|
---|
| 1086 | if (hasReady) {
|
---|
| 1087 | await writer.ready;
|
---|
| 1088 | }
|
---|
| 1089 | if (content != null) {
|
---|
| 1090 | return writer.write(encoder.encode(content));
|
---|
| 1091 | } else {
|
---|
| 1092 | return writer.close();
|
---|
| 1093 | }
|
---|
| 1094 | },
|
---|
| 1095 | destroy(err) {
|
---|
| 1096 | console.log(err);
|
---|
| 1097 | writer.close();
|
---|
| 1098 | }
|
---|
| 1099 | });
|
---|
| 1100 | }
|
---|
| 1101 |
|
---|
| 1102 | Vue.initDirectivesForSSR();
|
---|
| 1103 |
|
---|
| 1104 | exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr;
|
---|
| 1105 | exports.pipeToNodeWritable = pipeToNodeWritable;
|
---|
| 1106 | exports.pipeToWebWritable = pipeToWebWritable;
|
---|
| 1107 | exports.renderToNodeStream = renderToNodeStream;
|
---|
| 1108 | exports.renderToSimpleStream = renderToSimpleStream;
|
---|
| 1109 | exports.renderToStream = renderToStream;
|
---|
| 1110 | exports.renderToString = renderToString;
|
---|
| 1111 | exports.renderToWebStream = renderToWebStream;
|
---|
| 1112 | exports.ssrGetDirectiveProps = ssrGetDirectiveProps;
|
---|
| 1113 | exports.ssrGetDynamicModelProps = ssrGetDynamicModelProps;
|
---|
| 1114 | exports.ssrInterpolate = ssrInterpolate;
|
---|
| 1115 | exports.ssrLooseContain = ssrLooseContain;
|
---|
| 1116 | exports.ssrLooseEqual = ssrLooseEqual;
|
---|
| 1117 | exports.ssrRenderAttr = ssrRenderAttr;
|
---|
| 1118 | exports.ssrRenderAttrs = ssrRenderAttrs;
|
---|
| 1119 | exports.ssrRenderClass = ssrRenderClass;
|
---|
| 1120 | exports.ssrRenderComponent = ssrRenderComponent;
|
---|
| 1121 | exports.ssrRenderDynamicAttr = ssrRenderDynamicAttr;
|
---|
| 1122 | exports.ssrRenderDynamicModel = ssrRenderDynamicModel;
|
---|
| 1123 | exports.ssrRenderList = ssrRenderList;
|
---|
| 1124 | exports.ssrRenderSlot = ssrRenderSlot;
|
---|
| 1125 | exports.ssrRenderSlotInner = ssrRenderSlotInner;
|
---|
| 1126 | exports.ssrRenderStyle = ssrRenderStyle;
|
---|
| 1127 | exports.ssrRenderSuspense = ssrRenderSuspense;
|
---|
| 1128 | exports.ssrRenderTeleport = ssrRenderTeleport;
|
---|
| 1129 | exports.ssrRenderVNode = renderVNode;
|
---|