@vue/compiler-ssr 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 (3) hide show
  1. package/dist/compiler-ssr.cjs.js +761 -1288
  2. package/dist/compiler-ssr.d.ts +3 -2
  3. package/package.json +3 -3
package/dist/compiler-ssr.cjs.js CHANGED
@@ -1,1400 +1,873 @@
1
1
  /**
2
- * @vue/compiler-ssr v3.6.0-beta.4
3
- * (c) 2018-present Yuxi (Evan) You and Vue contributors
4
- * @license MIT
5
- **/
6
- 'use strict';
2
+ * @vue/compiler-ssr 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
+ let _vue_compiler_dom = require("@vue/compiler-dom");
8
+ let _vue_shared = require("@vue/shared");
7
9
 
8
- Object.defineProperty(exports, '__esModule', { value: true });
9
-
10
- var compilerDom = require('@vue/compiler-dom');
11
- var shared = require('@vue/shared');
12
-
13
- const SSR_INTERPOLATE = /* @__PURE__ */ Symbol(`ssrInterpolate`);
14
- const SSR_RENDER_VNODE = /* @__PURE__ */ Symbol(`ssrRenderVNode`);
15
- const SSR_RENDER_COMPONENT = /* @__PURE__ */ Symbol(`ssrRenderComponent`);
16
- const SSR_RENDER_SLOT = /* @__PURE__ */ Symbol(`ssrRenderSlot`);
17
- const SSR_RENDER_SLOT_INNER = /* @__PURE__ */ Symbol(`ssrRenderSlotInner`);
18
- const SSR_RENDER_CLASS = /* @__PURE__ */ Symbol(`ssrRenderClass`);
19
- const SSR_RENDER_STYLE = /* @__PURE__ */ Symbol(`ssrRenderStyle`);
20
- const SSR_RENDER_ATTRS = /* @__PURE__ */ Symbol(`ssrRenderAttrs`);
21
- const SSR_RENDER_ATTR = /* @__PURE__ */ Symbol(`ssrRenderAttr`);
22
- const SSR_RENDER_DYNAMIC_ATTR = /* @__PURE__ */ Symbol(`ssrRenderDynamicAttr`);
23
- const SSR_RENDER_LIST = /* @__PURE__ */ Symbol(`ssrRenderList`);
24
- const SSR_INCLUDE_BOOLEAN_ATTR = /* @__PURE__ */ Symbol(
25
- `ssrIncludeBooleanAttr`
26
- );
27
- const SSR_LOOSE_EQUAL = /* @__PURE__ */ Symbol(`ssrLooseEqual`);
28
- const SSR_LOOSE_CONTAIN = /* @__PURE__ */ Symbol(`ssrLooseContain`);
29
- const SSR_RENDER_DYNAMIC_MODEL = /* @__PURE__ */ Symbol(
30
- `ssrRenderDynamicModel`
31
- );
32
- const SSR_GET_DYNAMIC_MODEL_PROPS = /* @__PURE__ */ Symbol(
33
- `ssrGetDynamicModelProps`
34
- );
35
- const SSR_RENDER_TELEPORT = /* @__PURE__ */ Symbol(`ssrRenderTeleport`);
36
- const SSR_RENDER_SUSPENSE = /* @__PURE__ */ Symbol(`ssrRenderSuspense`);
37
- const SSR_GET_DIRECTIVE_PROPS = /* @__PURE__ */ Symbol(`ssrGetDirectiveProps`);
10
+ //#region packages/compiler-ssr/src/runtimeHelpers.ts
11
+ const SSR_INTERPOLATE = Symbol(`ssrInterpolate`);
12
+ const SSR_RENDER_VNODE = Symbol(`ssrRenderVNode`);
13
+ const SSR_RENDER_COMPONENT = Symbol(`ssrRenderComponent`);
14
+ const SSR_RENDER_SLOT = Symbol(`ssrRenderSlot`);
15
+ const SSR_RENDER_SLOT_INNER = Symbol(`ssrRenderSlotInner`);
16
+ const SSR_RENDER_CLASS = Symbol(`ssrRenderClass`);
17
+ const SSR_RENDER_STYLE = Symbol(`ssrRenderStyle`);
18
+ const SSR_RENDER_ATTRS = Symbol(`ssrRenderAttrs`);
19
+ const SSR_RENDER_ATTR = Symbol(`ssrRenderAttr`);
20
+ const SSR_RENDER_DYNAMIC_ATTR = Symbol(`ssrRenderDynamicAttr`);
21
+ const SSR_RENDER_LIST = Symbol(`ssrRenderList`);
22
+ const SSR_INCLUDE_BOOLEAN_ATTR = Symbol(`ssrIncludeBooleanAttr`);
23
+ const SSR_LOOSE_EQUAL = Symbol(`ssrLooseEqual`);
24
+ const SSR_LOOSE_CONTAIN = Symbol(`ssrLooseContain`);
25
+ const SSR_RENDER_DYNAMIC_MODEL = Symbol(`ssrRenderDynamicModel`);
26
+ const SSR_GET_DYNAMIC_MODEL_PROPS = Symbol(`ssrGetDynamicModelProps`);
27
+ const SSR_RENDER_TELEPORT = Symbol(`ssrRenderTeleport`);
28
+ const SSR_RENDER_SUSPENSE = Symbol(`ssrRenderSuspense`);
29
+ const SSR_GET_DIRECTIVE_PROPS = Symbol(`ssrGetDirectiveProps`);
38
30
  const ssrHelpers = {
39
- [SSR_INTERPOLATE]: `ssrInterpolate`,
40
- [SSR_RENDER_VNODE]: `ssrRenderVNode`,
41
- [SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
42
- [SSR_RENDER_SLOT]: `ssrRenderSlot`,
43
- [SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
44
- [SSR_RENDER_CLASS]: `ssrRenderClass`,
45
- [SSR_RENDER_STYLE]: `ssrRenderStyle`,
46
- [SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
47
- [SSR_RENDER_ATTR]: `ssrRenderAttr`,
48
- [SSR_RENDER_DYNAMIC_ATTR]: `ssrRenderDynamicAttr`,
49
- [SSR_RENDER_LIST]: `ssrRenderList`,
50
- [SSR_INCLUDE_BOOLEAN_ATTR]: `ssrIncludeBooleanAttr`,
51
- [SSR_LOOSE_EQUAL]: `ssrLooseEqual`,
52
- [SSR_LOOSE_CONTAIN]: `ssrLooseContain`,
53
- [SSR_RENDER_DYNAMIC_MODEL]: `ssrRenderDynamicModel`,
54
- [SSR_GET_DYNAMIC_MODEL_PROPS]: `ssrGetDynamicModelProps`,
55
- [SSR_RENDER_TELEPORT]: `ssrRenderTeleport`,
56
- [SSR_RENDER_SUSPENSE]: `ssrRenderSuspense`,
57
- [SSR_GET_DIRECTIVE_PROPS]: `ssrGetDirectiveProps`
31
+ [SSR_INTERPOLATE]: `ssrInterpolate`,
32
+ [SSR_RENDER_VNODE]: `ssrRenderVNode`,
33
+ [SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
34
+ [SSR_RENDER_SLOT]: `ssrRenderSlot`,
35
+ [SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
36
+ [SSR_RENDER_CLASS]: `ssrRenderClass`,
37
+ [SSR_RENDER_STYLE]: `ssrRenderStyle`,
38
+ [SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
39
+ [SSR_RENDER_ATTR]: `ssrRenderAttr`,
40
+ [SSR_RENDER_DYNAMIC_ATTR]: `ssrRenderDynamicAttr`,
41
+ [SSR_RENDER_LIST]: `ssrRenderList`,
42
+ [SSR_INCLUDE_BOOLEAN_ATTR]: `ssrIncludeBooleanAttr`,
43
+ [SSR_LOOSE_EQUAL]: `ssrLooseEqual`,
44
+ [SSR_LOOSE_CONTAIN]: `ssrLooseContain`,
45
+ [SSR_RENDER_DYNAMIC_MODEL]: `ssrRenderDynamicModel`,
46
+ [SSR_GET_DYNAMIC_MODEL_PROPS]: `ssrGetDynamicModelProps`,
47
+ [SSR_RENDER_TELEPORT]: `ssrRenderTeleport`,
48
+ [SSR_RENDER_SUSPENSE]: `ssrRenderSuspense`,
49
+ [SSR_GET_DIRECTIVE_PROPS]: `ssrGetDirectiveProps`
58
50
  };
59
- compilerDom.registerRuntimeHelpers(ssrHelpers);
51
+ (0, _vue_compiler_dom.registerRuntimeHelpers)(ssrHelpers);
60
52
 
61
- const ssrTransformIf = compilerDom.createStructuralDirectiveTransform(
62
- /^(?:if|else|else-if)$/,
63
- compilerDom.processIf
64
- );
53
+ //#endregion
54
+ //#region packages/compiler-ssr/src/transforms/ssrVIf.ts
55
+ const ssrTransformIf = (0, _vue_compiler_dom.createStructuralDirectiveTransform)(/^(?:if|else|else-if)$/, _vue_compiler_dom.processIf);
65
56
  function ssrProcessIf(node, context, disableNestedFragments = false, disableComment = false) {
66
- const [rootBranch] = node.branches;
67
- const ifStatement = compilerDom.createIfStatement(
68
- rootBranch.condition,
69
- processIfBranch(rootBranch, context, disableNestedFragments)
70
- );
71
- context.pushStatement(ifStatement);
72
- let currentIf = ifStatement;
73
- for (let i = 1; i < node.branches.length; i++) {
74
- const branch = node.branches[i];
75
- const branchBlockStatement = processIfBranch(
76
- branch,
77
- context,
78
- disableNestedFragments
79
- );
80
- if (branch.condition) {
81
- currentIf = currentIf.alternate = compilerDom.createIfStatement(
82
- branch.condition,
83
- branchBlockStatement
84
- );
85
- } else {
86
- currentIf.alternate = branchBlockStatement;
87
- }
88
- }
89
- if (!currentIf.alternate && !disableComment) {
90
- currentIf.alternate = compilerDom.createBlockStatement([
91
- compilerDom.createCallExpression(`_push`, ["`<!---->`"])
92
- ]);
93
- }
57
+ const [rootBranch] = node.branches;
58
+ const ifStatement = (0, _vue_compiler_dom.createIfStatement)(rootBranch.condition, processIfBranch(rootBranch, context, disableNestedFragments));
59
+ context.pushStatement(ifStatement);
60
+ let currentIf = ifStatement;
61
+ for (let i = 1; i < node.branches.length; i++) {
62
+ const branch = node.branches[i];
63
+ const branchBlockStatement = processIfBranch(branch, context, disableNestedFragments);
64
+ if (branch.condition) currentIf = currentIf.alternate = (0, _vue_compiler_dom.createIfStatement)(branch.condition, branchBlockStatement);
65
+ else currentIf.alternate = branchBlockStatement;
66
+ }
67
+ if (!currentIf.alternate && !disableComment) currentIf.alternate = (0, _vue_compiler_dom.createBlockStatement)([(0, _vue_compiler_dom.createCallExpression)(`_push`, ["`<!---->`"])]);
94
68
  }
95
69
  function processIfBranch(branch, context, disableNestedFragments = false) {
96
- const { children } = branch;
97
- const needFragmentWrapper = !disableNestedFragments && (children.length !== 1 || children[0].type !== 1) && // optimize away nested fragments when the only child is a ForNode
98
- !(children.length === 1 && children[0].type === 11);
99
- return processChildrenAsStatement(branch, context, needFragmentWrapper);
70
+ const { children } = branch;
71
+ return processChildrenAsStatement(branch, context, !disableNestedFragments && (children.length !== 1 || children[0].type !== 1) && !(children.length === 1 && children[0].type === 11));
100
72
  }
101
73
 
102
- const ssrTransformFor = compilerDom.createStructuralDirectiveTransform("for", compilerDom.processFor);
74
+ //#endregion
75
+ //#region packages/compiler-ssr/src/transforms/ssrVFor.ts
76
+ const ssrTransformFor = (0, _vue_compiler_dom.createStructuralDirectiveTransform)("for", _vue_compiler_dom.processFor);
103
77
  function ssrProcessFor(node, context, disableNestedFragments = false) {
104
- const needFragmentWrapper = !disableNestedFragments && (node.children.length !== 1 || node.children[0].type !== 1);
105
- const renderLoop = compilerDom.createFunctionExpression(
106
- compilerDom.createForLoopParams(node.parseResult)
107
- );
108
- renderLoop.body = processChildrenAsStatement(
109
- node,
110
- context,
111
- needFragmentWrapper
112
- );
113
- if (!disableNestedFragments) {
114
- context.pushStringPart(`<!--[-->`);
115
- }
116
- context.pushStatement(
117
- compilerDom.createCallExpression(context.helper(SSR_RENDER_LIST), [
118
- node.source,
119
- renderLoop
120
- ])
121
- );
122
- if (!disableNestedFragments) {
123
- context.pushStringPart(`<!--]-->`);
124
- }
78
+ const needFragmentWrapper = !disableNestedFragments && (node.children.length !== 1 || node.children[0].type !== 1);
79
+ const renderLoop = (0, _vue_compiler_dom.createFunctionExpression)((0, _vue_compiler_dom.createForLoopParams)(node.parseResult));
80
+ renderLoop.body = processChildrenAsStatement(node, context, needFragmentWrapper);
81
+ if (!disableNestedFragments) context.pushStringPart(`<!--[-->`);
82
+ context.pushStatement((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_LIST), [node.source, renderLoop]));
83
+ if (!disableNestedFragments) context.pushStringPart(`<!--]-->`);
125
84
  }
126
85
 
86
+ //#endregion
87
+ //#region packages/compiler-ssr/src/transforms/ssrTransformSlotOutlet.ts
127
88
  const ssrTransformSlotOutlet = (node, context) => {
128
- if (compilerDom.isSlotOutlet(node)) {
129
- const { slotName, slotProps } = compilerDom.processSlotOutlet(node, context);
130
- const args = [
131
- `_ctx.$slots`,
132
- slotName,
133
- slotProps || `{}`,
134
- // fallback content placeholder. will be replaced in the process phase
135
- `null`,
136
- `_push`,
137
- `_parent`
138
- ];
139
- if (context.scopeId && context.slotted !== false) {
140
- args.push(`"${context.scopeId}-s"`);
141
- }
142
- let method = SSR_RENDER_SLOT;
143
- let parent = context.parent;
144
- if (parent) {
145
- const children = parent.children;
146
- if (parent.type === 10) {
147
- parent = context.grandParent;
148
- }
149
- let componentType;
150
- if (parent.type === 1 && parent.tagType === 1 && ((componentType = compilerDom.resolveComponentType(parent, context, true)) === compilerDom.TRANSITION || componentType === compilerDom.TRANSITION_GROUP) && children.filter((c) => c.type === 1).length === 1) {
151
- method = SSR_RENDER_SLOT_INNER;
152
- if (!(context.scopeId && context.slotted !== false)) {
153
- args.push("null");
154
- }
155
- args.push("true");
156
- }
157
- }
158
- node.ssrCodegenNode = compilerDom.createCallExpression(context.helper(method), args);
159
- }
89
+ if ((0, _vue_compiler_dom.isSlotOutlet)(node)) {
90
+ const { slotName, slotProps } = (0, _vue_compiler_dom.processSlotOutlet)(node, context);
91
+ const args = [
92
+ `_ctx.$slots`,
93
+ slotName,
94
+ slotProps || `{}`,
95
+ `null`,
96
+ `_push`,
97
+ `_parent`
98
+ ];
99
+ if (context.scopeId && context.slotted !== false) args.push(`"${context.scopeId}-s"`);
100
+ let method = SSR_RENDER_SLOT;
101
+ let parent = context.parent;
102
+ if (parent) {
103
+ const children = parent.children;
104
+ if (parent.type === 10) parent = context.grandParent;
105
+ let componentType;
106
+ if (parent.type === 1 && parent.tagType === 1 && ((componentType = (0, _vue_compiler_dom.resolveComponentType)(parent, context, true)) === _vue_compiler_dom.TRANSITION || componentType === _vue_compiler_dom.TRANSITION_GROUP) && children.filter((c) => c.type === 1).length === 1) {
107
+ method = SSR_RENDER_SLOT_INNER;
108
+ if (!(context.scopeId && context.slotted !== false)) args.push("null");
109
+ args.push("true");
110
+ }
111
+ }
112
+ node.ssrCodegenNode = (0, _vue_compiler_dom.createCallExpression)(context.helper(method), args);
113
+ }
160
114
  };
161
115
  function ssrProcessSlotOutlet(node, context) {
162
- const renderCall = node.ssrCodegenNode;
163
- if (node.children.length) {
164
- const fallbackRenderFn = compilerDom.createFunctionExpression([]);
165
- fallbackRenderFn.body = processChildrenAsStatement(node, context);
166
- renderCall.arguments[3] = fallbackRenderFn;
167
- }
168
- if (context.withSlotScopeId) {
169
- const slotScopeId = renderCall.arguments[6];
170
- renderCall.arguments[6] = slotScopeId ? `${slotScopeId} + _scopeId` : `_scopeId`;
171
- }
172
- context.pushStatement(node.ssrCodegenNode);
116
+ const renderCall = node.ssrCodegenNode;
117
+ if (node.children.length) {
118
+ const fallbackRenderFn = (0, _vue_compiler_dom.createFunctionExpression)([]);
119
+ fallbackRenderFn.body = processChildrenAsStatement(node, context);
120
+ renderCall.arguments[3] = fallbackRenderFn;
121
+ }
122
+ if (context.withSlotScopeId) {
123
+ const slotScopeId = renderCall.arguments[6];
124
+ renderCall.arguments[6] = slotScopeId ? `${slotScopeId} + _scopeId` : `_scopeId`;
125
+ }
126
+ context.pushStatement(node.ssrCodegenNode);
173
127
  }
174
128
 
129
+ //#endregion
130
+ //#region packages/compiler-ssr/src/errors.ts
175
131
  function createSSRCompilerError(code, loc) {
176
- return compilerDom.createCompilerError(code, loc, SSRErrorMessages);
132
+ return (0, _vue_compiler_dom.createCompilerError)(code, loc, SSRErrorMessages);
177
133
  }
178
134
  const SSRErrorMessages = {
179
- [65]: `Unsafe attribute name for SSR.`,
180
- [66]: `Missing the 'to' prop on teleport element.`,
181
- [67]: `Invalid AST node during SSR transform.`
135
+ [65]: `Unsafe attribute name for SSR.`,
136
+ [66]: `Missing the 'to' prop on teleport element.`,
137
+ [67]: `Invalid AST node during SSR transform.`
182
138
  };
183
139
 
140
+ //#endregion
141
+ //#region packages/compiler-ssr/src/transforms/ssrTransformTeleport.ts
184
142
  function ssrProcessTeleport(node, context) {
185
- const targetProp = compilerDom.findProp(node, "to");
186
- if (!targetProp) {
187
- context.onError(
188
- createSSRCompilerError(66, node.loc)
189
- );
190
- return;
191
- }
192
- let target;
193
- if (targetProp.type === 6) {
194
- target = targetProp.value && compilerDom.createSimpleExpression(targetProp.value.content, true);
195
- } else {
196
- target = targetProp.exp;
197
- }
198
- if (!target) {
199
- context.onError(
200
- createSSRCompilerError(
201
- 66,
202
- targetProp.loc
203
- )
204
- );
205
- return;
206
- }
207
- const disabledProp = compilerDom.findProp(
208
- node,
209
- "disabled",
210
- false,
211
- true
212
- /* allow empty */
213
- );
214
- const disabled = disabledProp ? disabledProp.type === 6 ? `true` : disabledProp.exp || `false` : `false`;
215
- const contentRenderFn = compilerDom.createFunctionExpression(
216
- [`_push`],
217
- void 0,
218
- // Body is added later
219
- true,
220
- // newline
221
- false,
222
- // isSlot
223
- node.loc
224
- );
225
- contentRenderFn.body = processChildrenAsStatement(node, context);
226
- context.pushStatement(
227
- compilerDom.createCallExpression(context.helper(SSR_RENDER_TELEPORT), [
228
- `_push`,
229
- contentRenderFn,
230
- target,
231
- disabled,
232
- `_parent`
233
- ])
234
- );
143
+ const targetProp = (0, _vue_compiler_dom.findProp)(node, "to");
144
+ if (!targetProp) {
145
+ context.onError(createSSRCompilerError(66, node.loc));
146
+ return;
147
+ }
148
+ let target;
149
+ if (targetProp.type === 6) target = targetProp.value && (0, _vue_compiler_dom.createSimpleExpression)(targetProp.value.content, true);
150
+ else target = targetProp.exp;
151
+ if (!target) {
152
+ context.onError(createSSRCompilerError(66, targetProp.loc));
153
+ return;
154
+ }
155
+ const disabledProp = (0, _vue_compiler_dom.findProp)(node, "disabled", false, true);
156
+ const disabled = disabledProp ? disabledProp.type === 6 ? `true` : disabledProp.exp || `false` : `false`;
157
+ const contentRenderFn = (0, _vue_compiler_dom.createFunctionExpression)([`_push`], void 0, true, false, node.loc);
158
+ contentRenderFn.body = processChildrenAsStatement(node, context);
159
+ context.pushStatement((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_TELEPORT), [
160
+ `_push`,
161
+ contentRenderFn,
162
+ target,
163
+ disabled,
164
+ `_parent`
165
+ ]));
235
166
  }
236
167
 
168
+ //#endregion
169
+ //#region packages/compiler-ssr/src/transforms/ssrTransformSuspense.ts
237
170
  const wipMap$3 = /* @__PURE__ */ new WeakMap();
238
171
  function ssrTransformSuspense(node, context) {
239
- return () => {
240
- if (node.children.length) {
241
- const wipEntry = {
242
- slotsExp: null,
243
- // to be immediately set
244
- wipSlots: []
245
- };
246
- wipMap$3.set(node, wipEntry);
247
- wipEntry.slotsExp = compilerDom.buildSlots(
248
- node,
249
- context,
250
- (_props, _vForExp, children, loc) => {
251
- const fn = compilerDom.createFunctionExpression(
252
- [],
253
- void 0,
254
- // no return, assign body later
255
- true,
256
- // newline
257
- false,
258
- // suspense slots are not treated as normal slots
259
- loc
260
- );
261
- wipEntry.wipSlots.push({
262
- fn,
263
- children
264
- });
265
- return fn;
266
- }
267
- ).slots;
268
- }
269
- };
172
+ return () => {
173
+ if (node.children.length) {
174
+ const wipEntry = {
175
+ slotsExp: null,
176
+ wipSlots: []
177
+ };
178
+ wipMap$3.set(node, wipEntry);
179
+ wipEntry.slotsExp = (0, _vue_compiler_dom.buildSlots)(node, context, (_props, _vForExp, children, loc) => {
180
+ const fn = (0, _vue_compiler_dom.createFunctionExpression)([], void 0, true, false, loc);
181
+ wipEntry.wipSlots.push({
182
+ fn,
183
+ children
184
+ });
185
+ return fn;
186
+ }).slots;
187
+ }
188
+ };
270
189
  }
271
190
  function ssrProcessSuspense(node, context) {
272
- const wipEntry = wipMap$3.get(node);
273
- if (!wipEntry) {
274
- return;
275
- }
276
- const { slotsExp, wipSlots } = wipEntry;
277
- for (let i = 0; i < wipSlots.length; i++) {
278
- const slot = wipSlots[i];
279
- slot.fn.body = processChildrenAsStatement(slot, context);
280
- }
281
- context.pushStatement(
282
- compilerDom.createCallExpression(context.helper(SSR_RENDER_SUSPENSE), [
283
- `_push`,
284
- slotsExp
285
- ])
286
- );
191
+ const wipEntry = wipMap$3.get(node);
192
+ if (!wipEntry) return;
193
+ const { slotsExp, wipSlots } = wipEntry;
194
+ for (let i = 0; i < wipSlots.length; i++) {
195
+ const slot = wipSlots[i];
196
+ slot.fn.body = processChildrenAsStatement(slot, context);
197
+ }
198
+ context.pushStatement((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_SUSPENSE), [`_push`, slotsExp]));
287
199
  }
288
200
 
201
+ //#endregion
202
+ //#region packages/compiler-ssr/src/transforms/ssrTransformElement.ts
289
203
  const rawChildrenMap = /* @__PURE__ */ new WeakMap();
290
204
  const ssrTransformElement = (node, context) => {
291
- if (node.type !== 1 || node.tagType !== 0) {
292
- return;
293
- }
294
- return function ssrPostTransformElement() {
295
- const openTag = [`<${node.tag}`];
296
- const needTagForRuntime = node.tag === "textarea" || node.tag.indexOf("-") > 0;
297
- const hasDynamicVBind = compilerDom.hasDynamicKeyVBind(node);
298
- const hasCustomDir = node.props.some(
299
- (p) => p.type === 7 && !shared.isBuiltInDirective(p.name)
300
- );
301
- const vShowPropIndex = node.props.findIndex(
302
- (i) => i.type === 7 && i.name === "show"
303
- );
304
- if (vShowPropIndex !== -1) {
305
- const vShowProp = node.props[vShowPropIndex];
306
- node.props.splice(vShowPropIndex, 1);
307
- node.props.push(vShowProp);
308
- }
309
- const needMergeProps = hasDynamicVBind || hasCustomDir;
310
- if (needMergeProps) {
311
- const { props, directives } = compilerDom.buildProps(
312
- node,
313
- context,
314
- node.props,
315
- false,
316
- false,
317
- true
318
- );
319
- if (props || directives.length) {
320
- const mergedProps = buildSSRProps(props, directives, context);
321
- const propsExp = compilerDom.createCallExpression(
322
- context.helper(SSR_RENDER_ATTRS),
323
- [mergedProps]
324
- );
325
- if (node.tag === "textarea") {
326
- const existingText = node.children[0];
327
- if (!hasContentOverrideDirective(node) && (!existingText || existingText.type !== 5)) {
328
- const tempId = `_temp${context.temps++}`;
329
- propsExp.arguments = [
330
- compilerDom.createAssignmentExpression(
331
- compilerDom.createSimpleExpression(tempId, false),
332
- mergedProps
333
- )
334
- ];
335
- rawChildrenMap.set(
336
- node,
337
- compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [
338
- compilerDom.createConditionalExpression(
339
- compilerDom.createSimpleExpression(`"value" in ${tempId}`, false),
340
- compilerDom.createSimpleExpression(`${tempId}.value`, false),
341
- compilerDom.createSimpleExpression(
342
- existingText ? existingText.content : ``,
343
- true
344
- ),
345
- false
346
- )
347
- ])
348
- );
349
- }
350
- } else if (node.tag === "input") {
351
- const vModel = findVModel(node);
352
- if (vModel) {
353
- const tempId = `_temp${context.temps++}`;
354
- const tempExp = compilerDom.createSimpleExpression(tempId, false);
355
- propsExp.arguments = [
356
- compilerDom.createSequenceExpression([
357
- compilerDom.createAssignmentExpression(tempExp, mergedProps),
358
- compilerDom.createCallExpression(context.helper(compilerDom.MERGE_PROPS), [
359
- tempExp,
360
- compilerDom.createCallExpression(
361
- context.helper(SSR_GET_DYNAMIC_MODEL_PROPS),
362
- [
363
- tempExp,
364
- // existing props
365
- vModel.exp
366
- // model
367
- ]
368
- )
369
- ])
370
- ])
371
- ];
372
- }
373
- } else if (directives.length && !node.children.length) {
374
- if (!hasContentOverrideDirective(node)) {
375
- const tempId = `_temp${context.temps++}`;
376
- propsExp.arguments = [
377
- compilerDom.createAssignmentExpression(
378
- compilerDom.createSimpleExpression(tempId, false),
379
- mergedProps
380
- )
381
- ];
382
- rawChildrenMap.set(
383
- node,
384
- compilerDom.createConditionalExpression(
385
- compilerDom.createSimpleExpression(`"textContent" in ${tempId}`, false),
386
- compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [
387
- compilerDom.createSimpleExpression(`${tempId}.textContent`, false)
388
- ]),
389
- compilerDom.createSimpleExpression(`${tempId}.innerHTML ?? ''`, false),
390
- false
391
- )
392
- );
393
- }
394
- }
395
- if (needTagForRuntime) {
396
- propsExp.arguments.push(`"${node.tag}"`);
397
- }
398
- openTag.push(propsExp);
399
- }
400
- }
401
- let dynamicClassBinding = void 0;
402
- let staticClassBinding = void 0;
403
- let dynamicStyleBinding = void 0;
404
- for (let i = 0; i < node.props.length; i++) {
405
- const prop = node.props[i];
406
- if (node.tag === "input" && isTrueFalseValue(prop)) {
407
- continue;
408
- }
409
- if (prop.type === 7) {
410
- if (prop.name === "html" && prop.exp) {
411
- rawChildrenMap.set(
412
- node,
413
- compilerDom.createCompoundExpression([`(`, prop.exp, `) ?? ''`])
414
- );
415
- } else if (prop.name === "text" && prop.exp) {
416
- node.children = [compilerDom.createInterpolation(prop.exp, prop.loc)];
417
- } else if (prop.name === "slot") {
418
- context.onError(
419
- compilerDom.createCompilerError(40, prop.loc)
420
- );
421
- } else if (isTextareaWithValue(node, prop) && prop.exp) {
422
- if (!needMergeProps) {
423
- node.children = [compilerDom.createInterpolation(prop.exp, prop.loc)];
424
- }
425
- } else if (!needMergeProps && prop.name !== "on") {
426
- const directiveTransform = context.directiveTransforms[prop.name];
427
- if (directiveTransform) {
428
- const { props, ssrTagParts } = directiveTransform(
429
- prop,
430
- node,
431
- context
432
- );
433
- if (ssrTagParts) {
434
- openTag.push(...ssrTagParts);
435
- }
436
- for (let j = 0; j < props.length; j++) {
437
- const { key, value } = props[j];
438
- if (compilerDom.isStaticExp(key)) {
439
- let attrName = key.content;
440
- if (attrName === "key" || attrName === "ref") {
441
- continue;
442
- }
443
- if (attrName === "class") {
444
- openTag.push(
445
- ` class="`,
446
- dynamicClassBinding = compilerDom.createCallExpression(
447
- context.helper(SSR_RENDER_CLASS),
448
- [value]
449
- ),
450
- `"`
451
- );
452
- } else if (attrName === "style") {
453
- if (dynamicStyleBinding) {
454
- mergeCall(dynamicStyleBinding, value);
455
- } else {
456
- openTag.push(
457
- ` style="`,
458
- dynamicStyleBinding = compilerDom.createCallExpression(
459
- context.helper(SSR_RENDER_STYLE),
460
- [value]
461
- ),
462
- `"`
463
- );
464
- }
465
- } else {
466
- attrName = node.tag.indexOf("-") > 0 ? attrName : shared.propsToAttrMap[attrName] || attrName.toLowerCase();
467
- if (shared.isBooleanAttr(attrName)) {
468
- openTag.push(
469
- compilerDom.createConditionalExpression(
470
- compilerDom.createCallExpression(
471
- context.helper(SSR_INCLUDE_BOOLEAN_ATTR),
472
- [value]
473
- ),
474
- compilerDom.createSimpleExpression(" " + attrName, true),
475
- compilerDom.createSimpleExpression("", true),
476
- false
477
- )
478
- );
479
- } else if (shared.isSSRSafeAttrName(attrName)) {
480
- openTag.push(
481
- compilerDom.createCallExpression(context.helper(SSR_RENDER_ATTR), [
482
- key,
483
- value
484
- ])
485
- );
486
- } else {
487
- context.onError(
488
- createSSRCompilerError(
489
- 65,
490
- key.loc
491
- )
492
- );
493
- }
494
- }
495
- } else {
496
- const args = [key, value];
497
- if (needTagForRuntime) {
498
- args.push(`"${node.tag}"`);
499
- }
500
- openTag.push(
501
- compilerDom.createCallExpression(
502
- context.helper(SSR_RENDER_DYNAMIC_ATTR),
503
- args
504
- )
505
- );
506
- }
507
- }
508
- }
509
- }
510
- } else {
511
- const name = prop.name;
512
- if (node.tag === "textarea" && name === "value" && prop.value) {
513
- rawChildrenMap.set(node, shared.escapeHtml(prop.value.content));
514
- } else if (!needMergeProps) {
515
- if (name === "key" || name === "ref") {
516
- continue;
517
- }
518
- if (name === "class" && prop.value) {
519
- staticClassBinding = JSON.stringify(prop.value.content);
520
- }
521
- openTag.push(
522
- ` ${prop.name}` + (prop.value ? `="${shared.escapeHtml(prop.value.content)}"` : ``)
523
- );
524
- }
525
- }
526
- }
527
- if (dynamicClassBinding && staticClassBinding) {
528
- mergeCall(dynamicClassBinding, staticClassBinding);
529
- removeStaticBinding(openTag, "class");
530
- }
531
- if (context.scopeId) {
532
- openTag.push(` ${context.scopeId}`);
533
- }
534
- node.ssrCodegenNode = compilerDom.createTemplateLiteral(openTag);
535
- };
205
+ if (node.type !== 1 || node.tagType !== 0) return;
206
+ return function ssrPostTransformElement() {
207
+ const openTag = [`<${node.tag}`];
208
+ const needTagForRuntime = node.tag === "textarea" || node.tag.indexOf("-") > 0;
209
+ const hasDynamicVBind = (0, _vue_compiler_dom.hasDynamicKeyVBind)(node);
210
+ const hasCustomDir = node.props.some((p) => p.type === 7 && !(0, _vue_shared.isBuiltInDirective)(p.name));
211
+ const vShowPropIndex = node.props.findIndex((i) => i.type === 7 && i.name === "show");
212
+ if (vShowPropIndex !== -1) {
213
+ const vShowProp = node.props[vShowPropIndex];
214
+ node.props.splice(vShowPropIndex, 1);
215
+ node.props.push(vShowProp);
216
+ }
217
+ const needMergeProps = hasDynamicVBind || hasCustomDir;
218
+ if (needMergeProps) {
219
+ const { props, directives } = (0, _vue_compiler_dom.buildProps)(node, context, node.props, false, false, true);
220
+ if (props || directives.length) {
221
+ const mergedProps = buildSSRProps(props, directives, context);
222
+ const propsExp = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_ATTRS), [mergedProps]);
223
+ if (node.tag === "textarea") {
224
+ const existingText = node.children[0];
225
+ if (!hasContentOverrideDirective(node) && (!existingText || existingText.type !== 5)) {
226
+ const tempId = `_temp${context.temps++}`;
227
+ propsExp.arguments = [(0, _vue_compiler_dom.createAssignmentExpression)((0, _vue_compiler_dom.createSimpleExpression)(tempId, false), mergedProps)];
228
+ rawChildrenMap.set(node, (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_INTERPOLATE), [(0, _vue_compiler_dom.createConditionalExpression)((0, _vue_compiler_dom.createSimpleExpression)(`"value" in ${tempId}`, false), (0, _vue_compiler_dom.createSimpleExpression)(`${tempId}.value`, false), (0, _vue_compiler_dom.createSimpleExpression)(existingText ? existingText.content : ``, true), false)]));
229
+ }
230
+ } else if (node.tag === "input") {
231
+ const vModel = findVModel(node);
232
+ if (vModel) {
233
+ const tempExp = (0, _vue_compiler_dom.createSimpleExpression)(`_temp${context.temps++}`, false);
234
+ propsExp.arguments = [(0, _vue_compiler_dom.createSequenceExpression)([(0, _vue_compiler_dom.createAssignmentExpression)(tempExp, mergedProps), (0, _vue_compiler_dom.createCallExpression)(context.helper(_vue_compiler_dom.MERGE_PROPS), [tempExp, (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_GET_DYNAMIC_MODEL_PROPS), [tempExp, vModel.exp])])])];
235
+ }
236
+ } else if (directives.length && !node.children.length) {
237
+ if (!hasContentOverrideDirective(node)) {
238
+ const tempId = `_temp${context.temps++}`;
239
+ propsExp.arguments = [(0, _vue_compiler_dom.createAssignmentExpression)((0, _vue_compiler_dom.createSimpleExpression)(tempId, false), mergedProps)];
240
+ rawChildrenMap.set(node, (0, _vue_compiler_dom.createConditionalExpression)((0, _vue_compiler_dom.createSimpleExpression)(`"textContent" in ${tempId}`, false), (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_INTERPOLATE), [(0, _vue_compiler_dom.createSimpleExpression)(`${tempId}.textContent`, false)]), (0, _vue_compiler_dom.createSimpleExpression)(`${tempId}.innerHTML ?? ''`, false), false));
241
+ }
242
+ }
243
+ if (needTagForRuntime) propsExp.arguments.push(`"${node.tag}"`);
244
+ openTag.push(propsExp);
245
+ }
246
+ }
247
+ let dynamicClassBinding = void 0;
248
+ let staticClassBinding = void 0;
249
+ let dynamicStyleBinding = void 0;
250
+ for (let i = 0; i < node.props.length; i++) {
251
+ const prop = node.props[i];
252
+ if (node.tag === "input" && isTrueFalseValue(prop)) continue;
253
+ if (prop.type === 7) {
254
+ if (prop.name === "html" && prop.exp) rawChildrenMap.set(node, (0, _vue_compiler_dom.createCompoundExpression)([
255
+ `(`,
256
+ prop.exp,
257
+ `) ?? ''`
258
+ ]));
259
+ else if (prop.name === "text" && prop.exp) node.children = [(0, _vue_compiler_dom.createInterpolation)(prop.exp, prop.loc)];
260
+ else if (prop.name === "slot") context.onError((0, _vue_compiler_dom.createCompilerError)(40, prop.loc));
261
+ else if (isTextareaWithValue(node, prop) && prop.exp) {
262
+ if (!needMergeProps) node.children = [(0, _vue_compiler_dom.createInterpolation)(prop.exp, prop.loc)];
263
+ } else if (!needMergeProps && prop.name !== "on") {
264
+ const directiveTransform = context.directiveTransforms[prop.name];
265
+ if (directiveTransform) {
266
+ const { props, ssrTagParts } = directiveTransform(prop, node, context);
267
+ if (ssrTagParts) openTag.push(...ssrTagParts);
268
+ for (let j = 0; j < props.length; j++) {
269
+ const { key, value } = props[j];
270
+ if ((0, _vue_compiler_dom.isStaticExp)(key)) {
271
+ let attrName = key.content;
272
+ if (attrName === "key" || attrName === "ref") continue;
273
+ if (attrName === "class") openTag.push(` class="`, dynamicClassBinding = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_CLASS), [value]), `"`);
274
+ else if (attrName === "style") if (dynamicStyleBinding) mergeCall(dynamicStyleBinding, value);
275
+ else openTag.push(` style="`, dynamicStyleBinding = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_STYLE), [value]), `"`);
276
+ else {
277
+ attrName = node.tag.indexOf("-") > 0 ? attrName : _vue_shared.propsToAttrMap[attrName] || attrName.toLowerCase();
278
+ if ((0, _vue_shared.isBooleanAttr)(attrName)) openTag.push((0, _vue_compiler_dom.createConditionalExpression)((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_INCLUDE_BOOLEAN_ATTR), [value]), (0, _vue_compiler_dom.createSimpleExpression)(" " + attrName, true), (0, _vue_compiler_dom.createSimpleExpression)("", true), false));
279
+ else if ((0, _vue_shared.isSSRSafeAttrName)(attrName)) openTag.push((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_ATTR), [key, value]));
280
+ else context.onError(createSSRCompilerError(65, key.loc));
281
+ }
282
+ } else {
283
+ const args = [key, value];
284
+ if (needTagForRuntime) args.push(`"${node.tag}"`);
285
+ openTag.push((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_DYNAMIC_ATTR), args));
286
+ }
287
+ }
288
+ }
289
+ }
290
+ } else {
291
+ const name = prop.name;
292
+ if (node.tag === "textarea" && name === "value" && prop.value) rawChildrenMap.set(node, (0, _vue_shared.escapeHtml)(prop.value.content));
293
+ else if (!needMergeProps) {
294
+ if (name === "key" || name === "ref") continue;
295
+ if (name === "class" && prop.value) staticClassBinding = JSON.stringify(prop.value.content);
296
+ openTag.push(` ${prop.name}` + (prop.value ? `="${(0, _vue_shared.escapeHtml)(prop.value.content)}"` : ``));
297
+ }
298
+ }
299
+ }
300
+ if (dynamicClassBinding && staticClassBinding) {
301
+ mergeCall(dynamicClassBinding, staticClassBinding);
302
+ removeStaticBinding(openTag, "class");
303
+ }
304
+ if (context.scopeId) openTag.push(` ${context.scopeId}`);
305
+ node.ssrCodegenNode = (0, _vue_compiler_dom.createTemplateLiteral)(openTag);
306
+ };
536
307
  };
