@vue/server-renderer 3.6.0-alpha.7 → 3.6.0-beta.10

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