@vue/server-renderer 3.6.0-beta.4 → 3.6.0-beta.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/server-renderer.cjs.js +773 -979
  2. package/dist/server-renderer.cjs.prod.js +531 -754
  3. package/dist/server-renderer.d.ts +40 -26
  4. package/dist/server-renderer.esm-browser.js +6018 -8067
  5. package/dist/server-renderer.esm-browser.prod.js +5 -4
  6. package/dist/server-renderer.esm-bundler.js +1231 -1463
  7. package/package.json +4 -4
package/dist/server-renderer.cjs.prod.js CHANGED
@@ -1,857 +1,633 @@
1
1
  /**
2
- * @vue/server-renderer v3.6.0-beta.4
3
- * (c) 2018-present Yuxi (Evan) You and Vue contributors
4
- * @license MIT
5
- **/
6
- 'use strict';
2
+ * @vue/server-renderer v3.6.0-beta.6
3
+ * (c) 2018-present Yuxi (Evan) You and Vue contributors
4
+ * @license MIT
5
+ **/
6
+ Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
7
+ //#region \0rolldown/runtime.js
8
+ var __create = Object.create;
9
+ var __defProp = Object.defineProperty;
10
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
11
+ var __getOwnPropNames = Object.getOwnPropertyNames;
12
+ var __getProtoOf = Object.getPrototypeOf;
13
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
14
+ var __exportAll = (all, no_symbols) => {
15
+ let target = {};
16
+ for (var name in all) {
17
+ __defProp(target, name, {
18
+ get: all[name],
19
+ enumerable: true
20
+ });
21
+ }
22
+ if (!no_symbols) {
23
+ __defProp(target, Symbol.toStringTag, { value: "Module" });
24
+ }
25
+ return target;
26
+ };
27
+ var __copyProps = (to, from, except, desc) => {
28
+ if (from && typeof from === "object" || typeof from === "function") {
29
+ for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
30
+ key = keys[i];
31
+ if (!__hasOwnProp.call(to, key) && key !== except) {
32
+ __defProp(to, key, {
33
+ get: ((k) => from[k]).bind(null, key),
34
+ enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
35
+ });
36
+ }
37
+ }
38
+ }
39
+ return to;
40
+ };
41
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
42
+ value: mod,
43
+ enumerable: true
44
+ }) : target, mod));
7
45
 
8
- Object.defineProperty(exports, '__esModule', { value: true });
46
+ //#endregion
47
+ let vue = require("vue");
48
+ vue = __toESM(vue);
49
+ let _vue_shared = require("@vue/shared");
50
+ let _vue_compiler_ssr = require("@vue/compiler-ssr");
9
51
 
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
- );
52
+ //#region packages/server-renderer/src/helpers/ssrRenderAttrs.ts
53
+ const shouldIgnoreProp = /* @__PURE__ */ (0, _vue_shared.makeMap)(`,key,ref,innerHTML,textContent,ref_key,ref_for`);
30
54
  function ssrRenderAttrs(props, tag) {
31
- let ret = "";
32
- for (let key in props) {
33
- if (shouldIgnoreProp(key) || shared.isOn(key) || tag === "textarea" && key === "value" || // force as property (not rendered in SSR)
34
- key.startsWith(".")) {
35
- continue;
36
- }
37
- const value = props[key];
38
- if (key.startsWith("^")) key = key.slice(1);
39
- if (key === "class" || key === "className") {
40
- ret += ` class="${ssrRenderClass(value)}"`;
41
- } else if (key === "style") {
42
- ret += ` style="${ssrRenderStyle(value)}"`;
43
- } else {
44
- ret += ssrRenderDynamicAttr(key, value, tag);
45
- }
46
- }
47
- return ret;
55
+ let ret = "";
56
+ for (let key in props) {
57
+ if (shouldIgnoreProp(key) || (0, _vue_shared.isOn)(key) || tag === "textarea" && key === "value" || key.startsWith(".")) continue;
58
+ const value = props[key];
59
+ if (key.startsWith("^")) key = key.slice(1);
60
+ if (key === "class" || key === "className") ret += ` class="${ssrRenderClass(value)}"`;
61
+ else if (key === "style") ret += ` style="${ssrRenderStyle(value)}"`;
62
+ else ret += ssrRenderDynamicAttr(key, value, tag);
63
+ }
64
+ return ret;
48
65
  }
49
66
  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
- }
67
+ if (!(0, _vue_shared.isRenderableAttrValue)(value)) return ``;
68
+ const attrKey = tag && (tag.indexOf("-") > 0 || (0, _vue_shared.isSVGTag)(tag)) ? key : _vue_shared.propsToAttrMap[key] || key.toLowerCase();
69
+ if ((0, _vue_shared.isBooleanAttr)(attrKey)) return (0, _vue_shared.includeBooleanAttr)(value) ? ` ${attrKey}` : ``;
70
+ else if ((0, _vue_shared.isSSRSafeAttrName)(attrKey)) return value === "" ? ` ${attrKey}` : ` ${attrKey}="${(0, _vue_shared.escapeHtml)(value)}"`;
71
+ else {
72
+ console.warn(`[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`);
73
+ return ``;
74
+ }
64
75
  }
65
76
  function ssrRenderAttr(key, value) {
66
- if (!shared.isRenderableAttrValue(value)) {
67
- return ``;
68
- }
69
- return ` ${key}="${shared.escapeHtml(value)}"`;
77
+ if (!(0, _vue_shared.isRenderableAttrValue)(value)) return ``;
78
+ return ` ${key}="${(0, _vue_shared.escapeHtml)(value)}"`;
70
79
  }
71
80
  function ssrRenderClass(raw) {
72
- return shared.escapeHtml(shared.normalizeClass(raw));
81
+ return (0, _vue_shared.escapeHtml)((0, _vue_shared.normalizeClass)(raw));
73
82
  }
74
83
  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(ssrResetCssVars(raw));
82
- return shared.escapeHtml(shared.stringifyStyle(styles));
84
+ if (!raw) return "";
85
+ if ((0, _vue_shared.isString)(raw)) return (0, _vue_shared.escapeHtml)(raw);
86
+ return (0, _vue_shared.escapeHtml)((0, _vue_shared.stringifyStyle)((0, _vue_shared.normalizeStyle)(ssrResetCssVars(raw))));
83
87
  }
84
88
  function ssrResetCssVars(raw) {
85
- if (!shared.isArray(raw) && shared.isObject(raw)) {
86
- const res = {};
87
- for (const key in raw) {
88
- if (key.startsWith(":--")) {
89
- res[key.slice(1)] = shared.normalizeCssVarValue(raw[key]);
90
- } else {
91
- res[key] = raw[key];
92
- }
93
- }
94
- return res;
95
- }
96
- return raw;
89
+ if (!(0, _vue_shared.isArray)(raw) && (0, _vue_shared.isObject)(raw)) {
90
+ const res = {};
91
+ for (const key in raw) if (key.startsWith(":--")) res[key.slice(1)] = (0, _vue_shared.normalizeCssVarValue)(raw[key]);
92
+ else res[key] = raw[key];
93
+ return res;
94
+ }
95
+ return raw;
97
96
  }