537
308
  function buildSSRProps(props, directives, context) {
538
- let mergePropsArgs = [];
539
- if (props) {
540
- if (props.type === 14) {
541
- mergePropsArgs = props.arguments;
542
- } else {
543
- mergePropsArgs.push(props);
544
- }
545
- }
546
- if (directives.length) {
547
- for (const dir of directives) {
548
- mergePropsArgs.push(
549
- compilerDom.createCallExpression(context.helper(SSR_GET_DIRECTIVE_PROPS), [
550
- `_ctx`,
551
- ...compilerDom.buildDirectiveArgs(dir, context).elements
552
- ])
553
- );
554
- }
555
- }
556
- return mergePropsArgs.length > 1 ? compilerDom.createCallExpression(context.helper(compilerDom.MERGE_PROPS), mergePropsArgs) : mergePropsArgs[0];
309
+ let mergePropsArgs = [];
310
+ if (props) if (props.type === 14) mergePropsArgs = props.arguments;
311
+ else mergePropsArgs.push(props);
312
+ if (directives.length) for (const dir of directives) mergePropsArgs.push((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_GET_DIRECTIVE_PROPS), [`_ctx`, ...(0, _vue_compiler_dom.buildDirectiveArgs)(dir, context).elements]));
313
+ return mergePropsArgs.length > 1 ? (0, _vue_compiler_dom.createCallExpression)(context.helper(_vue_compiler_dom.MERGE_PROPS), mergePropsArgs) : mergePropsArgs[0];
557
314
  }
