871 lines
40 KiB
JavaScript
871 lines
40 KiB
JavaScript
/**
|
|
* @vue/compiler-ssr v3.6.0-rc.10
|
|
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
|
* @license MIT
|
|
**/
|
|
Object.defineProperties(exports, {
|
|
__esModule: { value: true },
|
|
[Symbol.toStringTag]: { value: "Module" }
|
|
});
|
|
let _vue_compiler_dom = require("@vue/compiler-dom");
|
|
let _vue_shared = require("@vue/shared");
|
|
//#region packages/compiler-ssr/src/runtimeHelpers.ts
|
|
const SSR_INTERPOLATE = Symbol(`ssrInterpolate`);
|
|
const SSR_RENDER_VNODE = Symbol(`ssrRenderVNode`);
|
|
const SSR_RENDER_COMPONENT = Symbol(`ssrRenderComponent`);
|
|
const SSR_RENDER_SLOT = Symbol(`ssrRenderSlot`);
|
|
const SSR_RENDER_SLOT_INNER = Symbol(`ssrRenderSlotInner`);
|
|
const SSR_RENDER_CLASS = Symbol(`ssrRenderClass`);
|
|
const SSR_RENDER_STYLE = Symbol(`ssrRenderStyle`);
|
|
const SSR_RENDER_ATTRS = Symbol(`ssrRenderAttrs`);
|
|
const SSR_RENDER_ATTR = Symbol(`ssrRenderAttr`);
|
|
const SSR_RENDER_DYNAMIC_ATTR = Symbol(`ssrRenderDynamicAttr`);
|
|
const SSR_RENDER_LIST = Symbol(`ssrRenderList`);
|
|
const SSR_INCLUDE_BOOLEAN_ATTR = Symbol(`ssrIncludeBooleanAttr`);
|
|
const SSR_LOOSE_EQUAL = Symbol(`ssrLooseEqual`);
|
|
const SSR_LOOSE_CONTAIN = Symbol(`ssrLooseContain`);
|
|
const SSR_RENDER_DYNAMIC_MODEL = Symbol(`ssrRenderDynamicModel`);
|
|
const SSR_GET_DYNAMIC_MODEL_PROPS = Symbol(`ssrGetDynamicModelProps`);
|
|
const SSR_RENDER_TELEPORT = Symbol(`ssrRenderTeleport`);
|
|
const SSR_RENDER_SUSPENSE = Symbol(`ssrRenderSuspense`);
|
|
const SSR_GET_DIRECTIVE_PROPS = Symbol(`ssrGetDirectiveProps`);
|
|
const ssrHelpers = {
|
|
[SSR_INTERPOLATE]: `ssrInterpolate`,
|
|
[SSR_RENDER_VNODE]: `ssrRenderVNode`,
|
|
[SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
|
|
[SSR_RENDER_SLOT]: `ssrRenderSlot`,
|
|
[SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
|
|
[SSR_RENDER_CLASS]: `ssrRenderClass`,
|
|
[SSR_RENDER_STYLE]: `ssrRenderStyle`,
|
|
[SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
|
|
[SSR_RENDER_ATTR]: `ssrRenderAttr`,
|
|
[SSR_RENDER_DYNAMIC_ATTR]: `ssrRenderDynamicAttr`,
|
|
[SSR_RENDER_LIST]: `ssrRenderList`,
|
|
[SSR_INCLUDE_BOOLEAN_ATTR]: `ssrIncludeBooleanAttr`,
|
|
[SSR_LOOSE_EQUAL]: `ssrLooseEqual`,
|
|
[SSR_LOOSE_CONTAIN]: `ssrLooseContain`,
|
|
[SSR_RENDER_DYNAMIC_MODEL]: `ssrRenderDynamicModel`,
|
|
[SSR_GET_DYNAMIC_MODEL_PROPS]: `ssrGetDynamicModelProps`,
|
|
[SSR_RENDER_TELEPORT]: `ssrRenderTeleport`,
|
|
[SSR_RENDER_SUSPENSE]: `ssrRenderSuspense`,
|
|
[SSR_GET_DIRECTIVE_PROPS]: `ssrGetDirectiveProps`
|
|
};
|
|
(0, _vue_compiler_dom.registerRuntimeHelpers)(ssrHelpers);
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrVIf.ts
|
|
const ssrTransformIf = (0, _vue_compiler_dom.createStructuralDirectiveTransform)(/^(?:if|else|else-if)$/, _vue_compiler_dom.processIf);
|
|
function ssrProcessIf(node, context, disableNestedFragments = false, disableComment = false) {
|
|
const [rootBranch] = node.branches;
|
|
const ifStatement = (0, _vue_compiler_dom.createIfStatement)(rootBranch.condition, processIfBranch(rootBranch, context, disableNestedFragments));
|
|
context.pushStatement(ifStatement);
|
|
let currentIf = ifStatement;
|
|
for (let i = 1; i < node.branches.length; i++) {
|
|
const branch = node.branches[i];
|
|
const branchBlockStatement = processIfBranch(branch, context, disableNestedFragments);
|
|
if (branch.condition) currentIf = currentIf.alternate = (0, _vue_compiler_dom.createIfStatement)(branch.condition, branchBlockStatement);
|
|
else currentIf.alternate = branchBlockStatement;
|
|
}
|
|
if (!currentIf.alternate && (!disableComment || context.options.vapor)) currentIf.alternate = (0, _vue_compiler_dom.createBlockStatement)([(0, _vue_compiler_dom.createCallExpression)(`_push`, ["`<!---->`"])]);
|
|
}
|
|
function processIfBranch(branch, context, disableNestedFragments = false) {
|
|
const { children } = branch;
|
|
return processChildrenAsStatement(branch, context, !disableNestedFragments && (children.length !== 1 || children[0].type !== 1) && !(children.length === 1 && children[0].type === 11));
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrVFor.ts
|
|
const ssrTransformFor = (0, _vue_compiler_dom.createStructuralDirectiveTransform)("for", _vue_compiler_dom.processFor);
|
|
function ssrProcessFor(node, context, disableNestedFragments = false) {
|
|
const needFragmentWrapper = !disableNestedFragments && (node.children.length !== 1 || node.children[0].type !== 1);
|
|
const renderLoop = (0, _vue_compiler_dom.createFunctionExpression)((0, _vue_compiler_dom.createForLoopParams)(node.parseResult));
|
|
renderLoop.body = processChildrenAsStatement(node, context, needFragmentWrapper);
|
|
if (!disableNestedFragments) context.pushStringPart(`<!--[-->`);
|
|
context.pushStatement((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_LIST), [node.source, renderLoop]));
|
|
if (!disableNestedFragments) context.pushStringPart(`<!--]-->`);
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/errors.ts
|
|
function createSSRCompilerError(code, loc) {
|
|
return (0, _vue_compiler_dom.createCompilerError)(code, loc, SSRErrorMessages);
|
|
}
|
|
const SSRErrorMessages = {
|
|
[65]: `Unsafe attribute name for SSR.`,
|
|
[66]: `Missing the 'to' prop on teleport element.`,
|
|
[67]: `Invalid AST node during SSR transform.`
|
|
};
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrTransformTeleport.ts
|
|
function ssrProcessTeleport(node, context) {
|
|
const targetProp = (0, _vue_compiler_dom.findProp)(node, "to");
|
|
if (!targetProp) {
|
|
context.onError(createSSRCompilerError(66, node.loc));
|
|
return;
|
|
}
|
|
let target;
|
|
if (targetProp.type === 6) target = targetProp.value && (0, _vue_compiler_dom.createSimpleExpression)(targetProp.value.content, true);
|
|
else target = targetProp.exp;
|
|
if (!target) {
|
|
context.onError(createSSRCompilerError(66, targetProp.loc));
|
|
return;
|
|
}
|
|
const disabledProp = (0, _vue_compiler_dom.findProp)(node, "disabled", false, true);
|
|
const disabled = disabledProp ? disabledProp.type === 6 ? `true` : disabledProp.exp || `false` : `false`;
|
|
const contentRenderFn = (0, _vue_compiler_dom.createFunctionExpression)([`_push`], void 0, true, false, node.loc);
|
|
contentRenderFn.body = processChildrenAsStatement(node, context);
|
|
context.pushStatement((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_TELEPORT), [
|
|
`_push`,
|
|
contentRenderFn,
|
|
target,
|
|
disabled,
|
|
`_parent`
|
|
]));
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrTransformSuspense.ts
|
|
const wipMap$3 = /* @__PURE__ */ new WeakMap();
|
|
function ssrTransformSuspense(node, context) {
|
|
return () => {
|
|
if (node.children.length) {
|
|
const wipEntry = {
|
|
slotsExp: null,
|
|
wipSlots: []
|
|
};
|
|
wipMap$3.set(node, wipEntry);
|
|
wipEntry.slotsExp = (0, _vue_compiler_dom.buildSlots)(node, context, (_props, _vForExp, children, loc) => {
|
|
const fn = (0, _vue_compiler_dom.createFunctionExpression)([], void 0, true, false, loc);
|
|
wipEntry.wipSlots.push({
|
|
fn,
|
|
children
|
|
});
|
|
return fn;
|
|
}).slots;
|
|
}
|
|
};
|
|
}
|
|
function ssrProcessSuspense(node, context) {
|
|
const wipEntry = wipMap$3.get(node);
|
|
if (!wipEntry) return;
|
|
const { slotsExp, wipSlots } = wipEntry;
|
|
for (let i = 0; i < wipSlots.length; i++) {
|
|
const slot = wipSlots[i];
|
|
slot.fn.body = processChildrenAsStatement(slot, context);
|
|
}
|
|
context.pushStatement((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_SUSPENSE), [`_push`, slotsExp]));
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrTransformElement.ts
|
|
const rawChildrenMap = /* @__PURE__ */ new WeakMap();
|
|
const ssrTransformElement = (node, context) => {
|
|
if (node.type !== 1 || node.tagType !== 0) return;
|
|
return function ssrPostTransformElement() {
|
|
const openTag = [`<${node.tag}`];
|
|
const needTagForRuntime = node.tag === "textarea" || node.tag.indexOf("-") > 0;
|
|
const hasDynamicVBind = (0, _vue_compiler_dom.hasDynamicKeyVBind)(node);
|
|
const hasCustomDir = node.props.some((p) => p.type === 7 && !(0, _vue_shared.isBuiltInDirective)(p.name));
|
|
const vShowPropIndex = node.props.findIndex((i) => i.type === 7 && i.name === "show");
|
|
if (vShowPropIndex !== -1) {
|
|
const vShowProp = node.props[vShowPropIndex];
|
|
node.props.splice(vShowPropIndex, 1);
|
|
node.props.push(vShowProp);
|
|
}
|
|
const needMergeProps = hasDynamicVBind || hasCustomDir;
|
|
if (needMergeProps) {
|
|
const { props, directives } = (0, _vue_compiler_dom.buildProps)(node, context, node.props, false, false, true);
|
|
if (props || directives.length) {
|
|
const mergedProps = buildSSRProps(props, directives, context);
|
|
const propsExp = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_ATTRS), [mergedProps]);
|
|
if (node.tag === "textarea") {
|
|
const existingText = node.children[0];
|
|
if (!hasContentOverrideDirective(node) && (!existingText || existingText.type !== 5)) {
|
|
const tempId = `_temp${context.temps++}`;
|
|
propsExp.arguments = [(0, _vue_compiler_dom.createAssignmentExpression)((0, _vue_compiler_dom.createSimpleExpression)(tempId, false), mergedProps)];
|
|
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)]));
|
|
}
|
|
} else if (node.tag === "input") {
|
|
const vModel = findVModel(node);
|
|
if (vModel) {
|
|
const tempId = `_temp${context.temps++}`;
|
|
const tempExp = (0, _vue_compiler_dom.createSimpleExpression)(tempId, false);
|
|
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])])])];
|
|
}
|
|
} else if (directives.length && !node.children.length) {
|
|
if (!hasContentOverrideDirective(node)) {
|
|
const tempId = `_temp${context.temps++}`;
|
|
propsExp.arguments = [(0, _vue_compiler_dom.createAssignmentExpression)((0, _vue_compiler_dom.createSimpleExpression)(tempId, false), mergedProps)];
|
|
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));
|
|
}
|
|
}
|
|
if (needTagForRuntime) propsExp.arguments.push(`"${node.tag}"`);
|
|
openTag.push(propsExp);
|
|
}
|
|
}
|
|
let dynamicClassBinding = void 0;
|
|
let staticClassBinding = void 0;
|
|
let dynamicStyleBinding = void 0;
|
|
for (let i = 0; i < node.props.length; i++) {
|
|
const prop = node.props[i];
|
|
if (node.tag === "input" && isTrueFalseValue(prop)) continue;
|
|
if (prop.type === 7) {
|
|
if (prop.name === "html" && prop.exp) rawChildrenMap.set(node, (0, _vue_compiler_dom.createCompoundExpression)([
|
|
`(`,
|
|
prop.exp,
|
|
`) ?? ''`
|
|
]));
|
|
else if (prop.name === "text" && prop.exp) node.children = [(0, _vue_compiler_dom.createInterpolation)(prop.exp, prop.loc)];
|
|
else if (prop.name === "slot") context.onError((0, _vue_compiler_dom.createCompilerError)(40, prop.loc));
|
|
else if (isTextareaWithValue(node, prop) && prop.exp) {
|
|
if (!needMergeProps) node.children = [(0, _vue_compiler_dom.createInterpolation)(prop.exp, prop.loc)];
|
|
} else if (!needMergeProps && prop.name !== "on") {
|
|
const directiveTransform = context.directiveTransforms[prop.name];
|
|
if (directiveTransform) {
|
|
const { props, ssrTagParts } = directiveTransform(prop, node, context);
|
|
if (ssrTagParts) openTag.push(...ssrTagParts);
|
|
for (let j = 0; j < props.length; j++) {
|
|
const { key, value } = props[j];
|
|
if ((0, _vue_compiler_dom.isStaticExp)(key)) {
|
|
let attrName = key.content;
|
|
if (attrName === "key" || attrName === "ref") continue;
|
|
if (attrName === "class") openTag.push(` class="`, dynamicClassBinding = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_CLASS), [value]), `"`);
|
|
else if (attrName === "style") {
|
|
if (dynamicStyleBinding) mergeCall(dynamicStyleBinding, value);
|
|
else openTag.push(` style="`, dynamicStyleBinding = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_STYLE), [value]), `"`);
|
|
} else {
|
|
attrName = node.tag.indexOf("-") > 0 ? attrName : _vue_shared.propsToAttrMap[attrName] || attrName.toLowerCase();
|
|
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));
|
|
else if (attrName === "hidden") openTag.push((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_DYNAMIC_ATTR), [key, value]));
|
|
else if ((0, _vue_shared.isSSRSafeAttrName)(attrName)) openTag.push((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_ATTR), [key, value]));
|
|
else context.onError(createSSRCompilerError(65, key.loc));
|
|
}
|
|
} else {
|
|
const args = [key, value];
|
|
if (needTagForRuntime) args.push(`"${node.tag}"`);
|
|
openTag.push((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_DYNAMIC_ATTR), args));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const name = prop.name;
|
|
if (node.tag === "textarea" && name === "value" && prop.value) rawChildrenMap.set(node, (0, _vue_shared.escapeHtml)(prop.value.content));
|
|
else if (!needMergeProps) {
|
|
if (name === "key" || name === "ref") continue;
|
|
if (name === "class" && prop.value) staticClassBinding = JSON.stringify(prop.value.content);
|
|
openTag.push(` ${prop.name}` + (prop.value ? `="${(0, _vue_shared.escapeHtml)(prop.value.content)}"` : ``));
|
|
}
|
|
}
|
|
}
|
|
if (dynamicClassBinding && staticClassBinding) {
|
|
mergeCall(dynamicClassBinding, staticClassBinding);
|
|
removeStaticBinding(openTag, "class");
|
|
}
|
|
if (context.scopeId) openTag.push(` ${context.scopeId}`);
|
|
node.ssrCodegenNode = (0, _vue_compiler_dom.createTemplateLiteral)(openTag);
|
|
};
|
|
};
|
|
function buildSSRProps(props, directives, context) {
|
|
let mergePropsArgs = [];
|
|
if (props) {
|
|
if (props.type === 14) mergePropsArgs = props.arguments;
|
|
else mergePropsArgs.push(props);
|
|
}
|
|
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]));
|
|
return mergePropsArgs.length > 1 ? (0, _vue_compiler_dom.createCallExpression)(context.helper(_vue_compiler_dom.MERGE_PROPS), mergePropsArgs) : mergePropsArgs[0];
|
|
}
|
|
function isTrueFalseValue(prop) {
|
|
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");
|
|
else return prop.name === "true-value" || prop.name === "false-value";
|
|
}
|
|
function isTextareaWithValue(node, prop) {
|
|
return !!(node.tag === "textarea" && prop.name === "bind" && (0, _vue_compiler_dom.isStaticArgOf)(prop.arg, "value"));
|
|
}
|
|
function mergeCall(call, arg) {
|
|
const existing = call.arguments[0];
|
|
if (existing.type === 17) existing.elements.push(arg);
|
|
else call.arguments[0] = (0, _vue_compiler_dom.createArrayExpression)([existing, arg]);
|
|
}
|
|
function removeStaticBinding(tag, binding) {
|
|
const regExp = new RegExp(`^ ${binding}=".+"$`);
|
|
const i = tag.findIndex((e) => typeof e === "string" && regExp.test(e));
|
|
if (i > -1) tag.splice(i, 1);
|
|
}
|
|
function findVModel(node) {
|
|
return node.props.find((p) => p.type === 7 && p.name === "model" && p.exp);
|
|
}
|
|
function hasContentOverrideDirective(node) {
|
|
return !!(0, _vue_compiler_dom.findDir)(node, "text") || !!(0, _vue_compiler_dom.findDir)(node, "html");
|
|
}
|
|
function ssrProcessElement(node, context) {
|
|
const isVoidTag = context.options.isVoidTag || _vue_shared.NO;
|
|
const elementsToAdd = node.ssrCodegenNode.elements;
|
|
for (let j = 0; j < elementsToAdd.length; j++) context.pushStringPart(elementsToAdd[j]);
|
|
if (context.withSlotScopeId) context.pushStringPart((0, _vue_compiler_dom.createSimpleExpression)(`_scopeId`, false));
|
|
context.pushStringPart(`>`);
|
|
const rawChildren = rawChildrenMap.get(node);
|
|
if (rawChildren) context.pushStringPart(rawChildren);
|
|
else if (node.children.length) processChildren(node, context);
|
|
if (!isVoidTag(node.tag)) context.pushStringPart(`</${node.tag}>`);
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrTransformTransitionGroup.ts
|
|
const wipMap$2 = /* @__PURE__ */ new WeakMap();
|
|
function ssrTransformTransitionGroup(node, context) {
|
|
return () => {
|
|
const tag = (0, _vue_compiler_dom.findProp)(node, "tag");
|
|
if (tag) {
|
|
const otherProps = node.props.filter((p) => p !== tag);
|
|
const { props, directives } = (0, _vue_compiler_dom.buildProps)(node, context, otherProps, true, false, true);
|
|
let propsExp = null;
|
|
if (props || directives.length) propsExp = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_ATTRS), [buildSSRProps(props, directives, context)]);
|
|
wipMap$2.set(node, {
|
|
tag,
|
|
propsExp,
|
|
scopeId: context.scopeId || null
|
|
});
|
|
}
|
|
};
|
|
}
|
|
function ssrProcessTransitionGroup(node, context) {
|
|
const entry = wipMap$2.get(node);
|
|
const disableNestedFragments = !context.options.vapor;
|
|
if (entry) {
|
|
const { tag, propsExp, scopeId } = entry;
|
|
if (tag.type === 7) {
|
|
context.pushStringPart(`<`);
|
|
context.pushStringPart(tag.exp);
|
|
if (propsExp) context.pushStringPart(propsExp);
|
|
if (scopeId) context.pushStringPart(` ${scopeId}`);
|
|
context.pushStringPart(`>`);
|
|
processChildren(
|
|
node,
|
|
context,
|
|
false,
|
|
/**
|
|
* TransitionGroup has the special runtime behavior of flattening and
|
|
* concatenating all children into a single fragment (in order for them to
|
|
* be patched using the same key map) so we need to account for that here
|
|
* by disabling nested fragment wrappers from being generated.
|
|
*/
|
|
disableNestedFragments,
|
|
/**
|
|
* TransitionGroup filters out comment children at runtime and thus
|
|
* doesn't expect comments to be present during hydration. We need to
|
|
* account for that by disabling the empty comment that is otherwise
|
|
* rendered for a falsy v-if that has no v-else specified. (#6715)
|
|
*/
|
|
true
|
|
);
|
|
context.pushStringPart(`</`);
|
|
context.pushStringPart(tag.exp);
|
|
context.pushStringPart(`>`);
|
|
} else {
|
|
context.pushStringPart(`<${tag.value.content}`);
|
|
if (propsExp) context.pushStringPart(propsExp);
|
|
if (scopeId) context.pushStringPart(` ${scopeId}`);
|
|
context.pushStringPart(`>`);
|
|
processChildren(node, context, false, disableNestedFragments, true);
|
|
context.pushStringPart(`</${tag.value.content}>`);
|
|
}
|
|
} else processChildren(node, context, true, disableNestedFragments, true);
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrTransformTransition.ts
|
|
const wipMap$1 = /* @__PURE__ */ new WeakMap();
|
|
function ssrTransformTransition(node, context) {
|
|
return () => {
|
|
const appear = (0, _vue_compiler_dom.findProp)(node, "appear", false, true);
|
|
wipMap$1.set(node, !!appear);
|
|
};
|
|
}
|
|
function ssrProcessTransition(node, context) {
|
|
node.children = node.children.filter((c) => c.type !== 3);
|
|
if (wipMap$1.get(node)) {
|
|
context.pushStringPart(`<template>`);
|
|
processChildren(node, context, false, true);
|
|
context.pushStringPart(`</template>`);
|
|
} else processChildren(node, context, false, true);
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrTransformComponent.ts
|
|
const wipMap = /* @__PURE__ */ new WeakMap();
|
|
const WIP_SLOT = Symbol();
|
|
const componentTypeMap = /* @__PURE__ */ new WeakMap();
|
|
const ssrTransformComponent = (node, context) => {
|
|
if (node.type !== 1 || node.tagType !== 1) return;
|
|
const component = (0, _vue_compiler_dom.resolveComponentType)(node, context, true);
|
|
const isDynamicComponent = (0, _vue_shared.isObject)(component) && component.callee === _vue_compiler_dom.RESOLVE_DYNAMIC_COMPONENT;
|
|
componentTypeMap.set(node, component);
|
|
if ((0, _vue_shared.isSymbol)(component)) {
|
|
if (component === _vue_compiler_dom.SUSPENSE) return ssrTransformSuspense(node, context);
|
|
else if (component === _vue_compiler_dom.TRANSITION_GROUP) return ssrTransformTransitionGroup(node, context);
|
|
else if (component === _vue_compiler_dom.TRANSITION) return ssrTransformTransition(node, context);
|
|
return;
|
|
}
|
|
const vnodeBranches = [];
|
|
const clonedNode = clone(node);
|
|
return function ssrPostTransformComponent() {
|
|
if (clonedNode.children.length) (0, _vue_compiler_dom.buildSlots)(clonedNode, context, (props, vFor, children) => {
|
|
vnodeBranches.push(createVNodeSlotBranch(props, vFor, children, context));
|
|
return (0, _vue_compiler_dom.createFunctionExpression)(void 0);
|
|
});
|
|
let propsExp = `null`;
|
|
if (node.props.length) {
|
|
const { props, directives } = (0, _vue_compiler_dom.buildProps)(node, context, void 0, true, isDynamicComponent);
|
|
if (props || directives.length) propsExp = buildSSRProps(props, directives, context);
|
|
}
|
|
const wipEntries = [];
|
|
wipMap.set(node, wipEntries);
|
|
const buildSSRSlotFn = (props, _vForExp, children, loc) => {
|
|
const param0 = props && (0, _vue_compiler_dom.stringifyExpression)(props) || `_`;
|
|
const fn = (0, _vue_compiler_dom.createFunctionExpression)([
|
|
param0,
|
|
`_push`,
|
|
`_parent`,
|
|
`_scopeId`
|
|
], void 0, true, true, loc);
|
|
wipEntries.push({
|
|
type: WIP_SLOT,
|
|
fn,
|
|
children,
|
|
vnodeBranch: vnodeBranches[wipEntries.length]
|
|
});
|
|
return fn;
|
|
};
|
|
const slots = node.children.length ? (0, _vue_compiler_dom.buildSlots)(node, context, buildSSRSlotFn).slots : `null`;
|
|
if (typeof component !== "string") node.ssrCodegenNode = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_VNODE), [
|
|
`_push`,
|
|
(0, _vue_compiler_dom.createCallExpression)(context.helper(_vue_compiler_dom.CREATE_VNODE), [
|
|
component,
|
|
propsExp,
|
|
slots
|
|
]),
|
|
`_parent`
|
|
]);
|
|
else node.ssrCodegenNode = (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_COMPONENT), [
|
|
component,
|
|
propsExp,
|
|
slots,
|
|
`_parent`
|
|
]);
|
|
};
|
|
};
|
|
function ssrProcessComponent(node, context, parent) {
|
|
const component = componentTypeMap.get(node);
|
|
if (!node.ssrCodegenNode) {
|
|
if (component === _vue_compiler_dom.TELEPORT) return ssrProcessTeleport(node, context);
|
|
else if (component === _vue_compiler_dom.SUSPENSE) return ssrProcessSuspense(node, context);
|
|
else if (component === _vue_compiler_dom.TRANSITION_GROUP) return ssrProcessTransitionGroup(node, context);
|
|
else {
|
|
if (parent.type === WIP_SLOT) context.pushStringPart(``);
|
|
if (component === _vue_compiler_dom.TRANSITION) return ssrProcessTransition(node, context);
|
|
processChildren(node, context);
|
|
}
|
|
} else {
|
|
const wipEntries = wipMap.get(node) || [];
|
|
for (let i = 0; i < wipEntries.length; i++) {
|
|
const { fn, vnodeBranch } = wipEntries[i];
|
|
fn.body = (0, _vue_compiler_dom.createIfStatement)((0, _vue_compiler_dom.createSimpleExpression)(`_push`, false), processChildrenAsStatement(wipEntries[i], context, false, true), vnodeBranch);
|
|
}
|
|
if (context.withSlotScopeId) node.ssrCodegenNode.arguments.push(`_scopeId`);
|
|
if (typeof component === "string") context.pushStatement((0, _vue_compiler_dom.createCallExpression)(`_push`, [node.ssrCodegenNode]));
|
|
else context.pushStatement(node.ssrCodegenNode);
|
|
}
|
|
}
|
|
const rawOptionsMap = /* @__PURE__ */ new WeakMap();
|
|
const [baseNodeTransforms, baseDirectiveTransforms] = (0, _vue_compiler_dom.getBaseTransformPreset)(true);
|
|
const vnodeNodeTransforms = [...baseNodeTransforms, ..._vue_compiler_dom.DOMNodeTransforms];
|
|
const vnodeDirectiveTransforms = {
|
|
...baseDirectiveTransforms,
|
|
..._vue_compiler_dom.DOMDirectiveTransforms
|
|
};
|
|
function createVNodeSlotBranch(slotProps, vFor, children, parentContext) {
|
|
const rawOptions = rawOptionsMap.get(parentContext.root);
|
|
const subOptions = {
|
|
...rawOptions,
|
|
nodeTransforms: [...vnodeNodeTransforms, ...rawOptions.nodeTransforms || []],
|
|
directiveTransforms: {
|
|
...vnodeDirectiveTransforms,
|
|
...rawOptions.directiveTransforms || {}
|
|
}
|
|
};
|
|
const wrapperProps = [];
|
|
if (slotProps) wrapperProps.push({
|
|
type: 7,
|
|
name: "slot",
|
|
exp: slotProps,
|
|
arg: void 0,
|
|
modifiers: [],
|
|
loc: _vue_compiler_dom.locStub
|
|
});
|
|
if (vFor) wrapperProps.push((0, _vue_shared.extend)({}, vFor));
|
|
subTransform({
|
|
type: 1,
|
|
ns: 0,
|
|
tag: "template",
|
|
tagType: 3,
|
|
props: wrapperProps,
|
|
children,
|
|
loc: _vue_compiler_dom.locStub,
|
|
codegenNode: void 0
|
|
}, subOptions, parentContext);
|
|
return (0, _vue_compiler_dom.createReturnStatement)(children);
|
|
}
|
|
function subTransform(node, options, parentContext) {
|
|
const childRoot = (0, _vue_compiler_dom.createRoot)([node]);
|
|
const childContext = (0, _vue_compiler_dom.createTransformContext)(childRoot, options);
|
|
childContext.ssr = false;
|
|
childContext.scopes = { ...parentContext.scopes };
|
|
childContext.identifiers = { ...parentContext.identifiers };
|
|
childContext.identifierScopes = Object.create(null);
|
|
for (const name in parentContext.identifierScopes) childContext.identifierScopes[name] = parentContext.identifierScopes[name].slice();
|
|
childContext.imports = parentContext.imports;
|
|
(0, _vue_compiler_dom.traverseNode)(childRoot, childContext);
|
|
[
|
|
"helpers",
|
|
"components",
|
|
"directives"
|
|
].forEach((key) => {
|
|
childContext[key].forEach((value, helperKey) => {
|
|
if (key === "helpers") {
|
|
const parentCount = parentContext.helpers.get(helperKey);
|
|
if (parentCount === void 0) parentContext.helpers.set(helperKey, value);
|
|
else parentContext.helpers.set(helperKey, value + parentCount);
|
|
} else parentContext[key].add(value);
|
|
});
|
|
});
|
|
}
|
|
function clone(v) {
|
|
if ((0, _vue_shared.isArray)(v)) return v.map(clone);
|
|
else if ((0, _vue_shared.isPlainObject)(v)) {
|
|
const res = {};
|
|
for (const key in v) res[key] = clone(v[key]);
|
|
return res;
|
|
} else return v;
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrTransformSlotOutlet.ts
|
|
const ssrTransformSlotOutlet = (node, context) => {
|
|
if ((0, _vue_compiler_dom.isSlotOutlet)(node)) {
|
|
const { slotName, slotProps } = (0, _vue_compiler_dom.processSlotOutlet)(node, context);
|
|
const args = [
|
|
`_ctx.$slots`,
|
|
slotName,
|
|
slotProps || `{}`,
|
|
`null`,
|
|
`_push`,
|
|
`_parent`
|
|
];
|
|
if (context.scopeId && context.slotted !== false) args.push(`"${context.scopeId}-s"`);
|
|
let method = SSR_RENDER_SLOT;
|
|
let parent = context.parent;
|
|
if (parent && !rawOptionsMap.get(context.root).vapor) {
|
|
const children = parent.children;
|
|
if (parent.type === 10) parent = context.grandParent;
|
|
let componentType;
|
|
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) {
|
|
method = SSR_RENDER_SLOT_INNER;
|
|
if (!(context.scopeId && context.slotted !== false)) args.push("null");
|
|
args.push("true");
|
|
}
|
|
}
|
|
node.ssrCodegenNode = (0, _vue_compiler_dom.createCallExpression)(context.helper(method), args);
|
|
}
|
|
};
|
|
function ssrProcessSlotOutlet(node, context) {
|
|
const renderCall = node.ssrCodegenNode;
|
|
if (node.children.length) {
|
|
const fallbackRenderFn = (0, _vue_compiler_dom.createFunctionExpression)([]);
|
|
fallbackRenderFn.body = processChildrenAsStatement(node, context);
|
|
renderCall.arguments[3] = fallbackRenderFn;
|
|
}
|
|
if (context.withSlotScopeId) {
|
|
const slotScopeId = renderCall.arguments[6];
|
|
renderCall.arguments[6] = slotScopeId ? `${slotScopeId} + _scopeId` : `_scopeId`;
|
|
}
|
|
context.pushStatement(node.ssrCodegenNode);
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/ssrCodegenTransform.ts
|
|
function ssrCodegenTransform(ast, options) {
|
|
const context = createSSRTransformContext(ast, options);
|
|
if (options.ssrCssVars) {
|
|
const cssContext = (0, _vue_compiler_dom.createTransformContext)((0, _vue_compiler_dom.createRoot)([]), options);
|
|
const varsExp = (0, _vue_compiler_dom.processExpression)((0, _vue_compiler_dom.createSimpleExpression)(options.ssrCssVars, false), cssContext);
|
|
context.body.push((0, _vue_compiler_dom.createCompoundExpression)([
|
|
`const _cssVars = { style: `,
|
|
varsExp,
|
|
`}`
|
|
]));
|
|
Array.from(cssContext.helpers.keys()).forEach((helper) => {
|
|
ast.helpers.add(helper);
|
|
});
|
|
}
|
|
processChildren(ast, context, ast.children.length > 1 && ast.children.some((c) => !(0, _vue_compiler_dom.isText)(c)));
|
|
ast.codegenNode = (0, _vue_compiler_dom.createBlockStatement)(context.body);
|
|
ast.ssrHelpers = Array.from(/* @__PURE__ */ new Set([...Array.from(ast.helpers).filter((h) => h in ssrHelpers), ...context.helpers]));
|
|
ast.helpers = new Set(Array.from(ast.helpers).filter((h) => !(h in ssrHelpers)));
|
|
}
|
|
function createSSRTransformContext(root, options, helpers = /* @__PURE__ */ new Set(), withSlotScopeId = false) {
|
|
const body = [];
|
|
let currentString = null;
|
|
return {
|
|
root,
|
|
options,
|
|
body,
|
|
helpers,
|
|
withSlotScopeId,
|
|
onError: options.onError || ((e) => {
|
|
throw e;
|
|
}),
|
|
helper(name) {
|
|
helpers.add(name);
|
|
return name;
|
|
},
|
|
pushStringPart(part) {
|
|
if (!currentString) {
|
|
const currentCall = (0, _vue_compiler_dom.createCallExpression)(`_push`);
|
|
body.push(currentCall);
|
|
currentString = (0, _vue_compiler_dom.createTemplateLiteral)([]);
|
|
currentCall.arguments.push(currentString);
|
|
}
|
|
const bufferedElements = currentString.elements;
|
|
const lastItem = bufferedElements[bufferedElements.length - 1];
|
|
if ((0, _vue_shared.isString)(part) && (0, _vue_shared.isString)(lastItem)) bufferedElements[bufferedElements.length - 1] += part;
|
|
else bufferedElements.push(part);
|
|
},
|
|
pushStatement(statement) {
|
|
currentString = null;
|
|
body.push(statement);
|
|
}
|
|
};
|
|
}
|
|
function createChildContext(parent, withSlotScopeId = parent.withSlotScopeId) {
|
|
return createSSRTransformContext(parent.root, parent.options, parent.helpers, withSlotScopeId);
|
|
}
|
|
function processChildren(parent, context, asFragment = false, disableNestedFragments = false, disableComment = false) {
|
|
if (asFragment) context.pushStringPart(`<!--[-->`);
|
|
const { children } = parent;
|
|
for (let i = 0; i < children.length; i++) {
|
|
const child = children[i];
|
|
switch (child.type) {
|
|
case 1:
|
|
switch (child.tagType) {
|
|
case 0:
|
|
ssrProcessElement(child, context);
|
|
break;
|
|
case 1:
|
|
ssrProcessComponent(child, context, parent);
|
|
break;
|
|
case 2:
|
|
ssrProcessSlotOutlet(child, context);
|
|
break;
|
|
case 3: break;
|
|
default:
|
|
context.onError(createSSRCompilerError(67, child.loc));
|
|
return child;
|
|
}
|
|
break;
|
|
case 2:
|
|
context.pushStringPart((0, _vue_shared.escapeHtml)(child.content));
|
|
break;
|
|
case 3:
|
|
if (!disableComment) context.pushStringPart(`<!--${child.content}-->`);
|
|
break;
|
|
case 5:
|
|
context.pushStringPart((0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_INTERPOLATE), [child.content]));
|
|
break;
|
|
case 9:
|
|
ssrProcessIf(child, context, disableNestedFragments, disableComment);
|
|
break;
|
|
case 11:
|
|
ssrProcessFor(child, context, disableNestedFragments);
|
|
break;
|
|
case 10: break;
|
|
case 12:
|
|
case 8: break;
|
|
default:
|
|
context.onError(createSSRCompilerError(67, child.loc));
|
|
return child;
|
|
}
|
|
}
|
|
if (asFragment) context.pushStringPart(`<!--]-->`);
|
|
}
|
|
function processChildrenAsStatement(parent, parentContext, asFragment = false, withSlotScopeId = parentContext.withSlotScopeId) {
|
|
const childContext = createChildContext(parentContext, withSlotScopeId);
|
|
processChildren(parent, childContext, asFragment);
|
|
return (0, _vue_compiler_dom.createBlockStatement)(childContext.body);
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrVModel.ts
|
|
const ssrTransformModel = (dir, node, context) => {
|
|
const model = dir.exp;
|
|
function checkDuplicatedValue() {
|
|
const value = (0, _vue_compiler_dom.findProp)(node, "value");
|
|
if (value) context.onError((0, _vue_compiler_dom.createDOMCompilerError)(61, value.loc));
|
|
}
|
|
const processSelectChildren = (children) => {
|
|
children.forEach((child) => {
|
|
if (child.type === 1) processOption(child);
|
|
else if (child.type === 11) processSelectChildren(child.children);
|
|
else if (child.type === 9) child.branches.forEach((b) => processSelectChildren(b.children));
|
|
});
|
|
};
|
|
function processOption(plainNode) {
|
|
if (plainNode.tag === "option") {
|
|
if (plainNode.props.findIndex((p) => p.name === "selected") === -1) {
|
|
const value = findValueBinding(plainNode);
|
|
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));
|
|
}
|
|
} else if (plainNode.tag === "optgroup") processSelectChildren(plainNode.children);
|
|
}
|
|
if (node.tagType === 0) {
|
|
const res = { props: [] };
|
|
if (node.tag === "input") {
|
|
const defaultProps = [(0, _vue_compiler_dom.createObjectProperty)(`value`, model)];
|
|
const type = (0, _vue_compiler_dom.findProp)(node, "type");
|
|
if (type) {
|
|
const value = findValueBinding(node);
|
|
if (type.type === 7) res.ssrTagParts = [(0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
|
|
type.exp,
|
|
model,
|
|
value
|
|
])];
|
|
else if (type.value) switch (type.value.content) {
|
|
case "radio":
|
|
res.props = [(0, _vue_compiler_dom.createObjectProperty)(`checked`, (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_LOOSE_EQUAL), [model, value]))];
|
|
break;
|
|
case "checkbox":
|
|
const trueValueBinding = (0, _vue_compiler_dom.findProp)(node, "true-value");
|
|
if (trueValueBinding) {
|
|
const trueValue = trueValueBinding.type === 6 ? JSON.stringify(trueValueBinding.value.content) : trueValueBinding.exp;
|
|
res.props = [(0, _vue_compiler_dom.createObjectProperty)(`checked`, (0, _vue_compiler_dom.createCallExpression)(context.helper(SSR_LOOSE_EQUAL), [model, trueValue]))];
|
|
} 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))];
|
|
break;
|
|
case "file":
|
|
context.onError((0, _vue_compiler_dom.createDOMCompilerError)(60, dir.loc));
|
|
break;
|
|
default:
|
|
checkDuplicatedValue();
|
|
res.props = defaultProps;
|
|
}
|
|
} else if ((0, _vue_compiler_dom.hasDynamicKeyVBind)(node)) {} else {
|
|
checkDuplicatedValue();
|
|
res.props = defaultProps;
|
|
}
|
|
} else if (node.tag === "textarea") {
|
|
checkDuplicatedValue();
|
|
node.children = [(0, _vue_compiler_dom.createInterpolation)(model, model.loc)];
|
|
} else if (node.tag === "select") processSelectChildren(node.children);
|
|
else context.onError((0, _vue_compiler_dom.createDOMCompilerError)(58, dir.loc));
|
|
return res;
|
|
} else return (0, _vue_compiler_dom.transformModel)(dir, node, context);
|
|
};
|
|
function findValueBinding(node) {
|
|
const valueBinding = (0, _vue_compiler_dom.findProp)(node, "value");
|
|
return valueBinding ? valueBinding.type === 7 ? valueBinding.exp : (0, _vue_compiler_dom.createSimpleExpression)(valueBinding.value.content, true) : (0, _vue_compiler_dom.createSimpleExpression)(`null`, false);
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrVShow.ts
|
|
const ssrTransformShow = (dir, node, context) => {
|
|
if (!dir.exp) context.onError((0, _vue_compiler_dom.createDOMCompilerError)(62));
|
|
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))] };
|
|
};
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrInjectFallthroughAttrs.ts
|
|
const ssrInjectFallthroughAttrs = (node, context) => {
|
|
if (node.type === 0) context.identifiers._attrs = 1;
|
|
if (node.type === 1 && node.tagType === 1 && (node.tag === "transition" || node.tag === "Transition" || node.tag === "KeepAlive" || node.tag === "keep-alive")) {
|
|
const rootChildren = (0, _vue_compiler_dom.filterNonCommentChildren)(context.root);
|
|
if (rootChildren.length === 1 && rootChildren[0] === node) {
|
|
if ((0, _vue_compiler_dom.hasSingleChild)(node)) injectFallthroughAttrs(node.children[0]);
|
|
return;
|
|
}
|
|
}
|
|
const parent = context.parent;
|
|
if (!parent || parent.type !== 0) return;
|
|
if (node.type === 10 && (0, _vue_compiler_dom.hasSingleChild)(node)) {
|
|
if ((0, _vue_compiler_dom.isSingleIfBlock)(parent)) injectFallthroughAttrs(node.children[0]);
|
|
} else if ((0, _vue_compiler_dom.hasSingleChild)(parent)) injectFallthroughAttrs(node);
|
|
};
|
|
function injectFallthroughAttrs(node) {
|
|
if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !(0, _vue_compiler_dom.findDir)(node, "for")) node.props.push({
|
|
type: 7,
|
|
name: "bind",
|
|
arg: void 0,
|
|
exp: (0, _vue_compiler_dom.createSimpleExpression)(`_attrs`, false),
|
|
modifiers: [],
|
|
loc: _vue_compiler_dom.locStub
|
|
});
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/transforms/ssrInjectCssVars.ts
|
|
const ssrInjectCssVars = (node, context) => {
|
|
if (!context.ssrCssVars) return;
|
|
if (node.type === 0) context.identifiers._cssVars = 1;
|
|
const parent = context.parent;
|
|
if (!parent || parent.type !== 0) return;
|
|
if (node.type === 10) for (const child of node.children) injectCssVars(child);
|
|
else injectCssVars(node);
|
|
};
|
|
function injectCssVars(node) {
|
|
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);
|
|
else injectCssVars(child);
|
|
else node.props.push({
|
|
type: 7,
|
|
name: "bind",
|
|
arg: void 0,
|
|
exp: (0, _vue_compiler_dom.createSimpleExpression)(`_cssVars`, false),
|
|
modifiers: [],
|
|
loc: _vue_compiler_dom.locStub
|
|
});
|
|
}
|
|
}
|
|
//#endregion
|
|
//#region packages/compiler-ssr/src/index.ts
|
|
function compile(source, options = {}) {
|
|
options = {
|
|
...options,
|
|
..._vue_compiler_dom.parserOptions,
|
|
ssr: true,
|
|
inSSR: true,
|
|
scopeId: options.mode === "function" ? null : options.scopeId,
|
|
prefixIdentifiers: true,
|
|
cacheHandlers: false,
|
|
hoistStatic: false
|
|
};
|
|
const ast = typeof source === "string" ? (0, _vue_compiler_dom.baseParse)(source, options) : source;
|
|
rawOptionsMap.set(ast, options);
|
|
(0, _vue_compiler_dom.transform)(ast, {
|
|
...options,
|
|
hoistStatic: false,
|
|
nodeTransforms: [
|
|
_vue_compiler_dom.transformVBindShorthand,
|
|
ssrTransformIf,
|
|
ssrTransformFor,
|
|
_vue_compiler_dom.trackVForSlotScopes,
|
|
_vue_compiler_dom.transformExpression,
|
|
ssrTransformSlotOutlet,
|
|
ssrInjectFallthroughAttrs,
|
|
ssrInjectCssVars,
|
|
ssrTransformElement,
|
|
ssrTransformComponent,
|
|
_vue_compiler_dom.trackSlotScopes,
|
|
_vue_compiler_dom.transformStyle,
|
|
...options.nodeTransforms || []
|
|
],
|
|
directiveTransforms: {
|
|
bind: _vue_compiler_dom.transformBind,
|
|
on: _vue_compiler_dom.transformOn,
|
|
model: ssrTransformModel,
|
|
show: ssrTransformShow,
|
|
cloak: _vue_compiler_dom.noopDirectiveTransform,
|
|
once: _vue_compiler_dom.noopDirectiveTransform,
|
|
memo: _vue_compiler_dom.noopDirectiveTransform,
|
|
...options.directiveTransforms || {}
|
|
}
|
|
});
|
|
ssrCodegenTransform(ast, options);
|
|
return (0, _vue_compiler_dom.generate)(ast, options);
|
|
}
|
|
//#endregion
|
|
exports.compile = compile;
|