98
97
 
98
+ //#endregion
99
+ //#region packages/server-renderer/src/helpers/ssrRenderComponent.ts
99
100
  function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
100
- return renderComponentVNode(
101
- Vue.createVNode(comp, props, children),
102
- parentComponent,
103
- slotScopeId
104
- );
101
+ return renderComponentVNode((0, vue.createVNode)(comp, props, children), parentComponent, slotScopeId);
105
102
  }
106
103
 
107
- const { ensureValidVNode } = Vue.ssrUtils;
104
+ //#endregion
105
+ //#region packages/server-renderer/src/helpers/ssrRenderSlot.ts
106
+ const { ensureValidVNode } = vue.ssrUtils;
108
107
  function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
109
- push(`<!--[-->`);
110
- ssrRenderSlotInner(
111
- slots,
112
- slotName,
113
- slotProps,
114
- fallbackRenderFn,
115
- push,
116
- parentComponent,
117
- slotScopeId
118
- );
119
- push(`<!--]-->`);
108
+ push(`<!--[-->`);
109
+ ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId);
110
+ push(`<!--]-->`);
120
111
  }
121
112
  function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
122
- const slotFn = slots[slotName];
123
- if (slotFn) {
124
- const slotBuffer = [];
125
- const bufferedPush = (item) => {
126
- slotBuffer.push(item);
127
- };
128
- const ret = slotFn(
129
- slotProps,
130
- bufferedPush,
131
- parentComponent,
132
- slotScopeId ? " " + slotScopeId : ""
133
- );
134
- if (shared.isArray(ret)) {
135
- const validSlotContent = ensureValidVNode(ret);
136
- if (validSlotContent) {
137
- renderVNodeChildren(
138
- push,
139
- validSlotContent,
140
- parentComponent,
141
- slotScopeId
142
- );
143
- } else if (fallbackRenderFn) {
144
- fallbackRenderFn();
145
- } else if (transition) {
146
- push(`<!---->`);
147
- }
148
- } else {
149
- let isEmptySlot = true;
150
- if (transition) {
151
- isEmptySlot = false;
152
- } else {
153
- for (let i = 0; i < slotBuffer.length; i++) {
154
- if (!isComment(slotBuffer[i])) {
155
- isEmptySlot = false;
156
- break;
157
- }
158
- }
159
- }
160
- if (isEmptySlot) {
161
- if (fallbackRenderFn) {
162
- fallbackRenderFn();
163
- }
164
- } else {
165
- let start = 0;
166
- let end = slotBuffer.length;
167
- if (transition && slotBuffer[0] === "<!--[-->" && slotBuffer[end - 1] === "<!--]-->") {
168
- start++;
169
- end--;
170
- }
171
- if (start < end) {
172
- for (let i = start; i < end; i++) {
173
- push(slotBuffer[i]);
174
- }
175
- } else if (transition) {
176
- push(`<!---->`);
177
- }
178
- }
179
- }
180
- } else if (fallbackRenderFn) {
181
- fallbackRenderFn();
182
- } else if (transition) {
183
- push(`<!---->`);
184
- }
113
+ const slotFn = slots[slotName];
114
+ if (slotFn) {
115
+ const slotBuffer = [];
116
+ const bufferedPush = (item) => {
117
+ slotBuffer.push(item);
118
+ };
119
+ const ret = slotFn(slotProps, bufferedPush, parentComponent, slotScopeId ? " " + slotScopeId : "");
120
+ if ((0, _vue_shared.isArray)(ret)) {
121
+ const validSlotContent = ensureValidVNode(ret);
122
+ if (validSlotContent) renderVNodeChildren(push, validSlotContent, parentComponent, slotScopeId);
123
+ else if (fallbackRenderFn) fallbackRenderFn();
124
+ else if (transition) push(`<!---->`);
125
+ } else {
126
+ let isEmptySlot = true;
127
+ if (transition) isEmptySlot = false;
128
+ else for (let i = 0; i < slotBuffer.length; i++) if (!isComment(slotBuffer[i])) {
129
+ isEmptySlot = false;
130
+ break;
131
+ }
132
+ if (isEmptySlot) {
133
+ if (fallbackRenderFn) fallbackRenderFn();
134
+ } else {
135
+ let start = 0;
136
+ let end = slotBuffer.length;
137
+ if (transition && slotBuffer[0] === "<!--[-->" && slotBuffer[end - 1] === "<!--]-->") {
138
+ start++;
139
+ end--;
140
+ }
141
+ if (start < end) for (let i = start; i < end; i++) push(slotBuffer[i]);
142
+ else if (transition) push(`<!---->`);
143
+ }
144
+ }
145
+ } else if (fallbackRenderFn) fallbackRenderFn();
146
+ else if (transition) push(`<!---->`);
185
147
  }
186
148
  const commentTestRE = /^<!--[\s\S]*-->$/;
187
149
  const commentRE = /<!--[^]*?-->/gm;
188
150
  function isComment(item) {
189
- if (typeof item !== "string" || !commentTestRE.test(item)) return false;
190
- if (item.length <= 8) return true;
191
- return !item.replace(commentRE, "").trim();
151
+ if (typeof item !== "string" || !commentTestRE.test(item)) return false;
152
+ if (item.length <= 8) return true;
153
+ return !item.replace(commentRE, "").trim();
192
154
  }
193
155
 
156
+ //#endregion
157
+ //#region packages/server-renderer/src/helpers/ssrRenderTeleport.ts
194
158
  function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
195
- parentPush("<!--teleport start-->");
196
- const context = parentComponent.appContext.provides[Vue.ssrContextKey];
197
- const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
198
- const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
199
- const bufferIndex = targetBuffer.length;
200
- let teleportContent;
201
- if (disabled) {
202
- contentRenderFn(parentPush);
203
- teleportContent = `<!--teleport start anchor--><!--teleport anchor-->`;
204
- } else {
205
- const { getBuffer, push } = createBuffer();
206
- push(`<!--teleport start anchor-->`);
207
- contentRenderFn(push);
208
- push(`<!--teleport anchor-->`);
209
- teleportContent = getBuffer();
210
- }
211
- targetBuffer.splice(bufferIndex, 0, teleportContent);
212
- parentPush("<!--teleport end-->");
159
+ parentPush("<!--teleport start-->");
160
+ const context = parentComponent.appContext.provides[vue.ssrContextKey];
161
+ const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
162
+ const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
163
+ const bufferIndex = targetBuffer.length;
164
+ let teleportContent;
165
+ if (disabled) {
166
+ contentRenderFn(parentPush);
167
+ teleportContent = `<!--teleport start anchor--><!--teleport anchor-->`;
168
+ } else {
169
+ const { getBuffer, push } = createBuffer();
170
+ push(`<!--teleport start anchor-->`);
171
+ contentRenderFn(push);
172
+ push(`<!--teleport anchor-->`);
173
+ teleportContent = getBuffer();
174
+ }
175
+ targetBuffer.splice(bufferIndex, 0, teleportContent);
176
+ parentPush("<!--teleport end-->");
213
177
  }