558
315
  function isTrueFalseValue(prop) {
559
- if (prop.type === 7) {
560
- return prop.name === "bind" && prop.arg && compilerDom.isStaticExp(prop.arg) && (prop.arg.content === "true-value" || prop.arg.content === "false-value");
561
- } else {
562
- return prop.name === "true-value" || prop.name === "false-value";
563
- }
316
+ if (prop.type === 7) return prop.name === "bind" && prop.arg && (0, _vue_compiler_dom.isStaticExp)(prop.arg) && (prop.arg.content === "true-value" || prop.arg.content === "false-value");
317
+ else return prop.name === "true-value" || prop.name === "false-value";
564
318
  }
565
319
  function isTextareaWithValue(node, prop) {
566
- return !!(node.tag === "textarea" && prop.name === "bind" && compilerDom.isStaticArgOf(prop.arg, "value"));
320
+ return !!(node.tag === "textarea" && prop.name === "bind" && (0, _vue_compiler_dom.isStaticArgOf)(prop.arg, "value"));
567
321
  }
568
322
  function mergeCall(call, arg) {
569
- const existing = call.arguments[0];
570
- if (existing.type === 17) {
571
- existing.elements.push(arg);
572
- } else {
573
- call.arguments[0] = compilerDom.createArrayExpression([existing, arg]);
574
- }
323
+ const existing = call.arguments[0];
324
+ if (existing.type === 17) existing.elements.push(arg);
325
+ else call.arguments[0] = (0, _vue_compiler_dom.createArrayExpression)([existing, arg]);
575
326
  }
