crates/core/src/vue_recovery/script.rs
GitHubuse anyhow::Result;
use crate::js_names::is_valid_identifier_name;
use super::components::component_script_imports;
use super::declarations::{
push_script_setup_declarations, script_setup_declarations, script_setup_declared_bindings,
VueScriptSetupDeclaration,
};
use super::locals::VueSetupLocalBinding;
use super::script_imports::referenced_script_imports;
use super::selection::setup_local_declarations;
use super::setup_bindings::{
component_prop_names, component_props_source, props_binding_reserved_names,
setup_emit_declaration, setup_prop_bindings, setup_props_script_binding,
setup_ref_declarations,
};
use super::{
render_setup_local_declarations, RenderSource, VueNode, VueRecoveryContext, VueTemplateUsage,
};
pub(super) struct VueSetupScriptPlan {
pub(super) valid_prop_names: Vec<String>,
pub(super) prop_bindings: Vec<(String, String)>,
pub(super) props_declaration: Option<(String, String)>,
pub(super) emit_declaration: Option<(String, String)>,
pub(super) ref_declarations: Vec<(String, String, String)>,
pub(super) local_declarations: Vec<VueSetupLocalBinding>,
pub(super) scheduled_declarations: Vec<VueScriptSetupDeclaration>,
pub(super) script_imports: Vec<String>,
}
impl VueSetupScriptPlan {
pub(super) fn build(
ctx: &VueRecoveryContext,
root: &mut VueNode,
render: RenderSource<'_>,
) -> Result<Self> {
let template_usage = VueTemplateUsage::new(root);
let ref_declarations = setup_ref_declarations(ctx, &template_usage, render);
let selected_local_declarations = setup_local_declarations(ctx, &template_usage);
let emit_declaration =
setup_emit_declaration(ctx, &template_usage, &selected_local_declarations)?;
let prop_names = ctx
.setup_component_options
.as_ref()
.or(ctx.component_options.as_ref())
.map(component_prop_names)
.unwrap_or_default();
let valid_prop_names = prop_names
.iter()
.filter(|name| is_valid_identifier_name(name))
.cloned()
.collect::<Vec<_>>();
let prop_bindings = setup_prop_bindings(&valid_prop_names, ctx);
let props_binding_reserved = props_binding_reserved_names(
ctx,
&valid_prop_names,
emit_declaration.as_ref(),
&ref_declarations,
);
let props_declaration = setup_props_script_binding(ctx, &props_binding_reserved)
.map(|binding| {
component_props_source(ctx).map(|source| source.map(|source| (binding, source)))
})
.transpose()?
.flatten();
let component_imports = component_script_imports(
ctx,
root,
&prop_bindings,
props_declaration.as_ref(),
emit_declaration.as_ref(),
&ref_declarations,
&selected_local_declarations,
);
let local_declarations = render_setup_local_declarations(
ctx,
selected_local_declarations,
&prop_bindings,
props_declaration.as_ref(),
emit_declaration.as_ref(),
&ref_declarations,
&component_imports,
)?;
let scheduled_declarations = script_setup_declarations(ctx, &local_declarations);
let declared_bindings = script_setup_declared_bindings(
ctx,
&prop_bindings,
props_declaration.as_ref(),
emit_declaration.as_ref(),
&ref_declarations,
&local_declarations,
);
let script_imports = referenced_script_imports(
ctx,
&template_usage,
&declared_bindings,
&local_declarations,
&component_imports,
);
Ok(Self {
valid_prop_names,
prop_bindings,
props_declaration,
emit_declaration,
ref_declarations,
local_declarations,
scheduled_declarations,
script_imports,
})
}
pub(super) fn is_empty(&self) -> bool {
self.scheduled_declarations.is_empty()
&& self.ref_declarations.is_empty()
&& self.props_declaration.is_none()
&& self.emit_declaration.is_none()
&& self.script_imports.is_empty()
}
pub(super) fn render(&self, ctx: &VueRecoveryContext) -> String {
let mut body = String::new();
if let Some((binding, props_source)) = &self.props_declaration {
body.push_str("const ");
body.push_str(binding);
body.push_str(" = defineProps(");
body.push_str(props_source);
body.push_str(");\n");
if !self.valid_prop_names.is_empty() {
body.push_str("const { ");
body.push_str(&format_prop_destructure_bindings(&self.prop_bindings));
body.push_str(" } = ");
body.push_str(binding);
body.push_str(";\n");
}
body.push('\n');
}
if let Some((binding, emits_source)) = &self.emit_declaration {
body.push_str("const ");
body.push_str(binding);
body.push_str(" = defineEmits(");
body.push_str(emits_source);
body.push_str(");\n");
if !self.ref_declarations.is_empty() || !self.scheduled_declarations.is_empty() {
body.push('\n');
}
}
for (binding, expr, _) in &self.ref_declarations {
body.push_str("const ");
body.push_str(binding);
body.push_str(" = ");
body.push_str(expr.trim());
body.push_str(";\n");
}
if !self.ref_declarations.is_empty() && !self.scheduled_declarations.is_empty() {
body.push('\n');
}
push_script_setup_declarations(&mut body, &self.scheduled_declarations);
let mut out = String::new();
if let Some(vue_import) =
vue_script_import_line(ctx, &self.ref_declarations, &self.local_declarations)
{
out.push_str(&vue_import);
out.push('\n');
}
for import in &self.script_imports {
out.push_str(import);
out.push('\n');
}
if !out.is_empty() {
out.push('\n');
}
out.push_str(&body);
out
}
}
fn vue_script_import_line(
ctx: &VueRecoveryContext,
ref_declarations: &[(String, String, String)],
local_declarations: &[VueSetupLocalBinding],
) -> Option<String> {
let mut imports = Vec::<(String, String)>::new();
if !ctx.setup_script_bindings.is_empty() {
imports.push(("computed".to_string(), "computed".to_string()));
}
for (_, _, helper) in ref_declarations {
imports.push((helper.clone(), helper.clone()));
}
for declaration in local_declarations {
for local in super::stmt_ident_refs(&declaration.stmt) {
if ctx.script_imports.contains_key(&local) {
continue;
}
let Some(helper) = ctx.vue_helpers.get(&local) else {
continue;
};
imports.push((
super::vue_helper_import_name(helper).to_string(),
local.as_ref().to_string(),
));
}
}
imports.sort();
imports.dedup();
if imports.is_empty() {
None
} else {
let specifiers = imports
.into_iter()
.map(|(imported, local)| {
if imported == local {
imported
} else {
format!("{imported} as {local}")
}
})
.collect::<Vec<_>>();
Some(format!(
"import {{ {} }} from \"vue\";",
specifiers.join(", ")
))
}
}
fn format_prop_destructure_bindings(prop_bindings: &[(String, String)]) -> String {
prop_bindings
.iter()
.map(|(prop, binding)| {
if prop == binding {
prop.clone()
} else {
format!("{prop}: {binding}")
}
})
.collect::<Vec<_>>()
.join(", ")
}