214
178
 
179
+ //#endregion
180
+ //#region packages/server-renderer/src/helpers/ssrInterpolate.ts
215
181
  function ssrInterpolate(value) {
216
- return shared.escapeHtml(shared.toDisplayString(value));
182
+ return (0, _vue_shared.escapeHtml)((0, _vue_shared.toDisplayString)(value));
217
183
  }
218
184
 
185
+ //#endregion
186
+ //#region packages/server-renderer/src/helpers/ssrRenderList.ts
219
187
  function ssrRenderList(source, renderItem) {
220
- if (shared.isArray(source) || shared.isString(source)) {
221
- for (let i = 0, l = source.length; i < l; i++) {
222
- renderItem(source[i], i);
223
- }
224
- } else if (typeof source === "number") {
225
- for (let i = 0; i < source; i++) {
226
- renderItem(i + 1, i);
227
- }
228
- } else if (shared.isObject(source)) {
229
- if (source[Symbol.iterator]) {
230
- const arr = Array.from(source);
231
- for (let i = 0, l = arr.length; i < l; i++) {
232
- renderItem(arr[i], i);
233
- }
234
- } else {
235
- const keys = Object.keys(source);
236
- for (let i = 0, l = keys.length; i < l; i++) {
237
- const key = keys[i];
238
- renderItem(source[key], key, i);
239
- }
240
- }
241
- }
188
+ if ((0, _vue_shared.isArray)(source) || (0, _vue_shared.isString)(source)) for (let i = 0, l = source.length; i < l; i++) renderItem(source[i], i);
189
+ else if (typeof source === "number") for (let i = 0; i < source; i++) renderItem(i + 1, i);
190
+ else if ((0, _vue_shared.isObject)(source)) if (source[Symbol.iterator]) {
191
+ const arr = Array.from(source);
192
+ for (let i = 0, l = arr.length; i < l; i++) renderItem(arr[i], i);
193
+ } else {
194
+ const keys = Object.keys(source);
195
+ for (let i = 0, l = keys.length; i < l; i++) {
196
+ const key = keys[i];
197
+ renderItem(source[key], key, i);
198
+ }
199
+ }
242
200
  }
243
201
 
202
+ //#endregion
203
+ //#region packages/server-renderer/src/helpers/ssrRenderSuspense.ts
244
204
  async function ssrRenderSuspense(push, { default: renderContent }) {
245
- if (renderContent) {
246
- renderContent();
247
- } else {
248
- push(`<!---->`);
249
- }
205
+ if (renderContent) renderContent();
206
+ else push(`<!---->`);
250
207
  }
251
208
 
209
+ //#endregion
210
+ //#region packages/server-renderer/src/helpers/ssrGetDirectiveProps.ts
252
211
  function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
253
- if (typeof dir !== "function" && dir.getSSRProps) {
254
- return dir.getSSRProps(
255
- {
256
- dir,
257
- instance: Vue.ssrUtils.getComponentPublicInstance(instance.$),
258
- value,
259
- oldValue: void 0,
260
- arg,
261
- modifiers
262
- },
263
- null
264
- ) || {};
265
- }
266
- return {};
212
+ if (typeof dir !== "function" && dir.getSSRProps) return dir.getSSRProps({
213
+ dir,
214
+ instance: vue.ssrUtils.getComponentPublicInstance(instance.$),
215
+ value,
216
+ oldValue: void 0,
217
+ arg,
218
+ modifiers
219
+ }, null) || {};
220
+ return {};
267
221
  }
268
222
 
269
- const ssrLooseEqual = shared.looseEqual;
223
+ //#endregion
224
+ //#region packages/server-renderer/src/helpers/ssrVModelHelpers.ts
225
+ const ssrLooseEqual = _vue_shared.looseEqual;
270
226
  function ssrLooseContain(arr, value) {
271
- return shared.looseIndexOf(arr, value) > -1;
227
+ return (0, _vue_shared.looseIndexOf)(arr, value) > -1;
272
228
  }
273
229
  function ssrRenderDynamicModel(type, model, value) {
274
- switch (type) {
275
- case "radio":
276
- return shared.looseEqual(model, value) ? " checked" : "";
277
- case "checkbox":
278
- return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? " checked" : "";
279
- default:
280
- return ssrRenderAttr("value", model);
281
- }
230
+ switch (type) {
231
+ case "radio": return (0, _vue_shared.looseEqual)(model, value) ? " checked" : "";
232
+ case "checkbox": return ((0, _vue_shared.isArray)(model) ? ssrLooseContain(model, value) : model) ? " checked" : "";
233
+ default: return ssrRenderAttr("value", model);
234
+ }
282
235
  }