576
327
  function removeStaticBinding(tag, binding) {
577
- const regExp = new RegExp(`^ ${binding}=".+"$`);
578
- const i = tag.findIndex((e) => typeof e === "string" && regExp.test(e));
579
- if (i > -1) {
580
- tag.splice(i, 1);
581
- }
328
+ const regExp = new RegExp(`^ ${binding}=".+"$`);
329
+ const i = tag.findIndex((e) => typeof e === "string" && regExp.test(e));
330
+ if (i > -1) tag.splice(i, 1);
582
331
  }
583
332
  function findVModel(node) {
584
- return node.props.find(
585
- (p) => p.type === 7 && p.name === "model" && p.exp
586
- );
333
+ return node.props.find((p) => p.type === 7 && p.name === "model" && p.exp);
587
334
  }
588
335
  function hasContentOverrideDirective(node) {
589
- return !!compilerDom.findDir(node, "text") || !!compilerDom.findDir(node, "html");
336
+ return !!(0, _vue_compiler_dom.findDir)(node, "text") || !!(0, _vue_compiler_dom.findDir)(node, "html");
590
337
  }
591
338
  function ssrProcessElement(node, context) {
592
- const isVoidTag = context.options.isVoidTag || shared.NO;
593
- const elementsToAdd = node.ssrCodegenNode.elements;
594
- for (let j = 0; j < elementsToAdd.length; j++) {
595
- context.pushStringPart(elementsToAdd[j]);
596
- }
597
- if (context.withSlotScopeId) {
598
- context.pushStringPart(compilerDom.createSimpleExpression(`_scopeId`, false));
599
- }
600
- context.pushStringPart(`>`);
601
- const rawChildren = rawChildrenMap.get(node);
602
- if (rawChildren) {
603
- context.pushStringPart(rawChildren);
604
- } else if (node.children.length) {
605
- processChildren(node, context);
606
- }
607
- if (!isVoidTag(node.tag)) {
608
- context.pushStringPart(`</${node.tag}>`);
609
- }
339
+ const isVoidTag = context.options.isVoidTag || _vue_shared.NO;
340
+ const elementsToAdd = node.ssrCodegenNode.elements;
341
+ for (let j = 0; j < elementsToAdd.length; j++) context.pushStringPart(elementsToAdd[j]);
342
+ if (context.withSlotScopeId) context.pushStringPart((0, _vue_compiler_dom.createSimpleExpression)(`_scopeId`, false));
343
+ context.pushStringPart(`>`);
344
+ const rawChildren = rawChildrenMap.get(node);
345
+ if (rawChildren) context.pushStringPart(rawChildren);
346
+ else if (node.children.length) processChildren(node, context);
347
+ if (!isVoidTag(node.tag)) context.pushStringPart(`</${node.tag}>`);
610
348
  }
611
349
 
350
+ //#endregion
351
+ //#region packages/compiler-ssr/src/transforms/ssrTransformTransitionGroup.ts
612
352
  const wipMap$2 = /* @__PURE__ */ new WeakMap();
613
353
  function ssrTransformTransitionGroup(node, context) {
614
- return () => {
615
- const tag = compilerDom.findProp(node, "tag");
616
- if (tag) {
617
- const otherProps = node.props.filter((p) => p !== tag);
618
- const { props, directives } = compilerDom.buildProps(
619
- node,
620
- context,
621
- otherProps,
622
- true,
623
- false,
624
- true
625
- );
626
- let propsExp = null;
627
- if (props || directives.length) {
628
- propsExp = compilerDom.createCallExpression(context.helper(SSR_RENDER_ATTRS), [
629
- buildSSRProps(props, directives, context)
630
- ]);
631
- }
632
- wipMap$2.set(node, {
633
- tag,
634
- propsExp,
635
- scopeId: context.scopeId || null
636
- });
637
- }
638
- };
354
+ return () => {
355
+ const tag = (0, _vue_compiler_dom.findProp)(node, "tag");
356
+ if (tag) {
357
+ const { props, directives } = (0, _vue_compiler_dom.buildProps)(node, context, node.props.filter((p) => p !== tag), true, false, true);
358
+ let propsExp = null;
359
+ if (props || directives.length) propsExp = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_ATTRS), [buildSSRProps(props, directives, context)]);
360
+ wipMap$2.set(node, {
361
+ tag,
362
+ propsExp,
363
+ scopeId: context.scopeId || null
364
+ });
365
+ }
366
+ };
639
367
  }
