crates/core/src/vue_recovery/slots.rs
GitHubuse anyhow::Result;
use swc_core::ecma::ast::{
ArrowExpr, CallExpr, Callee, Expr, ExprOrSpread, MemberExpr, MemberProp, ObjectLit,
ObjectPatProp, Pat, Prop, PropOrSpread,
};
use super::attrs::recover_attrs;
use super::expressions::{clean_attr_expr, print_expr, printed_vue_expr};
use super::helpers::{helper_name, VueHelper};
use super::locals::template_scope_from_pat;
use super::nodes::{
apply_for_param_renames, arrow_return_expr, clean_condition_expr, is_undefined_expr,
list_item_context, recover_children, recover_for_params,
};
use super::syntax::{prop_name, string_lit};
use super::{VueRecoveryContext, VueRenderSlotBinding};
use crate::vue_template::{
VueAttr, VueDirective, VueElement, VueExpr, VueFor, VueIfBranch, VueNode, VueTemplateScope,
};
pub(super) fn recover_direct_slot(
member: &MemberExpr,
ctx: &VueRecoveryContext,
) -> Result<Option<VueNode>> {
if !is_slot_object_expr(member.obj.as_ref(), ctx) {
return Ok(None);
}
let Some(slot_name) = slot_member_name(&member.prop) else {
return Ok(None);
};
let mut attrs = Vec::new();
if slot_name != "default" {
attrs.push(VueAttr::Static {
name: "name".to_string(),
value: Some(slot_name),
});
}
Ok(Some(VueNode::Element(
VueElement::new("slot").with_attrs(attrs),
)))
}
pub(super) fn recover_called_slot(
call: &CallExpr,
ctx: &VueRecoveryContext,
) -> Result<Option<VueNode>> {
slot_call_binding(call, ctx)
.map(|binding| recover_slot_binding(&binding, ctx))
.transpose()
}
pub(super) fn recover_slot_binding(
binding: &VueRenderSlotBinding,
ctx: &VueRecoveryContext,
) -> Result<VueNode> {
let mut attrs = Vec::new();
if binding.slot_name != "default" {
attrs.push(VueAttr::Static {
name: "name".to_string(),
value: Some(binding.slot_name.clone()),
});
}
if let Some(props) = &binding.props {
attrs.extend(recover_attrs(props.as_ref(), ctx)?);
}
Ok(VueNode::Element(VueElement::new("slot").with_attrs(attrs)))
}
pub(super) fn slot_call_binding(
call: &CallExpr,
ctx: &VueRecoveryContext,
) -> Option<VueRenderSlotBinding> {
let Callee::Expr(callee) = &call.callee else {
return None;
};
let Expr::Member(member) = callee.as_ref() else {
return None;
};
if !is_slot_object_expr(member.obj.as_ref(), ctx) {
return None;
}
let slot_name = slot_member_name(&member.prop)?;
let props = call
.args
.first()
.filter(|arg| arg.spread.is_none())
.map(|arg| arg.expr.clone());
Some(VueRenderSlotBinding { slot_name, props })
}
fn is_slot_object_expr(expr: &Expr, ctx: &VueRecoveryContext) -> bool {
match expr {
Expr::Paren(paren) => is_slot_object_expr(paren.expr.as_ref(), ctx),
Expr::Ident(ident) => {
matches!(ident.sym.as_ref(), "$slots" | "slots")
|| ctx.slot_bindings.contains(&ident.sym)
}
Expr::Member(member) => slot_member_name(&member.prop).as_deref() == Some("$slots"),
_ => false,
}
}
fn slot_member_name(prop: &MemberProp) -> Option<String> {
match prop {
MemberProp::Ident(ident) => Some(ident.sym.to_string()),
MemberProp::Computed(computed) => string_lit(computed.expr.as_ref()),
MemberProp::PrivateName(_) => None,
}
}
pub(super) fn recover_component_children(
expr: &Expr,
ctx: &VueRecoveryContext,
) -> Result<Option<Vec<VueNode>>> {
match expr {
Expr::Call(call) if helper_name(&call.callee, ctx) == Some(VueHelper::CreateSlots) => {
recover_create_slots(&call.args, ctx)
}
Expr::Object(object) => recover_component_slots(object, ctx),
_ => Ok(None),
}
}
fn recover_create_slots(
args: &[ExprOrSpread],
ctx: &VueRecoveryContext,
) -> Result<Option<Vec<VueNode>>> {
let Some(base_arg) = args.first() else {
return Ok(None);
};
let Expr::Object(base_slots) = base_arg.expr.as_ref() else {
return Ok(None);
};
let Some(mut slots) = recover_component_slots(base_slots, ctx)? else {
return Ok(None);
};
let Some(dynamic_arg) = args.get(1) else {
return Ok(Some(slots));
};
let Expr::Array(dynamic_slots) = dynamic_arg.expr.as_ref() else {
return Ok(None);
};
for elem in dynamic_slots.elems.iter().flatten() {
let Some(slot) = recover_dynamic_slot(elem.expr.as_ref(), ctx)? else {
return Ok(None);
};
slots.push(slot);
}
Ok(Some(slots))
}
fn recover_component_slots(
object: &ObjectLit,
ctx: &VueRecoveryContext,
) -> Result<Option<Vec<VueNode>>> {
let mut slots = Vec::new();
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
return Ok(None);
};
let Prop::KeyValue(key_value) = prop.as_ref() else {
return Ok(None);
};
let Some(slot_name) = prop_name(&key_value.key) else {
return Ok(None);
};
if slot_name == "_" {
continue;
}
let Some(slot) = recover_component_slot(
&RecoveredSlotName::Static(slot_name),
key_value.value.as_ref(),
ctx,
Vec::new(),
)?
else {
return Ok(None);
};
slots.push(slot);
}
Ok(Some(slots))
}
fn recover_dynamic_slot(expr: &Expr, ctx: &VueRecoveryContext) -> Result<Option<VueNode>> {
match expr {
Expr::Paren(paren) => recover_dynamic_slot(paren.expr.as_ref(), ctx),
Expr::Object(object) => recover_slot_descriptor(object, ctx),
Expr::Cond(cond) if is_undefined_expr(cond.alt.as_ref()) => {
let Some(slot) = recover_dynamic_slot(cond.cons.as_ref(), ctx)? else {
return Ok(None);
};
Ok(Some(VueNode::If(vec![VueIfBranch {
condition: Some(VueExpr::new(clean_condition_expr(cond.test.as_ref(), ctx)?)),
node: Box::new(slot),
}])))
}
Expr::Call(call) if helper_name(&call.callee, ctx) == Some(VueHelper::RenderList) => {
recover_dynamic_slot_list(&call.args, ctx)
}
_ => Ok(None),
}
}
fn recover_dynamic_slot_list(
args: &[ExprOrSpread],
ctx: &VueRecoveryContext,
) -> Result<Option<VueNode>> {
let Some(source_arg) = args.first() else {
return Ok(None);
};
let Some(callback_arg) = args.get(1) else {
return Ok(None);
};
let Expr::Arrow(callback) = callback_arg.expr.as_ref() else {
return Ok(None);
};
let Some(for_params) = recover_for_params(&callback.params, "slot", ctx)? else {
return Ok(None);
};
let Some(slot_expr) = arrow_return_expr(&callback.body) else {
return Ok(None);
};
let item_ctx = list_item_context(ctx, &for_params);
let Some(mut slot) = recover_dynamic_slot(slot_expr, &item_ctx)? else {
return Ok(None);
};
apply_for_param_renames(&mut slot, &for_params);
let scope = for_params.template_scope();
let value = for_params.value;
Ok(Some(VueNode::For(VueFor {
value,
source: VueExpr::new(clean_attr_expr(
&print_expr(source_arg.expr.as_ref(), ctx)?,
ctx,
)),
node: Box::new(slot),
scope,
})))
}
fn recover_slot_descriptor(
object: &ObjectLit,
ctx: &VueRecoveryContext,
) -> Result<Option<VueNode>> {
let mut slot_name = None;
let mut slot_fn = None;
let mut extra_attrs = Vec::new();
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
return Ok(None);
};
let Prop::KeyValue(key_value) = prop.as_ref() else {
return Ok(None);
};
let Some(name) = prop_name(&key_value.key) else {
return Ok(None);
};
match name.as_str() {
"name" => {
slot_name = Some(if let Some(name) = string_lit(key_value.value.as_ref()) {
RecoveredSlotName::Static(name)
} else {
RecoveredSlotName::Dynamic(printed_vue_expr(key_value.value.as_ref(), ctx)?)
});
}
"fn" => slot_fn = Some(key_value.value.as_ref()),
"key" => {
if string_lit(key_value.value.as_ref()).is_none() {
extra_attrs.push(VueAttr::Bind {
name: "key".to_string(),
expr: printed_vue_expr(key_value.value.as_ref(), ctx)?,
});
};
}
_ => return Ok(None),
}
}
let (Some(slot_name), Some(slot_fn)) = (slot_name, slot_fn) else {
return Ok(None);
};
recover_component_slot(&slot_name, slot_fn, ctx, extra_attrs)
}
#[derive(Clone)]
enum RecoveredSlotName {
Static(String),
Dynamic(VueExpr),
}
fn recover_component_slot(
slot_name: &RecoveredSlotName,
expr: &Expr,
ctx: &VueRecoveryContext,
extra_attrs: Vec<VueAttr>,
) -> Result<Option<VueNode>> {
let Some(slot_fn) = slot_fn_expr(expr, ctx) else {
return Ok(None);
};
let Expr::Arrow(arrow) = slot_fn else {
return Ok(None);
};
let Some(children_expr) = arrow_return_expr(&arrow.body) else {
return Ok(None);
};
let mut directive = match slot_name {
RecoveredSlotName::Static(name) => VueDirective::new("slot").with_arg(name.clone()),
RecoveredSlotName::Dynamic(name) => VueDirective::new("slot").with_dynamic_arg(name),
};
if let Some((scope_expr, scope)) = slot_scope(arrow, ctx)? {
directive = directive.with_expr(scope_expr).with_scope(scope);
}
let mut attrs = vec![VueAttr::Directive(directive)];
attrs.extend(extra_attrs);
Ok(Some(VueNode::Element(
VueElement::new("template")
.with_attrs(attrs)
.with_children(recover_children(children_expr, ctx)?),
)))
}
fn slot_fn_expr<'a>(expr: &'a Expr, ctx: &VueRecoveryContext) -> Option<&'a Expr> {
let Expr::Call(call) = expr else {
return Some(expr);
};
if helper_name(&call.callee, ctx) != Some(VueHelper::WithCtx) {
return Some(expr);
}
call.args.first().map(|arg| arg.expr.as_ref())
}
fn slot_scope(
arrow: &ArrowExpr,
ctx: &VueRecoveryContext,
) -> Result<Option<(VueExpr, VueTemplateScope)>> {
let Some(param) = arrow.params.first() else {
return Ok(None);
};
Ok(slot_pat(param, ctx)?
.map(VueExpr::new)
.map(|expr| (expr, template_scope_from_pat(param))))
}
pub(super) fn slot_pat(pat: &Pat, ctx: &VueRecoveryContext) -> Result<Option<String>> {
match pat {
Pat::Ident(binding) => Ok(Some(binding.id.sym.to_string())),
Pat::Object(object) => {
let mut props = Vec::new();
for prop in &object.props {
let Some(prop) = object_slot_pat_prop(prop, ctx)? else {
return Ok(None);
};
props.push(prop);
}
Ok(Some(format!("{{ {} }}", props.join(", "))))
}
_ => Ok(None),
}
}
fn object_slot_pat_prop(prop: &ObjectPatProp, ctx: &VueRecoveryContext) -> Result<Option<String>> {
match prop {
ObjectPatProp::Assign(assign) => {
let name = assign.key.sym.to_string();
if let Some(value) = &assign.value {
Ok(Some(format!(
"{name} = {}",
clean_attr_expr(&print_expr(value.as_ref(), ctx)?, ctx)
)))
} else {
Ok(Some(name))
}
}
ObjectPatProp::KeyValue(key_value) => {
let Some(name) = prop_name(&key_value.key) else {
return Ok(None);
};
let Some(value) = slot_pat(key_value.value.as_ref(), ctx)? else {
return Ok(None);
};
if value == name {
Ok(Some(name))
} else {
Ok(Some(format!("{name}: {value}")))
}
}
ObjectPatProp::Rest(rest) => match rest.arg.as_ref() {
Pat::Ident(binding) => Ok(Some(format!("...{}", binding.id.sym))),
_ => Ok(None),
},
}
}
pub(super) fn recover_slot(args: &[ExprOrSpread], ctx: &VueRecoveryContext) -> Result<VueNode> {
let slot_name = args
.get(1)
.and_then(|arg| string_lit(arg.expr.as_ref()))
.unwrap_or_else(|| "default".to_string());
let mut attrs = Vec::new();
if slot_name != "default" {
attrs.push(VueAttr::Static {
name: "name".to_string(),
value: Some(slot_name),
});
}
if let Some(props_arg) = args.get(2) {
attrs.extend(recover_attrs(props_arg.expr.as_ref(), ctx)?);
}
let children = args
.get(3)
.map(|arg| recover_slot_fallback(arg.expr.as_ref(), ctx))
.transpose()?
.unwrap_or_default();
Ok(VueNode::Element(
VueElement::new("slot")
.with_attrs(attrs)
.with_children(children),
))
}
fn recover_slot_fallback(expr: &Expr, ctx: &VueRecoveryContext) -> Result<Vec<VueNode>> {
let Expr::Arrow(arrow) = expr else {
return Ok(Vec::new());
};
let Some(fallback) = arrow_return_expr(&arrow.body) else {
return Ok(Vec::new());
};
recover_children(fallback, ctx)
}