283
236
  function ssrGetDynamicModelProps(existingProps = {}, model) {
284
- const { type, value } = existingProps;
285
- switch (type) {
286
- case "radio":
287
- return shared.looseEqual(model, value) ? { checked: true } : null;
288
- case "checkbox":
289
- return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
290
- default:
291
- return { value: model };
292
- }
237
+ const { type, value } = existingProps;
238
+ switch (type) {
239
+ case "radio": return (0, _vue_shared.looseEqual)(model, value) ? { checked: true } : null;
240
+ case "checkbox": return ((0, _vue_shared.isArray)(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
241
+ default: return { value: model };
242
+ }
293
243
  }
294
244
 
295
- var helpers = /*#__PURE__*/Object.freeze({
296
- __proto__: null,
297
- ssrGetDirectiveProps: ssrGetDirectiveProps,
298
- ssrGetDynamicModelProps: ssrGetDynamicModelProps,
299
- ssrIncludeBooleanAttr: shared.includeBooleanAttr,
300
- ssrInterpolate: ssrInterpolate,
301
- ssrLooseContain: ssrLooseContain,
302
- ssrLooseEqual: ssrLooseEqual,
303
- ssrRenderAttr: ssrRenderAttr,
304
- ssrRenderAttrs: ssrRenderAttrs,
305
- ssrRenderClass: ssrRenderClass,
306
- ssrRenderComponent: ssrRenderComponent,
307
- ssrRenderDynamicAttr: ssrRenderDynamicAttr,
308
- ssrRenderDynamicModel: ssrRenderDynamicModel,
309
- ssrRenderList: ssrRenderList,
310
- ssrRenderSlot: ssrRenderSlot,
311
- ssrRenderSlotInner: ssrRenderSlotInner,
312
- ssrRenderStyle: ssrRenderStyle,
313
- ssrRenderSuspense: ssrRenderSuspense,
314
- ssrRenderTeleport: ssrRenderTeleport,
315
- ssrRenderVNode: renderVNode
245
+ //#endregion
246
+ //#region packages/server-renderer/src/internal.ts
247
+ var internal_exports = /* @__PURE__ */ __exportAll({
248
+ ssrGetDirectiveProps: () => ssrGetDirectiveProps,
249
+ ssrGetDynamicModelProps: () => ssrGetDynamicModelProps,
250
+ ssrIncludeBooleanAttr: () => _vue_shared.includeBooleanAttr,
251
+ ssrInterpolate: () => ssrInterpolate,
252
+ ssrLooseContain: () => ssrLooseContain,
253
+ ssrLooseEqual: () => ssrLooseEqual,
254
+ ssrRenderAttr: () => ssrRenderAttr,
255
+ ssrRenderAttrs: () => ssrRenderAttrs,
256
+ ssrRenderClass: () => ssrRenderClass,
257
+ ssrRenderComponent: () => ssrRenderComponent,
258
+ ssrRenderDynamicAttr: () => ssrRenderDynamicAttr,
259
+ ssrRenderDynamicModel: () => ssrRenderDynamicModel,
260
+ ssrRenderList: () => ssrRenderList,
261
+ ssrRenderSlot: () => ssrRenderSlot,
262
+ ssrRenderSlotInner: () => ssrRenderSlotInner,
263
+ ssrRenderStyle: () => ssrRenderStyle,
264
+ ssrRenderSuspense: () => ssrRenderSuspense,
265
+ ssrRenderTeleport: () => ssrRenderTeleport,
266
+ ssrRenderVNode: () => renderVNode
316
267
  });
317
268
 
318
- const compileCache = /* @__PURE__ */ Object.create(null);
269
+ //#endregion
270
+ //#region packages/server-renderer/src/helpers/ssrCompile.ts
271
+ const compileCache = Object.create(null);
319
272
  function ssrCompile(template, instance) {
320
- const Component = instance.type;
321
- const { isCustomElement, compilerOptions } = instance.appContext.config;
322
- const { delimiters, compilerOptions: componentCompilerOptions } = Component;
323
- const finalCompilerOptions = shared.extend(
324
- shared.extend(
325
- {
326
- isCustomElement,
327
- delimiters
328
- },
329
- compilerOptions
330
- ),
331
- componentCompilerOptions
332
- );
333
- finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || shared.NO;
334
- finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || shared.NO;
335
- const cacheKey = JSON.stringify(
336
- {
337
- template,
338
- compilerOptions: finalCompilerOptions
339
- },
340
- (key, value) => {
341
- return shared.isFunction(value) ? value.toString() : value;
342
- }
343
- );
344
- const cached = compileCache[cacheKey];
345
- if (cached) {
346
- return cached;
347
- }
348
- finalCompilerOptions.onError = (err) => {
349
- {
350
- throw err;
351
- }
352
- };
353
- const { code } = compilerSsr.compile(template, finalCompilerOptions);
354
- const requireMap = {
355
- vue: Vue__namespace,
356
- "vue/server-renderer": helpers
357
- };
358
- const fakeRequire = (id) => requireMap[id];
359
- return compileCache[cacheKey] = Function("require", code)(fakeRequire);
273
+ const Component = instance.type;
274
+ const { isCustomElement, compilerOptions } = instance.appContext.config;
275
+ const { delimiters, compilerOptions: componentCompilerOptions } = Component;
276
+ const finalCompilerOptions = (0, _vue_shared.extend)((0, _vue_shared.extend)({
277
+ isCustomElement,
278
+ delimiters
279
+ }, compilerOptions), componentCompilerOptions);
280
+ finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || _vue_shared.NO;
281
+ finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || _vue_shared.NO;
282
+ const cacheKey = JSON.stringify({
283
+ template,
284
+ compilerOptions: finalCompilerOptions
285
+ }, (key, value) => {
286
+ return (0, _vue_shared.isFunction)(value) ? value.toString() : value;
287
+ });
288
+ const cached = compileCache[cacheKey];
289
+ if (cached) return cached;
290
+ finalCompilerOptions.onError = (err) => {
291
+ throw err;
292
+ };
293
+ const { code } = (0, _vue_compiler_ssr.compile)(template, finalCompilerOptions);
294
+ const requireMap = {
295
+ vue,
296
+ "vue/server-renderer": internal_exports
297
+ };
298
+ const fakeRequire = (id) => requireMap[id];
299
+ return compileCache[cacheKey] = Function("require", code)(fakeRequire);
360
300
  }
361
301
 
362
- const {
363
- createComponentInstance,
364
- setCurrentRenderingInstance,
365
- setupComponent,
366
- renderComponentRoot,
367
- normalizeVNode,
368
- pushWarningContext,
369
- popWarningContext
370
- } = Vue.ssrUtils;
302
+ //#endregion
303
+ //#region packages/server-renderer/src/render.ts
304
+ const { createComponentInstance, setCurrentRenderingInstance, setupComponent, renderComponentRoot, normalizeVNode, pushWarningContext, popWarningContext } = vue.ssrUtils;
371
305
  function createBuffer() {
372
- let appendable = false;
373
- const buffer = [];
374
- return {
375
- getBuffer() {
376
- return buffer;
377
- },
378
- push(item) {
379
- const isStringItem = shared.isString(item);
380
- if (appendable && isStringItem) {
381
- buffer[buffer.length - 1] += item;
382
- return;
383
- }
384
- buffer.push(item);
385
- appendable = isStringItem;
386
- if (shared.isPromise(item) || shared.isArray(item) && item.hasAsync) {
387
- buffer.hasAsync = true;
388
- }
389
- }
390
- };
306
+ let appendable = false;
307
+ const buffer = [];
308
+ return {
309
+ getBuffer() {
310
+ return buffer;
311
+ },
312
+ push(item) {
313
+ const isStringItem = (0, _vue_shared.isString)(item);
314
+ if (appendable && isStringItem) {
315
+ buffer[buffer.length - 1] += item;
316
+ return;
317
+ }
318
+ buffer.push(item);
319
+ appendable = isStringItem;
320
+ if ((0, _vue_shared.isPromise)(item) || (0, _vue_shared.isArray)(item) && item.hasAsync) buffer.hasAsync = true;
321
+ }
322
+ };
391
323
  }
392
324
  function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
393
- const instance = vnode.component = createComponentInstance(
394
- vnode,
395
- parentComponent,
396
- null
397
- );
398
- const res = setupComponent(
399
- instance,
400
- true
401
- /* isSSR */
402
- );
403
- const hasAsyncSetup = shared.isPromise(res);
404
- let prefetches = instance.sp;
405
- if (hasAsyncSetup || prefetches) {
406
- const p = Promise.resolve(res).then(() => {
407
- if (hasAsyncSetup) prefetches = instance.sp;
408
- if (prefetches) {
409
- return Promise.all(
410
- prefetches.map((prefetch) => prefetch.call(instance.proxy))
411
- );
412
- }
413
- }).catch(shared.NOOP);
414
- return p.then(() => renderComponentSubTree(instance, slotScopeId));
415
- } else {
416
- return renderComponentSubTree(instance, slotScopeId);
417
- }
325
+ const instance = vnode.component = createComponentInstance(vnode, parentComponent, null);
326
+ const res = setupComponent(instance, true);
327
+ const hasAsyncSetup = (0, _vue_shared.isPromise)(res);
328
+ let prefetches = instance.sp;
329
+ if (hasAsyncSetup || prefetches) return Promise.resolve(res).then(() => {
330
+ if (hasAsyncSetup) prefetches = instance.sp;
331
+ if (prefetches) return Promise.all(prefetches.map((prefetch) => prefetch.call(instance.proxy)));
332
+ }).catch(_vue_shared.NOOP).then(() => renderComponentSubTree(instance, slotScopeId));
333
+ else return renderComponentSubTree(instance, slotScopeId);
418
334
  }
419
335
  function renderComponentSubTree(instance, slotScopeId) {
420
- const comp = instance.type;
421
- const { getBuffer, push } = createBuffer();
422
- if (shared.isFunction(comp)) {
423
- let root = renderComponentRoot(instance);
424
- if (!comp.props) {
425
- for (const key in instance.attrs) {
426
- if (key.startsWith(`data-v-`)) {
427
- (root.props || (root.props = {}))[key] = ``;
428
- }
429
- }
430
- }
431
- renderVNode(push, instance.subTree = root, instance, slotScopeId);
432
- } else {
433
- if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) {
434
- comp.ssrRender = ssrCompile(comp.template, instance);
435
- }
436
- const ssrRender = instance.ssrRender || comp.ssrRender;
437
- if (ssrRender) {
438
- let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
439
- let hasCloned = false;
440
- let cur = instance;
441
- while (true) {
442
- const scopeId = cur.vnode.scopeId;
443
- if (scopeId) {
444
- if (!hasCloned) {
445
- attrs = { ...attrs };
446
- hasCloned = true;
447
- }
448
- attrs[scopeId] = "";
449
- }
450
- const parent = cur.parent;
451
- if (parent && parent.subTree && parent.subTree === cur.vnode) {
452
- cur = parent;
453
- } else {
454
- break;
455
- }
456
- }
457
- if (slotScopeId) {
458
- if (!hasCloned) attrs = { ...attrs };
459
- const slotScopeIdList = slotScopeId.trim().split(" ");
460
- for (let i = 0; i < slotScopeIdList.length; i++) {
461
- attrs[slotScopeIdList[i]] = "";
462
- }
463
- }
464
- const prev = setCurrentRenderingInstance(instance);
465
- try {
466
- ssrRender(
467
- instance.proxy,
468
- push,
469
- instance,
470
- attrs,
471
- // compiler-optimized bindings
472
- instance.props,
473
- instance.setupState,
474
- instance.data,
475
- instance.ctx
476
- );
477
- } finally {
478
- setCurrentRenderingInstance(prev);
479
- }
480
- } else if (instance.render && instance.render !== shared.NOOP) {
481
- renderVNode(
482
- push,
483
- instance.subTree = renderComponentRoot(instance),
484
- instance,
485
- slotScopeId
486
- );
487
- } else {
488
- const componentName = comp.name || comp.__file || `<Anonymous>`;
489
- Vue.warn(`Component ${componentName} is missing template or render function.`);
490
- push(`<!---->`);
491
- }
492
- }
493
- return getBuffer();
336
+ const comp = instance.type;
337
+ const { getBuffer, push } = createBuffer();
338
+ if ((0, _vue_shared.isFunction)(comp)) {
339
+ let root = renderComponentRoot(instance);
340
+ if (!comp.props) {
341
+ for (const key in instance.attrs) if (key.startsWith(`data-v-`)) (root.props || (root.props = {}))[key] = ``;
342
+ }
343
+ renderVNode(push, instance.subTree = root, instance, slotScopeId);
344
+ } else {
345
+ if ((!instance.render || instance.render === _vue_shared.NOOP) && !instance.ssrRender && !comp.ssrRender && (0, _vue_shared.isString)(comp.template)) comp.ssrRender = ssrCompile(comp.template, instance);
346
+ const ssrRender = instance.ssrRender || comp.ssrRender;
347
+ if (ssrRender) {
348
+ let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
349
+ let hasCloned = false;
350
+ let cur = instance;
351
+ while (true) {
352
+ const scopeId = cur.vnode.scopeId;
353
+ if (scopeId) {
354
+ if (!hasCloned) {
355
+ attrs = { ...attrs };
356
+ hasCloned = true;
357
+ }
358
+ attrs[scopeId] = "";
359
+ }
360
+ const parent = cur.parent;
361
+ if (parent && parent.subTree && parent.subTree === cur.vnode) cur = parent;
362
+ else break;
363
+ }
364
+ if (slotScopeId) {
365
+ if (!hasCloned) attrs = { ...attrs };
366
+ const slotScopeIdList = slotScopeId.trim().split(" ");
367
+ for (let i = 0; i < slotScopeIdList.length; i++) attrs[slotScopeIdList[i]] = "";
368
+ }
369
+ const prev = setCurrentRenderingInstance(instance);
370
+ try {
371
+ ssrRender(instance.proxy, push, instance, attrs, instance.props, instance.setupState, instance.data, instance.ctx);
372
+ } finally {
373
+ setCurrentRenderingInstance(prev);
374
+ }
375
+ } else if (instance.render && instance.render !== _vue_shared.NOOP) renderVNode(push, instance.subTree = renderComponentRoot(instance), instance, slotScopeId);
376
+ else {
377
+ (0, vue.warn)(`Component ${comp.name || comp.__file || `<Anonymous>`} is missing template or render function.`);
378
+ push(`<!---->`);
379
+ }
380
+ }
381
+ return getBuffer();
494
382
  }
495
383
  function renderVNode(push, vnode, parentComponent, slotScopeId) {
496
- const { type, shapeFlag, children, dirs, props } = vnode;
497
- if (dirs) {
498
- vnode.props = applySSRDirectives(vnode, props, dirs);
499
- }
500
- switch (type) {
501
- case Vue.Text:
502
- push(shared.escapeHtml(children));
503
- break;
504
- case Vue.Comment:
505
- push(
506
- children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->`
507
- );
508
- break;
509
- case Vue.Static:
510
- push(children);
511
- break;
512
- case Vue.Fragment:
513
- if (vnode.slotScopeIds) {
514
- slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
515
- }
516
- push(`<!--[-->`);
517
- renderVNodeChildren(
518
- push,
519
- children,
520
- parentComponent,
521
- slotScopeId
522
- );
523
- push(`<!--]-->`);
524
- break;
525
- default:
526
- if (shapeFlag & 1) {
527
- renderElementVNode(push, vnode, parentComponent, slotScopeId);
528
- } else if (shapeFlag & 6) {
529
- push(renderComponentVNode(vnode, parentComponent, slotScopeId));
530
- } else if (shapeFlag & 64) {
531
- renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
532
- } else if (shapeFlag & 128) {
533
- renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
534
- } else {
535
- Vue.warn(
536
- "[@vue/server-renderer] Invalid VNode type:",
537
- type,
538
- `(${typeof type})`
539
- );
540
- }
541
- }
384
+ const { type, shapeFlag, children, dirs, props } = vnode;
385
+ if (dirs) vnode.props = applySSRDirectives(vnode, props, dirs);
386
+ switch (type) {
387
+ case vue.Text:
388
+ push((0, _vue_shared.escapeHtml)(children));
389
+ break;
390
+ case vue.Comment:
391
+ push(children ? `<!--${(0, _vue_shared.escapeHtmlComment)(children)}-->` : `<!---->`);
392
+ break;
393
+ case vue.Static:
394
+ push(children);
395
+ break;
396
+ case vue.Fragment:
397
+ if (vnode.slotScopeIds) slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
398
+ push(`<!--[-->`);
399
+ renderVNodeChildren(push, children, parentComponent, slotScopeId);
400
+ push(`<!--]-->`);
401
+ break;
402
+ default: if (shapeFlag & 1) renderElementVNode(push, vnode, parentComponent, slotScopeId);
403
+ else if (shapeFlag & 6) push(renderComponentVNode(vnode, parentComponent, slotScopeId));
404
+ else if (shapeFlag & 64) renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
405
+ else if (shapeFlag & 128) renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
406
+ else (0, vue.warn)("[@vue/server-renderer] Invalid VNode type:", type, `(${typeof type})`);
407
+ }
542
408
  }
543
409
  function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
544
- for (let i = 0; i < children.length; i++) {
545
- renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
546
- }
410
+ for (let i = 0; i < children.length; i++) renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
547
411
  }
548
412
  function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
549
- const tag = vnode.type;
550
- let { props, children, shapeFlag, scopeId } = vnode;
551
- let openTag = `<${tag}`;
552
- if (props) {
553
- openTag += ssrRenderAttrs(props, tag);
554
- }
555
- if (scopeId) {
556
- openTag += ` ${scopeId}`;
557
- }
558
- let curParent = parentComponent;
559
- let curVnode = vnode;
560
- while (curParent && curVnode === curParent.subTree) {
561
- curVnode = curParent.vnode;
562
- if (curVnode.scopeId) {
563
- openTag += ` ${curVnode.scopeId}`;
564
- }
565
- curParent = curParent.parent;
566
- }
567
- if (slotScopeId) {
568
- openTag += ` ${slotScopeId}`;
569
- }
570
- push(openTag + `>`);
571
- if (!shared.isVoidTag(tag)) {
572
- let hasChildrenOverride = false;
573
- if (props) {
574
- if (props.innerHTML) {
575
- hasChildrenOverride = true;
576
- push(props.innerHTML);
577
- } else if (props.textContent) {
578
- hasChildrenOverride = true;
579
- push(shared.escapeHtml(props.textContent));
580
- } else if (tag === "textarea" && props.value) {
581
- hasChildrenOverride = true;
582
- push(shared.escapeHtml(props.value));
583
- }
584
- }
585
- if (!hasChildrenOverride) {
586
- if (shapeFlag & 8) {
587
- push(shared.escapeHtml(children));
588
- } else if (shapeFlag & 16) {
589
- renderVNodeChildren(
590
- push,
591
- children,
592
- parentComponent,
593
- slotScopeId
594
- );
595
- }
596
- }
597
- push(`</${tag}>`);
598
- }
413
+ const tag = vnode.type;
414
+ let { props, children, shapeFlag, scopeId } = vnode;
415
+ let openTag = `<${tag}`;
416
+ if (props) openTag += ssrRenderAttrs(props, tag);
417
+ if (scopeId) openTag += ` ${scopeId}`;
418
+ let curParent = parentComponent;
419
+ let curVnode = vnode;
420
+ while (curParent && curVnode === curParent.subTree) {
421
+ curVnode = curParent.vnode;
422
+ if (curVnode.scopeId) openTag += ` ${curVnode.scopeId}`;
423
+ curParent = curParent.parent;
424
+ }
425
+ if (slotScopeId) openTag += ` ${slotScopeId}`;
426
+ push(openTag + `>`);
427
+ if (!(0, _vue_shared.isVoidTag)(tag)) {
428
+ let hasChildrenOverride = false;
429
+ if (props) {
430
+ if (props.innerHTML) {
431
+ hasChildrenOverride = true;
432
+ push(props.innerHTML);
433
+ } else if (props.textContent) {
434
+ hasChildrenOverride = true;
435
+ push((0, _vue_shared.escapeHtml)(props.textContent));
436
+ } else if (tag === "textarea" && props.value) {
437
+ hasChildrenOverride = true;
438
+ push((0, _vue_shared.escapeHtml)(props.value));
439
+ }
440
+ }
441
+ if (!hasChildrenOverride) {
442
+ if (shapeFlag & 8) push((0, _vue_shared.escapeHtml)(children));
443
+ else if (shapeFlag & 16) renderVNodeChildren(push, children, parentComponent, slotScopeId);
444
+ }
445
+ push(`</${tag}>`);
446
+ }
599
447
  }
600
448
  function applySSRDirectives(vnode, rawProps, dirs) {
601
- const toMerge = [];
602
- for (let i = 0; i < dirs.length; i++) {
603
- const binding = dirs[i];
604
- const {
605
- dir: { getSSRProps }
606
- } = binding;
607
- if (getSSRProps) {
608
- const props = getSSRProps(binding, vnode);
609
- if (props) toMerge.push(props);
610
- }
611
- }
612
- return Vue.mergeProps(rawProps || {}, ...toMerge);
449
+ const toMerge = [];
450
+ for (let i = 0; i < dirs.length; i++) {
451
+ const binding = dirs[i];
452
+ const { dir: { getSSRProps } } = binding;
453
+ if (getSSRProps) {
454
+ const props = getSSRProps(binding, vnode);
455
+ if (props) toMerge.push(props);
456
+ }
457
+ }
458
+ return (0, vue.mergeProps)(rawProps || {}, ...toMerge);
613
459
  }
614
460
  function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
615
- const target = vnode.props && vnode.props.to;
616
- const disabled = vnode.props && vnode.props.disabled;
617
- if (!target) {
618
- if (!disabled) {
619
- Vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
620
- }
621
- return [];
622
- }
623
- if (!shared.isString(target)) {
624
- Vue.warn(
625
- `[@vue/server-renderer] Teleport target must be a query selector string.`
626
- );
627
- return [];
628
- }
629
- ssrRenderTeleport(
630
- push,
631
- (push2) => {
632
- renderVNodeChildren(
633
- push2,
634
- vnode.children,
635
- parentComponent,
636
- slotScopeId
637
- );
638
- },
639
- target,
640
- disabled || disabled === "",
641
- parentComponent
642
- );
461
+ const target = vnode.props && vnode.props.to;
462
+ const disabled = vnode.props && vnode.props.disabled;
463
+ if (!target) {
464
+ if (!disabled) (0, vue.warn)(`[@vue/server-renderer] Teleport is missing target prop.`);
465
+ return [];
466
+ }
467
+ if (!(0, _vue_shared.isString)(target)) {
468
+ (0, vue.warn)(`[@vue/server-renderer] Teleport target must be a query selector string.`);
469
+ return [];
470
+ }
471
+ ssrRenderTeleport(push, (push) => {
472
+ renderVNodeChildren(push, vnode.children, parentComponent, slotScopeId);
473
+ }, target, disabled || disabled === "", parentComponent);
643
474
  }
644
475
 
645
- const { isVNode: isVNode$1 } = Vue.ssrUtils;
476
+ //#endregion
477
+ //#region packages/server-renderer/src/renderToString.ts
478
+ const { isVNode: isVNode$1 } = vue.ssrUtils;
646
479
  function nestedUnrollBuffer(buffer, parentRet, startIndex) {
647
- if (!buffer.hasAsync) {
648
- return parentRet + unrollBufferSync$1(buffer);
649
- }
650
- let ret = parentRet;
651
- for (let i = startIndex; i < buffer.length; i += 1) {
652
- const item = buffer[i];
653
- if (shared.isString(item)) {
654
- ret += item;
655
- continue;
656
- }
657
- if (shared.isPromise(item)) {
658
- return item.then((nestedItem) => {
659
- buffer[i] = nestedItem;
660
- return nestedUnrollBuffer(buffer, ret, i);
661
- });
662
- }
663
- const result = nestedUnrollBuffer(item, ret, 0);
664
- if (shared.isPromise(result)) {
665
- return result.then((nestedItem) => {
666
- buffer[i] = nestedItem;
667
- return nestedUnrollBuffer(buffer, "", i);
668
- });
669
- }
670
- ret = result;
671
- }
672
- return ret;
480
+ if (!buffer.hasAsync) return parentRet + unrollBufferSync$1(buffer);
481
+ let ret = parentRet;
482
+ for (let i = startIndex; i < buffer.length; i += 1) {
483
+ const item = buffer[i];
484
+ if ((0, _vue_shared.isString)(item)) {
485
+ ret += item;
486
+ continue;
487
+ }
488
+ if ((0, _vue_shared.isPromise)(item)) return item.then((nestedItem) => {
489
+ buffer[i] = nestedItem;
490
+ return nestedUnrollBuffer(buffer, ret, i);
491
+ });
492
+ const result = nestedUnrollBuffer(item, ret, 0);
493
+ if ((0, _vue_shared.isPromise)(result)) return result.then((nestedItem) => {
494
+ buffer[i] = nestedItem;
495
+ return nestedUnrollBuffer(buffer, "", i);
496
+ });
497
+ ret = result;
498
+ }
499
+ return ret;
673
500
  }
674
501
  function unrollBuffer$1(buffer) {
675
- return nestedUnrollBuffer(buffer, "", 0);
502
+ return nestedUnrollBuffer(buffer, "", 0);
676
503
  }
677
504
  function unrollBufferSync$1(buffer) {
678
- let ret = "";
679
- for (let i = 0; i < buffer.length; i++) {
680
- let item = buffer[i];
681
- if (shared.isString(item)) {
682
- ret += item;
683
- } else {
684
- ret += unrollBufferSync$1(item);
685
- }
686
- }
687
- return ret;
505
+ let ret = "";
506
+ for (let i = 0; i < buffer.length; i++) {
507
+ let item = buffer[i];
508
+ if ((0, _vue_shared.isString)(item)) ret += item;
509
+ else ret += unrollBufferSync$1(item);
510
+ }
511
+ return ret;
688
512
  }
689
513
  async function renderToString(input, context = {}) {
690
- if (isVNode$1(input)) {
691
- return renderToString(Vue.createApp({ render: () => input }), context);
692
- }
693
- const vnode = Vue.createVNode(input._component, input._props);
694
- vnode.appContext = input._context;
695
- input.provide(Vue.ssrContextKey, context);
696
- const buffer = await renderComponentVNode(vnode);
697
- const result = await unrollBuffer$1(buffer);
698
- await resolveTeleports(context);
699
- if (context.__watcherHandles) {
700
- for (const unwatch of context.__watcherHandles) {
701
- unwatch();
702
- }
703
- }
704
- return result;
514
+ if (isVNode$1(input)) return renderToString((0, vue.createApp)({ render: () => input }), context);
515
+ const vnode = (0, vue.createVNode)(input._component, input._props);
516
+ vnode.appContext = input._context;
517
+ input.provide(vue.ssrContextKey, context);
518
+ const result = await unrollBuffer$1(await renderComponentVNode(vnode));
519
+ await resolveTeleports(context);
520
+ if (context.__watcherHandles) for (const unwatch of context.__watcherHandles) unwatch();
521
+ return result;
705
522
  }
706
523
  async function resolveTeleports(context) {
707
- if (context.__teleportBuffers) {
708
- context.teleports = context.teleports || {};
709
- for (const key in context.__teleportBuffers) {
710
- context.teleports[key] = await unrollBuffer$1(
711
- await Promise.all([context.__teleportBuffers[key]])
712
- );
713
- }
714
- }
524
+ if (context.__teleportBuffers) {
525
+ context.teleports = context.teleports || {};
526
+ for (const key in context.__teleportBuffers) context.teleports[key] = await unrollBuffer$1(await Promise.all([context.__teleportBuffers[key]]));
527
+ }
715
528
  }
716
529
 
717
- const { isVNode } = Vue.ssrUtils;
530
+ //#endregion
531
+ //#region packages/server-renderer/src/renderToStream.ts
532
+ const { isVNode } = vue.ssrUtils;
718
533
  async function unrollBuffer(buffer, stream) {
719
- if (buffer.hasAsync) {
720
- for (let i = 0; i < buffer.length; i++) {
721
- let item = buffer[i];
722
- if (shared.isPromise(item)) {
723
- item = await item;
724
- }
725
- if (shared.isString(item)) {
726
- stream.push(item);
727
- } else {
728
- await unrollBuffer(item, stream);
729
- }
730
- }
731
- } else {
732
- unrollBufferSync(buffer, stream);
733
- }
534
+ if (buffer.hasAsync) for (let i = 0; i < buffer.length; i++) {
535
+ let item = buffer[i];
536
+ if ((0, _vue_shared.isPromise)(item)) item = await item;
537
+ if ((0, _vue_shared.isString)(item)) stream.push(item);
538
+ else await unrollBuffer(item, stream);
539
+ }
540
+ else unrollBufferSync(buffer, stream);
734
541
  }
735
542
  function unrollBufferSync(buffer, stream) {
736
- for (let i = 0; i < buffer.length; i++) {
737
- let item = buffer[i];
738
- if (shared.isString(item)) {
739
- stream.push(item);
740
- } else {
741
- unrollBufferSync(item, stream);
742
- }
743
- }
543
+ for (let i = 0; i < buffer.length; i++) {
544
+ let item = buffer[i];
545
+ if ((0, _vue_shared.isString)(item)) stream.push(item);
546
+ else unrollBufferSync(item, stream);
547
+ }
744
548
  }
745
549
  function renderToSimpleStream(input, context, stream) {
746
- if (isVNode(input)) {
747
- return renderToSimpleStream(
748
- Vue.createApp({ render: () => input }),
749
- context,
750
- stream
751
- );
752
- }
753
- const vnode = Vue.createVNode(input._component, input._props);
754
- vnode.appContext = input._context;
755
- input.provide(Vue.ssrContextKey, context);
756
- Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => {
757
- if (context.__watcherHandles) {
758
- for (const unwatch of context.__watcherHandles) {
759
- unwatch();
760
- }
761
- }
762
- }).then(() => stream.push(null)).catch((error) => {
763
- stream.destroy(error);
764
- });
765
- return stream;
550
+ if (isVNode(input)) return renderToSimpleStream((0, vue.createApp)({ render: () => input }), context, stream);
551
+ const vnode = (0, vue.createVNode)(input._component, input._props);
552
+ vnode.appContext = input._context;
553
+ input.provide(vue.ssrContextKey, context);
554
+ Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => {
555
+ if (context.__watcherHandles) for (const unwatch of context.__watcherHandles) unwatch();
556
+ }).then(() => stream.push(null)).catch((error) => {
557
+ stream.destroy(error);
558
+ });
559
+ return stream;
766
560
  }
561
+ /**
562
+ * @deprecated
563
+ */
767
564
  function renderToStream(input, context = {}) {
768
- console.warn(
769
- `[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.`
770
- );
771
- return renderToNodeStream(input, context);
565
+ console.warn(`[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.`);
566
+ return renderToNodeStream(input, context);
772
567
  }
773
568
  function renderToNodeStream(input, context = {}) {
774
- const stream = new (require("node:stream")).Readable({ read() {
775
- } }) ;
776
- if (!stream) {
777
- throw new Error(
778
- `ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.`
779
- );
780
- }
781
- return renderToSimpleStream(input, context, stream);
569
+ const stream = new (require("node:stream")).Readable({ read() {} });
570
+ if (!stream) throw new Error("ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.");
571
+ return renderToSimpleStream(input, context, stream);
782
572
  }
783
573
  function pipeToNodeWritable(input, context = {}, writable) {
784
- renderToSimpleStream(input, context, {
785
- push(content) {
786
- if (content != null) {
787
- writable.write(content);
788
- } else {
789
- writable.end();
790
- }
791
- },
792
- destroy(err) {
793
- writable.destroy(err);
794
- }
795
- });
574
+ renderToSimpleStream(input, context, {
575
+ push(content) {
576
+ if (content != null) writable.write(content);
577
+ else writable.end();
578
+ },
579
+ destroy(err) {
580
+ writable.destroy(err);
581
+ }
582
+ });
796
583
  }
797
584
  function renderToWebStream(input, context = {}) {
798
- if (typeof ReadableStream !== "function") {
799
- throw new Error(
800
- `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.`
801
- );
802
- }
803
- const encoder = new TextEncoder();
804
- let cancelled = false;
805
- return new ReadableStream({
806
- start(controller) {
807
- renderToSimpleStream(input, context, {
808
- push(content) {
809
- if (cancelled) return;
810
- if (content != null) {
811
- controller.enqueue(encoder.encode(content));
812
- } else {
813
- controller.close();
814
- }
815
- },
816
- destroy(err) {
817
- controller.error(err);
818
- }
819
- });
820
- },
821
- cancel() {
822
- cancelled = true;
823
- }
824
- });
585
+ 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.");
586
+ const encoder = new TextEncoder();
587
+ let cancelled = false;
588
+ return new ReadableStream({
589
+ start(controller) {
590
+ renderToSimpleStream(input, context, {
591
+ push(content) {
592
+ if (cancelled) return;
593
+ if (content != null) controller.enqueue(encoder.encode(content));
594
+ else controller.close();
595
+ },
596
+ destroy(err) {
597
+ controller.error(err);
598
+ }
599
+ });
600
+ },
601
+ cancel() {
602
+ cancelled = true;
603
+ }
604
+ });
825
605
  }
826
606
  function pipeToWebWritable(input, context = {}, writable) {
827
- const writer = writable.getWriter();
828
- const encoder = new TextEncoder();
829
- let hasReady = false;
830
- try {
831
- hasReady = shared.isPromise(writer.ready);
832
- } catch (e) {
833
- }
834
- renderToSimpleStream(input, context, {
835
- async push(content) {
836
- if (hasReady) {
837
- await writer.ready;
838
- }
839
- if (content != null) {
840
- return writer.write(encoder.encode(content));
841
- } else {
842
- return writer.close();
843
- }
844
- },
845
- destroy(err) {
846
- console.log(err);
847
- writer.close();
848
- }
849
- });
607
+ const writer = writable.getWriter();
608
+ const encoder = new TextEncoder();
609
+ let hasReady = false;
610
+ try {
611
+ hasReady = (0, _vue_shared.isPromise)(writer.ready);
612
+ } catch (e) {}
613
+ renderToSimpleStream(input, context, {
614
+ async push(content) {
615
+ if (hasReady) await writer.ready;
616
+ if (content != null) return writer.write(encoder.encode(content));
617
+ else return writer.close();
618
+ },
619
+ destroy(err) {
620
+ console.log(err);
621
+ writer.close();
622
+ }
623
+ });
850
624
  }
851
625
 
852
- Vue.initDirectivesForSSR();
626
+ //#endregion
627
+ //#region packages/server-renderer/src/index.ts
628
+ (0, vue.initDirectivesForSSR)();
853
629
 
854
- exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr;
630
+ //#endregion
855
631
  exports.pipeToNodeWritable = pipeToNodeWritable;
856
632
  exports.pipeToWebWritable = pipeToWebWritable;
857
633
  exports.renderToNodeStream = renderToNodeStream;
@@ -861,6 +637,7 @@ exports.renderToString = renderToString;
861
637
  exports.renderToWebStream = renderToWebStream;
862
638
  exports.ssrGetDirectiveProps = ssrGetDirectiveProps;
863
639
  exports.ssrGetDynamicModelProps = ssrGetDynamicModelProps;
640
+ exports.ssrIncludeBooleanAttr = _vue_shared.includeBooleanAttr;
864
641
  exports.ssrInterpolate = ssrInterpolate;
865
642
  exports.ssrLooseContain = ssrLooseContain;
866
643
  exports.ssrLooseEqual = ssrLooseEqual;
@@ -876,4 +653,4 @@ exports.ssrRenderSlotInner = ssrRenderSlotInner;
876
653
  exports.ssrRenderStyle = ssrRenderStyle;
877
654
  exports.ssrRenderSuspense = ssrRenderSuspense;
878
655
  exports.ssrRenderTeleport = ssrRenderTeleport;
879
- exports.ssrRenderVNode = renderVNode;
656
+ exports.ssrRenderVNode = renderVNode;