640
368
  function ssrProcessTransitionGroup(node, context) {
641
- const entry = wipMap$2.get(node);
642
- if (entry) {
643
- const { tag, propsExp, scopeId } = entry;
644
- if (tag.type === 7) {
645
- context.pushStringPart(`<`);
646
- context.pushStringPart(tag.exp);
647
- if (propsExp) {
648
- context.pushStringPart(propsExp);
649
- }
650
- if (scopeId) {
651
- context.pushStringPart(` ${scopeId}`);
652
- }
653
- context.pushStringPart(`>`);
654
- processChildren(
655
- node,
656
- context,
657
- false,
658
- /**
659
- * TransitionGroup has the special runtime behavior of flattening and
660
- * concatenating all children into a single fragment (in order for them to
661
- * be patched using the same key map) so we need to account for that here
662
- * by disabling nested fragment wrappers from being generated.
663
- */
664
- true,
665
- /**
666
- * TransitionGroup filters out comment children at runtime and thus
667
- * doesn't expect comments to be present during hydration. We need to
668
- * account for that by disabling the empty comment that is otherwise
669
- * rendered for a falsy v-if that has no v-else specified. (#6715)
670
- */
671
- true
672
- );
673
- context.pushStringPart(`</`);
674
- context.pushStringPart(tag.exp);
675
- context.pushStringPart(`>`);
676
- } else {
677
- context.pushStringPart(`<${tag.value.content}`);
678
- if (propsExp) {
679
- context.pushStringPart(propsExp);
680
- }
681
- if (scopeId) {
682
- context.pushStringPart(` ${scopeId}`);
683
- }
684
- context.pushStringPart(`>`);
685
- processChildren(node, context, false, true, true);
686
- context.pushStringPart(`</${tag.value.content}>`);
687
- }
688
- } else {
689
- processChildren(node, context, true, true, true);
690
- }
369
+ const entry = wipMap$2.get(node);
370
+ if (entry) {
371
+ const { tag, propsExp, scopeId } = entry;
372
+ if (tag.type === 7) {
373
+ context.pushStringPart(`<`);
374
+ context.pushStringPart(tag.exp);
375
+ if (propsExp) context.pushStringPart(propsExp);
376
+ if (scopeId) context.pushStringPart(` ${scopeId}`);
377
+ context.pushStringPart(`>`);
378
+ processChildren(
379
+ node,
380
+ context,
381
+ false,
382
+ /**
383
+ * TransitionGroup has the special runtime behavior of flattening and
384
+ * concatenating all children into a single fragment (in order for them to
385
+ * be patched using the same key map) so we need to account for that here
386
+ * by disabling nested fragment wrappers from being generated.
387
+ */
388
+ true,
389
+ /**
390
+ * TransitionGroup filters out comment children at runtime and thus
391
+ * doesn't expect comments to be present during hydration. We need to
392
+ * account for that by disabling the empty comment that is otherwise
393
+ * rendered for a falsy v-if that has no v-else specified. (#6715)
394
+ */
395
+ true
396
+ );
397
+ context.pushStringPart(`</`);
398
+ context.pushStringPart(tag.exp);
399
+ context.pushStringPart(`>`);
400
+ } else {
401
+ context.pushStringPart(`<${tag.value.content}`);
402
+ if (propsExp) context.pushStringPart(propsExp);
403
+ if (scopeId) context.pushStringPart(` ${scopeId}`);
404
+ context.pushStringPart(`>`);
405
+ processChildren(node, context, false, true, true);
406
+ context.pushStringPart(`</${tag.value.content}>`);
407
+ }
408
+ } else processChildren(node, context, true, true, true);
691
409
  }
692
410
 
411
+ //#endregion
412
+ //#region packages/compiler-ssr/src/transforms/ssrTransformTransition.ts
693
413
  const wipMap$1 = /* @__PURE__ */ new WeakMap();
694
414
  function ssrTransformTransition(node, context) {
695
- return () => {
696
- const appear = compilerDom.findProp(node, "appear", false, true);
697
- wipMap$1.set(node, !!appear);
698
- };
415
+ return () => {
416
+ const appear = (0, _vue_compiler_dom.findProp)(node, "appear", false, true);
417
+ wipMap$1.set(node, !!appear);
418
+ };
699
419
  }
700
420
  function ssrProcessTransition(node, context) {
701
- node.children = node.children.filter((c) => c.type !== 3);
702
- const appear = wipMap$1.get(node);
703
- if (appear) {
704
- context.pushStringPart(`<template>`);
705
- processChildren(node, context, false, true);
706
- context.pushStringPart(`</template>`);
707
- } else {
708
- processChildren(node, context, false, true);
709
- }
421
+ node.children = node.children.filter((c) => c.type !== 3);
422
+ if (wipMap$1.get(node)) {
423
+ context.pushStringPart(`<template>`);
424
+ processChildren(node, context, false, true);
425
+ context.pushStringPart(`</template>`);
426
+ } else processChildren(node, context, false, true);
710
427
  }
711
428
 
429
+ //#endregion
430
+ //#region packages/compiler-ssr/src/transforms/ssrTransformComponent.ts
712
431
  const wipMap = /* @__PURE__ */ new WeakMap();
713
- const WIP_SLOT = /* @__PURE__ */ Symbol();
432
+ const WIP_SLOT = Symbol();
714
433
  const componentTypeMap = /* @__PURE__ */ new WeakMap();
715
434
  const ssrTransformComponent = (node, context) => {
716
- if (node.type !== 1 || node.tagType !== 1) {
717
- return;
718
- }
719
- const component = compilerDom.resolveComponentType(
720
- node,
721
- context,
722
- true
723
- /* ssr */
724
- );
725
- const isDynamicComponent = shared.isObject(component) && component.callee === compilerDom.RESOLVE_DYNAMIC_COMPONENT;
726
- componentTypeMap.set(node, component);
727
- if (shared.isSymbol(component)) {
728
- if (component === compilerDom.SUSPENSE) {
729
- return ssrTransformSuspense(node, context);
730
- } else if (component === compilerDom.TRANSITION_GROUP) {
731
- return ssrTransformTransitionGroup(node, context);
732
- } else if (component === compilerDom.TRANSITION) {
733
- return ssrTransformTransition(node);
734
- }
735
- return;
736
- }
737
- const vnodeBranches = [];
738
- const clonedNode = clone(node);
739
- return function ssrPostTransformComponent() {
740
- if (clonedNode.children.length) {
741
- compilerDom.buildSlots(clonedNode, context, (props, vFor, children) => {
742
- vnodeBranches.push(
743
- createVNodeSlotBranch(props, vFor, children, context)
744
- );
745
- return compilerDom.createFunctionExpression(void 0);
746
- });
747
- }
748
- let propsExp = `null`;
749
- if (node.props.length) {
750
- const { props, directives } = compilerDom.buildProps(
751
- node,
752
- context,
753
- void 0,
754
- true,
755
- isDynamicComponent
756
- );
757
- if (props || directives.length) {
758
- propsExp = buildSSRProps(props, directives, context);
759
- }
760
- }
761
- const wipEntries = [];
762
- wipMap.set(node, wipEntries);
763
- const buildSSRSlotFn = (props, _vForExp, children, loc) => {
764
- const param0 = props && compilerDom.stringifyExpression(props) || `_`;
765
- const fn = compilerDom.createFunctionExpression(
766
- [param0, `_push`, `_parent`, `_scopeId`],
767
- void 0,
768
- // no return, assign body later
769
- true,
770
- // newline
771
- true,
772
- // isSlot
773
- loc
774
- );
775
- wipEntries.push({
776
- type: WIP_SLOT,
777
- fn,
778
- children,
779
- // also collect the corresponding vnode branch built earlier
780
- vnodeBranch: vnodeBranches[wipEntries.length]
781
- });
782
- return fn;
783
- };
784
- const slots = node.children.length ? compilerDom.buildSlots(node, context, buildSSRSlotFn).slots : `null`;
785
- if (typeof component !== "string") {
786
- node.ssrCodegenNode = compilerDom.createCallExpression(
787
- context.helper(SSR_RENDER_VNODE),
788
- [
789
- `_push`,
790
- compilerDom.createCallExpression(context.helper(compilerDom.CREATE_VNODE), [
791
- component,
792
- propsExp,
793
- slots
794
- ]),
795
- `_parent`
796
- ]
797
- );
798
- } else {
799
- node.ssrCodegenNode = compilerDom.createCallExpression(
800
- context.helper(SSR_RENDER_COMPONENT),
801
- [component, propsExp, slots, `_parent`]
802
- );
803
- }
804
- };
435
+ if (node.type !== 1 || node.tagType !== 1) return;
436
+ const component = (0, _vue_compiler_dom.resolveComponentType)(node, context, true);
437
+ const isDynamicComponent = (0, _vue_shared.isObject)(component) && component.callee === _vue_compiler_dom.RESOLVE_DYNAMIC_COMPONENT;
438
+ componentTypeMap.set(node, component);
439
+ if ((0, _vue_shared.isSymbol)(component)) {
440
+ if (component === _vue_compiler_dom.SUSPENSE) return ssrTransformSuspense(node, context);
441
+ else if (component === _vue_compiler_dom.TRANSITION_GROUP) return ssrTransformTransitionGroup(node, context);
442
+ else if (component === _vue_compiler_dom.TRANSITION) return ssrTransformTransition(node, context);
443
+ return;
444
+ }
445
+ const vnodeBranches = [];
446
+ const clonedNode = clone(node);
447
+ return function ssrPostTransformComponent() {
448
+ if (clonedNode.children.length) (0, _vue_compiler_dom.buildSlots)(clonedNode, context, (props, vFor, children) => {
449
+ vnodeBranches.push(createVNodeSlotBranch(props, vFor, children, context));
450
+ return (0, _vue_compiler_dom.createFunctionExpression)(void 0);
451
+ });
452
+ let propsExp = `null`;
453
+ if (node.props.length) {
454
+ const { props, directives } = (0, _vue_compiler_dom.buildProps)(node, context, void 0, true, isDynamicComponent);
455
+ if (props || directives.length) propsExp = buildSSRProps(props, directives, context);
456
+ }
457
+ const wipEntries = [];
458
+ wipMap.set(node, wipEntries);
459
+ const buildSSRSlotFn = (props, _vForExp, children, loc) => {
460
+ const fn = (0, _vue_compiler_dom.createFunctionExpression)([
461
+ props && (0, _vue_compiler_dom.stringifyExpression)(props) || `_`,
462
+ `_push`,
463
+ `_parent`,
464
+ `_scopeId`
465
+ ], void 0, true, true, loc);
466
+ wipEntries.push({
467
+ type: WIP_SLOT,
468
+ fn,
469
+ children,
470
+ vnodeBranch: vnodeBranches[wipEntries.length]
471
+ });
472
+ return fn;
473
+ };
474
+ const slots = node.children.length ? (0, _vue_compiler_dom.buildSlots)(node, context, buildSSRSlotFn).slots : `null`;
475
+ if (typeof component !== "string") node.ssrCodegenNode = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_VNODE), [
476
+ `_push`,
477
+ (0, _vue_compiler_dom.createCallExpression)(context.helper(_vue_compiler_dom.CREATE_VNODE), [
478
+ component,
479
+ propsExp,
480
+ slots
481
+ ]),
482
+ `_parent`
483
+ ]);
484
+ else node.ssrCodegenNode = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_COMPONENT), [
485
+ component,
486
+ propsExp,
487
+ slots,
488
+ `_parent`
489
+ ]);
490
+ };
805
491
  };
806
492
  function ssrProcessComponent(node, context, parent) {
807
- const component = componentTypeMap.get(node);
808
- if (!node.ssrCodegenNode) {
809
- if (component === compilerDom.TELEPORT) {
810
- return ssrProcessTeleport(node, context);
811
- } else if (component === compilerDom.SUSPENSE) {
812
- return ssrProcessSuspense(node, context);
813
- } else if (component === compilerDom.TRANSITION_GROUP) {
814
- return ssrProcessTransitionGroup(node, context);
815
- } else {
816
- if (parent.type === WIP_SLOT) {
817
- context.pushStringPart(``);
818
- }
819
- if (component === compilerDom.TRANSITION) {
820
- return ssrProcessTransition(node, context);
821
- }
822
- processChildren(node, context);
823
- }
824
- } else {
825
- const wipEntries = wipMap.get(node) || [];
826
- for (let i = 0; i < wipEntries.length; i++) {
827
- const { fn, vnodeBranch } = wipEntries[i];
828
- fn.body = compilerDom.createIfStatement(
829
- compilerDom.createSimpleExpression(`_push`, false),
830
- processChildrenAsStatement(
831
- wipEntries[i],
832
- context,
833
- false,
834
- true
835
- ),
836
- vnodeBranch
837
- );
838
- }
839
- if (context.withSlotScopeId) {
840
- node.ssrCodegenNode.arguments.push(`_scopeId`);
841
- }
842
- if (typeof component === "string") {
843
- context.pushStatement(
844
- compilerDom.createCallExpression(`_push`, [node.ssrCodegenNode])
845
- );
846
- } else {
847
- context.pushStatement(node.ssrCodegenNode);
848
- }
849
- }
493
+ const component = componentTypeMap.get(node);
494
+ if (!node.ssrCodegenNode) if (component === _vue_compiler_dom.TELEPORT) return ssrProcessTeleport(node, context);
495
+ else if (component === _vue_compiler_dom.SUSPENSE) return ssrProcessSuspense(node, context);
496
+ else if (component === _vue_compiler_dom.TRANSITION_GROUP) return ssrProcessTransitionGroup(node, context);
497
+ else {
498
+ if (parent.type === WIP_SLOT) context.pushStringPart(``);
499
+ if (component === _vue_compiler_dom.TRANSITION) return ssrProcessTransition(node, context);
500
+ processChildren(node, context);
501
+ }
502
+ else {
503
+ const wipEntries = wipMap.get(node) || [];
504
+ for (let i = 0; i < wipEntries.length; i++) {
505
+ const { fn, vnodeBranch } = wipEntries[i];
506
+ fn.body = (0, _vue_compiler_dom.createIfStatement)((0, _vue_compiler_dom.createSimpleExpression)(`_push`, false), processChildrenAsStatement(wipEntries[i], context, false, true), vnodeBranch);
507
+ }
508
+ if (context.withSlotScopeId) node.ssrCodegenNode.arguments.push(`_scopeId`);
509
+ if (typeof component === "string") context.pushStatement((0, _vue_compiler_dom.createCallExpression)(`_push`, [node.ssrCodegenNode]));
510
+ else context.pushStatement(node.ssrCodegenNode);
511
+ }
850
512
  }
851
513
  const rawOptionsMap = /* @__PURE__ */ new WeakMap();
852
- const [baseNodeTransforms, baseDirectiveTransforms] = compilerDom.getBaseTransformPreset(true);
853
- const vnodeNodeTransforms = [...baseNodeTransforms, ...compilerDom.DOMNodeTransforms];
514
+ const [baseNodeTransforms, baseDirectiveTransforms] = (0, _vue_compiler_dom.getBaseTransformPreset)(true);
515
+ const vnodeNodeTransforms = [...baseNodeTransforms, ..._vue_compiler_dom.DOMNodeTransforms];
854
516
  const vnodeDirectiveTransforms = {
855
- ...baseDirectiveTransforms,
856
- ...compilerDom.DOMDirectiveTransforms
517
+ ...baseDirectiveTransforms,
518
+ ..._vue_compiler_dom.DOMDirectiveTransforms
857
519
  };
858
520
  function createVNodeSlotBranch(slotProps, vFor, children, parentContext) {
859
- const rawOptions = rawOptionsMap.get(parentContext.root);
860
- const subOptions = {
861
- ...rawOptions,
862
- // overwrite with vnode-based transforms
863
- nodeTransforms: [
864
- ...vnodeNodeTransforms,
865
- ...rawOptions.nodeTransforms || []
866
- ],
867
- directiveTransforms: {
868
- ...vnodeDirectiveTransforms,
869
- ...rawOptions.directiveTransforms || {}
870
- }
871
- };
872
- const wrapperProps = [];
873
- if (slotProps) {
874
- wrapperProps.push({
875
- type: 7,
876
- name: "slot",
877
- exp: slotProps,
878
- arg: void 0,
879
- modifiers: [],
880
- loc: compilerDom.locStub
881
- });
882
- }
883
- if (vFor) {
884
- wrapperProps.push(shared.extend({}, vFor));
885
- }
886
- const wrapperNode = {
887
- type: 1,
888
- ns: 0,
889
- tag: "template",
890
- tagType: 3,
891
- props: wrapperProps,
892
- children,
893
- loc: compilerDom.locStub,
894
- codegenNode: void 0
895
- };
896
- subTransform(wrapperNode, subOptions, parentContext);
897
- return compilerDom.createReturnStatement(children);
521
+ const rawOptions = rawOptionsMap.get(parentContext.root);
522
+ const subOptions = {
523
+ ...rawOptions,
524
+ nodeTransforms: [...vnodeNodeTransforms, ...rawOptions.nodeTransforms || []],
525
+ directiveTransforms: {
526
+ ...vnodeDirectiveTransforms,
527
+ ...rawOptions.directiveTransforms || {}
528
+ }
529
+ };
530
+ const wrapperProps = [];
531
+ if (slotProps) wrapperProps.push({
532
+ type: 7,
533
+ name: "slot",
534
+ exp: slotProps,
535
+ arg: void 0,
536
+ modifiers: [],
537
+ loc: _vue_compiler_dom.locStub
538
+ });
539
+ if (vFor) wrapperProps.push((0, _vue_shared.extend)({}, vFor));
540
+ subTransform({
541
+ type: 1,
542
+ ns: 0,
543
+ tag: "template",
544
+ tagType: 3,
545
+ props: wrapperProps,
546
+ children,
547
+ loc: _vue_compiler_dom.locStub,
548
+ codegenNode: void 0
549
+ }, subOptions, parentContext);
550
+ return (0, _vue_compiler_dom.createReturnStatement)(children);
898
551
  }
899
552
  function subTransform(node, options, parentContext) {
900
- const childRoot = compilerDom.createRoot([node]);
901
- const childContext = compilerDom.createTransformContext(childRoot, options);
902
- childContext.ssr = false;
903
- childContext.scopes = { ...parentContext.scopes };
904
- childContext.identifiers = { ...parentContext.identifiers };
905
- childContext.imports = parentContext.imports;
906
- compilerDom.traverseNode(childRoot, childContext);
907
- ["helpers", "components", "directives"].forEach((key) => {
908
- childContext[key].forEach((value, helperKey) => {
909
- if (key === "helpers") {
910
- const parentCount = parentContext.helpers.get(helperKey);
911
- if (parentCount === void 0) {
912
- parentContext.helpers.set(helperKey, value);
913
- } else {
914
- parentContext.helpers.set(helperKey, value + parentCount);
915
- }
916
- } else {
917
- parentContext[key].add(value);
918
- }
919
- });
920
- });
553
+ const childRoot = (0, _vue_compiler_dom.createRoot)([node]);
554
+ const childContext = (0, _vue_compiler_dom.createTransformContext)(childRoot, options);
555
+ childContext.ssr = false;
556
+ childContext.scopes = { ...parentContext.scopes };
557
+ childContext.identifiers = { ...parentContext.identifiers };
558
+ childContext.imports = parentContext.imports;
559
+ (0, _vue_compiler_dom.traverseNode)(childRoot, childContext);
560
+ [
561
+ "helpers",
562
+ "components",
563
+ "directives"
564
+ ].forEach((key) => {
565
+ childContext[key].forEach((value, helperKey) => {
566
+ if (key === "helpers") {
567
+ const parentCount = parentContext.helpers.get(helperKey);
568
+ if (parentCount === void 0) parentContext.helpers.set(helperKey, value);
569
+ else parentContext.helpers.set(helperKey, value + parentCount);
570
+ } else parentContext[key].add(value);
571
+ });
572
+ });
921
573
  }
922
574
  function clone(v) {
923
- if (shared.isArray(v)) {
924
- return v.map(clone);
925
- } else if (shared.isPlainObject(v)) {
926
- const res = {};
927
- for (const key in v) {
928
- res[key] = clone(v[key]);
929
- }
930
- return res;
931
- } else {
932
- return v;
933
- }
575
+ if ((0, _vue_shared.isArray)(v)) return v.map(clone);
576
+ else if ((0, _vue_shared.isPlainObject)(v)) {
577
+ const res = {};
578
+ for (const key in v) res[key] = clone(v[key]);
579
+ return res;
580
+ } else return v;
934
581
  }
935
582
 
583
+ //#endregion
584
+ //#region packages/compiler-ssr/src/ssrCodegenTransform.ts
936
585
  function ssrCodegenTransform(ast, options) {
937
- const context = createSSRTransformContext(ast, options);
938
- if (options.ssrCssVars) {
939
- const cssContext = compilerDom.createTransformContext(compilerDom.createRoot([]), options);
940
- const varsExp = compilerDom.processExpression(
941
- compilerDom.createSimpleExpression(options.ssrCssVars, false),
942
- cssContext
943
- );
944
- context.body.push(
945
- compilerDom.createCompoundExpression([`const _cssVars = { style: `, varsExp, `}`])
946
- );
947
- Array.from(cssContext.helpers.keys()).forEach((helper) => {
948
- ast.helpers.add(helper);
949
- });
950
- }
951
- const isFragment = ast.children.length > 1 && ast.children.some((c) => !compilerDom.isText(c));
952
- processChildren(ast, context, isFragment);
953
- ast.codegenNode = compilerDom.createBlockStatement(context.body);
954
- ast.ssrHelpers = Array.from(
955
- /* @__PURE__ */ new Set([
956
- ...Array.from(ast.helpers).filter((h) => h in ssrHelpers),
957
- ...context.helpers
958
- ])
959
- );
960
- ast.helpers = new Set(Array.from(ast.helpers).filter((h) => !(h in ssrHelpers)));
586
+ const context = createSSRTransformContext(ast, options);
587
+ if (options.ssrCssVars) {
588
+ const cssContext = (0, _vue_compiler_dom.createTransformContext)((0, _vue_compiler_dom.createRoot)([]), options);
589
+ const varsExp = (0, _vue_compiler_dom.processExpression)((0, _vue_compiler_dom.createSimpleExpression)(options.ssrCssVars, false), cssContext);
590
+ context.body.push((0, _vue_compiler_dom.createCompoundExpression)([
591
+ `const _cssVars = { style: `,
592
+ varsExp,
593
+ `}`
594
+ ]));
595
+ Array.from(cssContext.helpers.keys()).forEach((helper) => {
596
+ ast.helpers.add(helper);
597
+ });
598
+ }
599
+ processChildren(ast, context, ast.children.length > 1 && ast.children.some((c) => !(0, _vue_compiler_dom.isText)(c)));
600
+ ast.codegenNode = (0, _vue_compiler_dom.createBlockStatement)(context.body);
601
+ ast.ssrHelpers = Array.from(new Set([...Array.from(ast.helpers).filter((h) => h in ssrHelpers), ...context.helpers]));
602
+ ast.helpers = new Set(Array.from(ast.helpers).filter((h) => !(h in ssrHelpers)));
961
603
  }
962
604
  function createSSRTransformContext(root, options, helpers = /* @__PURE__ */ new Set(), withSlotScopeId = false) {
963
- const body = [];
964
- let currentString = null;
965
- return {
966
- root,
967
- options,
968
- body,
969
- helpers,
970
- withSlotScopeId,
971
- onError: options.onError || ((e) => {
972
- throw e;
973
- }),
974
- helper(name) {
975
- helpers.add(name);
976
- return name;
977
- },
978
- pushStringPart(part) {
979
- if (!currentString) {
980
- const currentCall = compilerDom.createCallExpression(`_push`);
981
- body.push(currentCall);
982
- currentString = compilerDom.createTemplateLiteral([]);
983
- currentCall.arguments.push(currentString);
984
- }
985
- const bufferedElements = currentString.elements;
986
- const lastItem = bufferedElements[bufferedElements.length - 1];
987
- if (shared.isString(part) && shared.isString(lastItem)) {
988
- bufferedElements[bufferedElements.length - 1] += part;
989
- } else {
990
- bufferedElements.push(part);
991
- }
992
- },
993
- pushStatement(statement) {
994
- currentString = null;
995
- body.push(statement);
996
- }
997
- };
605
+ const body = [];
606
+ let currentString = null;
607
+ return {
608
+ root,
609
+ options,
610
+ body,
611
+ helpers,
612
+ withSlotScopeId,
613
+ onError: options.onError || ((e) => {
614
+ throw e;
615
+ }),
616
+ helper(name) {
617
+ helpers.add(name);
618
+ return name;
619
+ },
620
+ pushStringPart(part) {
621
+ if (!currentString) {
622
+ const currentCall = (0, _vue_compiler_dom.createCallExpression)(`_push`);
623
+ body.push(currentCall);
624
+ currentString = (0, _vue_compiler_dom.createTemplateLiteral)([]);
625
+ currentCall.arguments.push(currentString);
626
+ }
627
+ const bufferedElements = currentString.elements;
628
+ const lastItem = bufferedElements[bufferedElements.length - 1];
629
+ if ((0, _vue_shared.isString)(part) && (0, _vue_shared.isString)(lastItem)) bufferedElements[bufferedElements.length - 1] += part;
630
+ else bufferedElements.push(part);
631
+ },
632
+ pushStatement(statement) {
633
+ currentString = null;
634
+ body.push(statement);
635
+ }
636
+ };
998
637
  }
999
638
  function createChildContext(parent, withSlotScopeId = parent.withSlotScopeId) {
1000
- return createSSRTransformContext(
1001
- parent.root,
1002
- parent.options,
1003
- parent.helpers,
1004
- withSlotScopeId
1005
- );
639
+ return createSSRTransformContext(parent.root, parent.options, parent.helpers, withSlotScopeId);
1006
640
  }
1007
641
  function processChildren(parent, context, asFragment = false, disableNestedFragments = false, disableComment = false) {
1008
- if (asFragment) {
1009
- context.pushStringPart(`<!--[-->`);
1010
- }
1011
- const { children } = parent;
1012
- for (let i = 0; i < children.length; i++) {
1013
- const child = children[i];
1014
- switch (child.type) {
1015
- case 1:
1016
- switch (child.tagType) {
1017
- case 0:
1018
- ssrProcessElement(child, context);
1019
- break;
1020
- case 1:
1021
- ssrProcessComponent(child, context, parent);
1022
- break;
1023
- case 2:
1024
- ssrProcessSlotOutlet(child, context);
1025
- break;
1026
- case 3:
1027
- break;
1028
- default:
1029
- context.onError(
1030
- createSSRCompilerError(
1031
- 67,
1032
- child.loc
1033
- )
1034
- );
1035
- const exhaustiveCheck2 = child;
1036
- return exhaustiveCheck2;
1037
- }
1038
- break;
1039
- case 2:
1040
- context.pushStringPart(shared.escapeHtml(child.content));
1041
- break;
1042
- case 3:
1043
- if (!disableComment) {
1044
- context.pushStringPart(`<!--${child.content}-->`);
1045
- }
1046
- break;
1047
- case 5:
1048
- context.pushStringPart(
1049
- compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [
1050
- child.content
1051
- ])
1052
- );
1053
- break;
1054
- case 9:
1055
- ssrProcessIf(child, context, disableNestedFragments, disableComment);
1056
- break;
1057
- case 11:
1058
- ssrProcessFor(child, context, disableNestedFragments);
1059
- break;
1060
- case 10:
1061
- break;
1062
- case 12:
1063
- case 8:
1064
- break;
1065
- default:
1066
- context.onError(
1067
- createSSRCompilerError(
1068
- 67,
1069
- child.loc
1070
- )
1071
- );
1072
- const exhaustiveCheck = child;
1073
- return exhaustiveCheck;
1074
- }
1075
- }
1076
- if (asFragment) {
1077
- context.pushStringPart(`<!--]-->`);
1078
- }
642
+ if (asFragment) context.pushStringPart(`<!--[-->`);
643
+ const { children } = parent;
644
+ for (let i = 0; i < children.length; i++) {
645
+ const child = children[i];
646
+ switch (child.type) {
647
+ case 1:
648
+ switch (child.tagType) {
649
+ case 0:
650
+ ssrProcessElement(child, context);
651
+ break;
652
+ case 1:
653
+ ssrProcessComponent(child, context, parent);
654
+ break;
655
+ case 2:
656
+ ssrProcessSlotOutlet(child, context);
657
+ break;
658
+ case 3: break;
659
+ default:
660
+ context.onError(createSSRCompilerError(67, child.loc));
661
+ return child;
662
+ }
663
+ break;
664
+ case 2:
665
+ context.pushStringPart((0, _vue_shared.escapeHtml)(child.content));
666
+ break;
667
+ case 3:
668
+ if (!disableComment) context.pushStringPart(`<!--${child.content}-->`);
669
+ break;
670
+ case 5:
671
+ context.pushStringPart((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_INTERPOLATE), [child.content]));
672
+ break;
673
+ case 9:
674
+ ssrProcessIf(child, context, disableNestedFragments, disableComment);
675
+ break;
676
+ case 11:
677
+ ssrProcessFor(child, context, disableNestedFragments);
678
+ break;
679
+ case 10: break;
680
+ case 12:
681
+ case 8: break;
682
+ default:
683
+ context.onError(createSSRCompilerError(67, child.loc));
684
+ return child;
685
+ }
686
+ }
687
+ if (asFragment) context.pushStringPart(`<!--]-->`);
1079
688
  }
1080
689
  function processChildrenAsStatement(parent, parentContext, asFragment = false, withSlotScopeId = parentContext.withSlotScopeId) {
1081
- const childContext = createChildContext(parentContext, withSlotScopeId);
1082
- processChildren(parent, childContext, asFragment);
1083
- return compilerDom.createBlockStatement(childContext.body);
690
+ const childContext = createChildContext(parentContext, withSlotScopeId);
691
+ processChildren(parent, childContext, asFragment);
692
+ return (0, _vue_compiler_dom.createBlockStatement)(childContext.body);
1084
693
  }
1085
694
 
695
+ //#endregion
696
+ //#region packages/compiler-ssr/src/transforms/ssrVModel.ts
1086
697
  const ssrTransformModel = (dir, node, context) => {
1087
- const model = dir.exp;
1088
- function checkDuplicatedValue() {
1089
- const value = compilerDom.findProp(node, "value");
1090
- if (value) {
1091
- context.onError(
1092
- compilerDom.createDOMCompilerError(
1093
- 61,
1094
- value.loc
1095
- )
1096
- );
1097
- }
1098
- }
1099
- const processSelectChildren = (children) => {
1100
- children.forEach((child) => {
1101
- if (child.type === 1) {
1102
- processOption(child);
1103
- } else if (child.type === 11) {
1104
- processSelectChildren(child.children);
1105
- } else if (child.type === 9) {
1106
- child.branches.forEach((b) => processSelectChildren(b.children));
1107
- }
1108
- });
1109
- };
1110
- function processOption(plainNode) {
1111
- if (plainNode.tag === "option") {
1112
- if (plainNode.props.findIndex((p) => p.name === "selected") === -1) {
1113
- const value = findValueBinding(plainNode);
1114
- plainNode.ssrCodegenNode.elements.push(
1115
- compilerDom.createConditionalExpression(
1116
- compilerDom.createCallExpression(context.helper(SSR_INCLUDE_BOOLEAN_ATTR), [
1117
- compilerDom.createConditionalExpression(
1118
- compilerDom.createCallExpression(`Array.isArray`, [model]),
1119
- compilerDom.createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
1120
- model,
1121
- value
1122
- ]),
1123
- compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
1124
- model,
1125
- value
1126
- ])
1127
- )
1128
- ]),
1129
- compilerDom.createSimpleExpression(" selected", true),
1130
- compilerDom.createSimpleExpression("", true),
1131
- false
1132
- )
1133
- );
1134
- }
1135
- } else if (plainNode.tag === "optgroup") {
1136
- processSelectChildren(plainNode.children);
1137
- }
1138
- }
1139
- if (node.tagType === 0) {
1140
- const res = { props: [] };
1141
- if (node.tag === "input") {
1142
- const defaultProps = [
1143
- // default value binding for text type inputs
1144
- compilerDom.createObjectProperty(`value`, model)
1145
- ];
1146
- const type = compilerDom.findProp(node, "type");
1147
- if (type) {
1148
- const value = findValueBinding(node);
1149
- if (type.type === 7) {
1150
- res.ssrTagParts = [
1151
- compilerDom.createCallExpression(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
1152
- type.exp,
1153
- model,
1154
- value
1155
- ])
1156
- ];
1157
- } else if (type.value) {
1158
- switch (type.value.content) {
1159
- case "radio":
1160
- res.props = [
1161
- compilerDom.createObjectProperty(
1162
- `checked`,
1163
- compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
1164
- model,
1165
- value
1166
- ])
1167
- )
1168
- ];
1169
- break;
1170
- case "checkbox":
1171
- const trueValueBinding = compilerDom.findProp(node, "true-value");
1172
- if (trueValueBinding) {
1173
- const trueValue = trueValueBinding.type === 6 ? JSON.stringify(trueValueBinding.value.content) : trueValueBinding.exp;
1174
- res.props = [
1175
- compilerDom.createObjectProperty(
1176
- `checked`,
1177
- compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
1178
- model,
1179
- trueValue
1180
- ])
1181
- )
1182
- ];
1183
- } else {
1184
- res.props = [
1185
- compilerDom.createObjectProperty(
1186
- `checked`,
1187
- compilerDom.createConditionalExpression(
1188
- compilerDom.createCallExpression(`Array.isArray`, [model]),
1189
- compilerDom.createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
1190
- model,
1191
- value
1192
- ]),
1193
- model
1194
- )
1195
- )
1196
- ];
1197
- }
1198
- break;
1199
- case "file":
1200
- context.onError(
1201
- compilerDom.createDOMCompilerError(
1202
- 60,
1203
- dir.loc
1204
- )
1205
- );
1206
- break;
1207
- default:
1208
- checkDuplicatedValue();
1209
- res.props = defaultProps;
1210
- break;
1211
- }
1212
- }
1213
- } else if (compilerDom.hasDynamicKeyVBind(node)) ; else {
1214
- checkDuplicatedValue();
1215
- res.props = defaultProps;
1216
- }
1217
- } else if (node.tag === "textarea") {
1218
- checkDuplicatedValue();
1219
- node.children = [compilerDom.createInterpolation(model, model.loc)];
1220
- } else if (node.tag === "select") {
1221
- processSelectChildren(node.children);
1222
- } else {
1223
- context.onError(
1224
- compilerDom.createDOMCompilerError(
1225
- 58,
1226
- dir.loc
1227
- )
1228
- );
1229
- }
1230
- return res;
1231
- } else {
1232
- return compilerDom.transformModel(dir, node, context);
1233
- }
698
+ const model = dir.exp;
699
+ function checkDuplicatedValue() {
700
+ const value = (0, _vue_compiler_dom.findProp)(node, "value");
701
+ if (value) context.onError((0, _vue_compiler_dom.createDOMCompilerError)(61, value.loc));
702
+ }
703
+ const processSelectChildren = (children) => {
704
+ children.forEach((child) => {
705
+ if (child.type === 1) processOption(child);
706
+ else if (child.type === 11) processSelectChildren(child.children);
707
+ else if (child.type === 9) child.branches.forEach((b) => processSelectChildren(b.children));
708
+ });
709
+ };
710
+ function processOption(plainNode) {
711
+ if (plainNode.tag === "option") {
712
+ if (plainNode.props.findIndex((p) => p.name === "selected") === -1) {
713
+ const value = findValueBinding(plainNode);
714
+ plainNode.ssrCodegenNode.elements.push((0, _vue_compiler_dom.createConditionalExpression)((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_INCLUDE_BOOLEAN_ATTR), [(0, _vue_compiler_dom.createConditionalExpression)((0, _vue_compiler_dom.createCallExpression)(`Array.isArray`, [model]), (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_LOOSE_CONTAIN), [model, value]), (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_LOOSE_EQUAL), [model, value]))]), (0, _vue_compiler_dom.createSimpleExpression)(" selected", true), (0, _vue_compiler_dom.createSimpleExpression)("", true), false));
715
+ }
716
+ } else if (plainNode.tag === "optgroup") processSelectChildren(plainNode.children);
717
+ }
718
+ if (node.tagType === 0) {
719
+ const res = { props: [] };
720
+ if (node.tag === "input") {
721
+ const defaultProps = [(0, _vue_compiler_dom.createObjectProperty)(`value`, model)];
722
+ const type = (0, _vue_compiler_dom.findProp)(node, "type");
723
+ if (type) {
724
+ const value = findValueBinding(node);
725
+ if (type.type === 7) res.ssrTagParts = [(0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
726
+ type.exp,
727
+ model,
728
+ value
729
+ ])];
730
+ else if (type.value) switch (type.value.content) {
731
+ case "radio":
732
+ res.props = [(0, _vue_compiler_dom.createObjectProperty)(`checked`, (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_LOOSE_EQUAL), [model, value]))];
733
+ break;
734
+ case "checkbox":
735
+ const trueValueBinding = (0, _vue_compiler_dom.findProp)(node, "true-value");
736
+ if (trueValueBinding) {
737
+ const trueValue = trueValueBinding.type === 6 ? JSON.stringify(trueValueBinding.value.content) : trueValueBinding.exp;
738
+ res.props = [(0, _vue_compiler_dom.createObjectProperty)(`checked`, (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_LOOSE_EQUAL), [model, trueValue]))];
739
+ } else res.props = [(0, _vue_compiler_dom.createObjectProperty)(`checked`, (0, _vue_compiler_dom.createConditionalExpression)((0, _vue_compiler_dom.createCallExpression)(`Array.isArray`, [model]), (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_LOOSE_CONTAIN), [model, value]), model))];
740
+ break;
741
+ case "file":
742
+ context.onError((0, _vue_compiler_dom.createDOMCompilerError)(60, dir.loc));
743
+ break;
744
+ default:
745
+ checkDuplicatedValue();
746
+ res.props = defaultProps;
747
+ break;
748
+ }
749
+ } else if ((0, _vue_compiler_dom.hasDynamicKeyVBind)(node)) {} else {
750
+ checkDuplicatedValue();
751
+ res.props = defaultProps;
752
+ }
753
+ } else if (node.tag === "textarea") {
754
+ checkDuplicatedValue();
755
+ node.children = [(0, _vue_compiler_dom.createInterpolation)(model, model.loc)];
756
+ } else if (node.tag === "select") processSelectChildren(node.children);
757
+ else context.onError((0, _vue_compiler_dom.createDOMCompilerError)(58, dir.loc));
758
+ return res;
759
+ } else return (0, _vue_compiler_dom.transformModel)(dir, node, context);
1234
760
  };
1235
761
  function findValueBinding(node) {
1236
- const valueBinding = compilerDom.findProp(node, "value");
1237
- return valueBinding ? valueBinding.type === 7 ? valueBinding.exp : compilerDom.createSimpleExpression(valueBinding.value.content, true) : compilerDom.createSimpleExpression(`null`, false);
762
+ const valueBinding = (0, _vue_compiler_dom.findProp)(node, "value");
763
+ return valueBinding ? valueBinding.type === 7 ? valueBinding.exp : (0, _vue_compiler_dom.createSimpleExpression)(valueBinding.value.content, true) : (0, _vue_compiler_dom.createSimpleExpression)(`null`, false);
1238
764
  }
1239
765
 
766
+ //#endregion
767
+ //#region packages/compiler-ssr/src/transforms/ssrVShow.ts
1240
768
  const ssrTransformShow = (dir, node, context) => {
1241
- if (!dir.exp) {
1242
- context.onError(
1243
- compilerDom.createDOMCompilerError(62)
1244
- );
1245
- }
1246
- return {
1247
- props: [
1248
- compilerDom.createObjectProperty(
1249
- `style`,
1250
- compilerDom.createConditionalExpression(
1251
- dir.exp,
1252
- compilerDom.createSimpleExpression(`null`, false),
1253
- compilerDom.createObjectExpression([
1254
- compilerDom.createObjectProperty(
1255
- `display`,
1256
- compilerDom.createSimpleExpression(`none`, true)
1257
- )
1258
- ]),
1259
- false
1260
- )
1261
- )
1262
- ]
1263
- };
769
+ if (!dir.exp) context.onError((0, _vue_compiler_dom.createDOMCompilerError)(62));
770
+ return { props: [(0, _vue_compiler_dom.createObjectProperty)(`style`, (0, _vue_compiler_dom.createConditionalExpression)(dir.exp, (0, _vue_compiler_dom.createSimpleExpression)(`null`, false), (0, _vue_compiler_dom.createObjectExpression)([(0, _vue_compiler_dom.createObjectProperty)(`display`, (0, _vue_compiler_dom.createSimpleExpression)(`none`, true))]), false))] };
1264
771
  };
1265
772
 
773
+ //#endregion
774
+ //#region packages/compiler-ssr/src/transforms/ssrInjectFallthroughAttrs.ts
1266
775
  const ssrInjectFallthroughAttrs = (node, context) => {
1267
- if (node.type === 0) {
1268
- context.identifiers._attrs = 1;
1269
- }
1270
- if (node.type === 1 && node.tagType === 1 && (node.tag === "transition" || node.tag === "Transition" || node.tag === "KeepAlive" || node.tag === "keep-alive")) {
1271
- const rootChildren = compilerDom.filterNonCommentChildren(context.root);
1272
- if (rootChildren.length === 1 && rootChildren[0] === node) {
1273
- if (compilerDom.hasSingleChild(node)) {
1274
- injectFallthroughAttrs(node.children[0]);
1275
- }
1276
- return;
1277
- }
1278
- }
1279
- const parent = context.parent;
1280
- if (!parent || parent.type !== 0) {
1281
- return;
1282
- }
1283
- if (node.type === 10 && compilerDom.hasSingleChild(node)) {
1284
- if (compilerDom.isSingleIfBlock(parent)) {
1285
- injectFallthroughAttrs(node.children[0]);
1286
- }
1287
- } else if (compilerDom.hasSingleChild(parent)) {
1288
- injectFallthroughAttrs(node);
1289
- }
776
+ if (node.type === 0) context.identifiers._attrs = 1;
777
+ if (node.type === 1 && node.tagType === 1 && (node.tag === "transition" || node.tag === "Transition" || node.tag === "KeepAlive" || node.tag === "keep-alive")) {
778
+ const rootChildren = (0, _vue_compiler_dom.filterNonCommentChildren)(context.root);
779
+ if (rootChildren.length === 1 && rootChildren[0] === node) {
780
+ if ((0, _vue_compiler_dom.hasSingleChild)(node)) injectFallthroughAttrs(node.children[0]);
781
+ return;
782
+ }
783
+ }
784
+ const parent = context.parent;
785
+ if (!parent || parent.type !== 0) return;
786
+ if (node.type === 10 && (0, _vue_compiler_dom.hasSingleChild)(node)) {
787
+ if ((0, _vue_compiler_dom.isSingleIfBlock)(parent)) injectFallthroughAttrs(node.children[0]);
788
+ } else if ((0, _vue_compiler_dom.hasSingleChild)(parent)) injectFallthroughAttrs(node);
1290
789
  };
1291
790
  function injectFallthroughAttrs(node) {
1292
- if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !compilerDom.findDir(node, "for")) {
1293
- node.props.push({
1294
- type: 7,
1295
- name: "bind",
1296
- arg: void 0,
1297
- exp: compilerDom.createSimpleExpression(`_attrs`, false),
1298
- modifiers: [],
1299
- loc: compilerDom.locStub
1300
- });
1301
- }
791
+ if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !(0, _vue_compiler_dom.findDir)(node, "for")) node.props.push({
792
+ type: 7,
793
+ name: "bind",
794
+ arg: void 0,
795
+ exp: (0, _vue_compiler_dom.createSimpleExpression)(`_attrs`, false),
796
+ modifiers: [],
797
+ loc: _vue_compiler_dom.locStub
798
+ });
1302
799
  }
1303
800
 
801
+ //#endregion
802
+ //#region packages/compiler-ssr/src/transforms/ssrInjectCssVars.ts
1304
803
  const ssrInjectCssVars = (node, context) => {
1305
- if (!context.ssrCssVars) {
1306
- return;
1307
- }
1308
- if (node.type === 0) {
1309
- context.identifiers._cssVars = 1;
1310
- }
1311
- const parent = context.parent;
1312
- if (!parent || parent.type !== 0) {
1313
- return;
1314
- }
1315
- if (node.type === 10) {
1316
- for (const child of node.children) {
1317
- injectCssVars(child);
1318
- }
1319
- } else {
1320
- injectCssVars(node);
1321
- }
804
+ if (!context.ssrCssVars) return;
805
+ if (node.type === 0) context.identifiers._cssVars = 1;
806
+ const parent = context.parent;
807
+ if (!parent || parent.type !== 0) return;
808
+ if (node.type === 10) for (const child of node.children) injectCssVars(child);
809
+ else injectCssVars(node);
1322
810
  };
1323
811
  function injectCssVars(node) {
1324
- if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !compilerDom.findDir(node, "for")) {
1325
- if (node.tag === "suspense" || node.tag === "Suspense") {
1326
- for (const child of node.children) {
1327
- if (child.type === 1 && child.tagType === 3) {
1328
- child.children.forEach(injectCssVars);
1329
- } else {
1330
- injectCssVars(child);
1331
- }
1332
- }
1333
- } else {
1334
- node.props.push({
1335
- type: 7,
1336
- name: "bind",
1337
- arg: void 0,
1338
- exp: compilerDom.createSimpleExpression(`_cssVars`, false),
1339
- modifiers: [],
1340
- loc: compilerDom.locStub
1341
- });
1342
- }
1343
- }
812
+ if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !(0, _vue_compiler_dom.findDir)(node, "for")) if (node.tag === "suspense" || node.tag === "Suspense") for (const child of node.children) if (child.type === 1 && child.tagType === 3) child.children.forEach(injectCssVars);
813
+ else injectCssVars(child);
814
+ else node.props.push({
815
+ type: 7,
816
+ name: "bind",
817
+ arg: void 0,
818
+ exp: (0, _vue_compiler_dom.createSimpleExpression)(`_cssVars`, false),
819
+ modifiers: [],
820
+ loc: _vue_compiler_dom.locStub
821
+ });
1344
822
  }
1345
823
 
824
+ //#endregion
825
+ //#region packages/compiler-ssr/src/index.ts
1346
826
  function compile(source, options = {}) {
1347
- options = {
1348
- ...options,
1349
- ...compilerDom.parserOptions,
1350
- ssr: true,
1351
- inSSR: true,
1352
- scopeId: options.mode === "function" ? null : options.scopeId,
1353
- // always prefix since compiler-ssr doesn't have size concern
1354
- prefixIdentifiers: true,
1355
- // disable optimizations that are unnecessary for ssr
1356
- cacheHandlers: false,
1357
- hoistStatic: false
1358
- };
1359
- const ast = typeof source === "string" ? compilerDom.baseParse(source, options) : source;
1360
- rawOptionsMap.set(ast, options);
1361
- compilerDom.transform(ast, {
1362
- ...options,
1363
- hoistStatic: false,
1364
- nodeTransforms: [
1365
- compilerDom.transformVBindShorthand,
1366
- ssrTransformIf,
1367
- ssrTransformFor,
1368
- compilerDom.trackVForSlotScopes,
1369
- compilerDom.transformExpression,
1370
- ssrTransformSlotOutlet,
1371
- ssrInjectFallthroughAttrs,
1372
- ssrInjectCssVars,
1373
- ssrTransformElement,
1374
- ssrTransformComponent,
1375
- compilerDom.trackSlotScopes,
1376
- compilerDom.transformStyle,
1377
- ...options.nodeTransforms || []
1378
- // user transforms
1379
- ],
1380
- directiveTransforms: {
1381
- // reusing core v-bind
1382
- bind: compilerDom.transformBind,
1383
- on: compilerDom.transformOn,
1384
- // model and show have dedicated SSR handling
1385
- model: ssrTransformModel,
1386
- show: ssrTransformShow,
1387
- // the following are ignored during SSR
1388
- // on: noopDirectiveTransform,
1389
- cloak: compilerDom.noopDirectiveTransform,
1390
- once: compilerDom.noopDirectiveTransform,
1391
- memo: compilerDom.noopDirectiveTransform,
1392
- ...options.directiveTransforms || {}
1393
- // user transforms
1394
- }
1395
- });
1396
- ssrCodegenTransform(ast, options);
1397
- return compilerDom.generate(ast, options);
827
+ options = {
828
+ ...options,
829
+ ..._vue_compiler_dom.parserOptions,
830
+ ssr: true,
831
+ inSSR: true,
832
+ scopeId: options.mode === "function" ? null : options.scopeId,
833
+ prefixIdentifiers: true,
834
+ cacheHandlers: false,
835
+ hoistStatic: false
836
+ };
837
+ const ast = typeof source === "string" ? (0, _vue_compiler_dom.baseParse)(source, options) : source;
838
+ rawOptionsMap.set(ast, options);
839
+ (0, _vue_compiler_dom.transform)(ast, {
840
+ ...options,
841
+ hoistStatic: false,
842
+ nodeTransforms: [
843
+ _vue_compiler_dom.transformVBindShorthand,
844
+ ssrTransformIf,
845
+ ssrTransformFor,
846
+ _vue_compiler_dom.trackVForSlotScopes,
847
+ _vue_compiler_dom.transformExpression,
848
+ ssrTransformSlotOutlet,
849
+ ssrInjectFallthroughAttrs,
850
+ ssrInjectCssVars,
851
+ ssrTransformElement,
852
+ ssrTransformComponent,
853
+ _vue_compiler_dom.trackSlotScopes,
854
+ _vue_compiler_dom.transformStyle,
855
+ ...options.nodeTransforms || []
856
+ ],
857
+ directiveTransforms: {
858
+ bind: _vue_compiler_dom.transformBind,
859
+ on: _vue_compiler_dom.transformOn,
860
+ model: ssrTransformModel,
861
+ show: ssrTransformShow,
862
+ cloak: _vue_compiler_dom.noopDirectiveTransform,
863
+ once: _vue_compiler_dom.noopDirectiveTransform,
864
+ memo: _vue_compiler_dom.noopDirectiveTransform,
865
+ ...options.directiveTransforms || {}
866
+ }
867
+ });
868
+ ssrCodegenTransform(ast, options);
869
+ return (0, _vue_compiler_dom.generate)(ast, options);
1398
870
  }
1399
871
 
1400
- exports.compile = compile;
872
+ //#endregion
873
+ exports.compile = compile;