vize_atelier_core 0.211.0

//! Slots object generation for component children.

use crate::transforms::v_slot::{collect_slots, get_slot_name, has_v_slot};
use crate::*;
use vize_carton::String;
use vize_carton::ToCompactString;

use super::super::context::CodegenContext;
use super::super::expression::generate_expression;
use super::super::helpers::{escape_js_string, is_valid_js_identifier};
use super::super::node::generate_node;
use super::detect::{
    child_is_slot_template, has_conditional_or_loop_slots, has_forwarded_slot_outlet,
    slot_children_have_meaningful_content,
};
use super::params::{extract_slot_params, get_slot_props, prefix_slot_defaults};

/// Generate slots object for component
pub fn generate_slots(ctx: &mut CodegenContext, el: &ElementNode<'_>) {
    // Note: WithCtx helper is registered at each _withCtx() output site,
    // not here, to avoid importing it when slots don't actually use it.

    // Check for v-slot on component root (shorthand for default slot)
    let root_slot = el.props.iter().find_map(|p| {
        if let PropNode::Directive(dir) = p
            && dir.name.as_str() == "slot"
        {
            return Some(dir.as_ref());
        }
        None
    });

    let collected_slots = collect_slots(el);
    let has_forwarded_slots = has_forwarded_slot_outlet(el);
    let has_dynamic_slots =
        ctx.in_v_for || collected_slots.iter().any(|s| s.is_dynamic) || has_forwarded_slots;
    let has_conditional_slots = has_conditional_or_loop_slots(el);

    // If there are conditional (v-if) or looped (v-for) slots, use createSlots
    if has_conditional_slots && root_slot.is_none() {
        generate_create_slots(ctx, el);
        return;
    }

    ctx.push("{");
    ctx.indent();

    if let Some(slot_dir) = root_slot {
        // v-slot on component root - all children go to default slot
        ctx.newline();
        ctx.push("default: ");
        ctx.use_helper(RuntimeHelper::WithCtx);
        ctx.push(ctx.helper(RuntimeHelper::WithCtx));
        ctx.push("(");
        // Slot props (scoped slot params) - use raw source with default value prefix
        let params = if let Some(props_str) = get_slot_props(slot_dir) {
            let processed = prefix_slot_defaults(&props_str);
            ctx.push("(");
            ctx.push(&processed);
            ctx.push(")");
            extract_slot_params(&props_str)
        } else {
            ctx.push("()");
            vec![]
        };

        // Track slot params for stripping _ctx. prefix
        ctx.add_slot_params(&params);

        ctx.push(" => [");
        ctx.indent();
        generate_slot_children(ctx, &el.children);
        ctx.deindent();
        ctx.newline();
        ctx.push("])");

        // Remove slot params
        ctx.remove_slot_params(&params);
    } else {
        // Check for named slots via template#slotName
        let mut has_generated_default = false;
        let mut first_slot = true;

        for child in &el.children {
            if let TemplateChildNode::Element(template_el) = child
                && template_el.tag.as_str() == "template"
                && has_v_slot(template_el)
            {
                // This is a named slot template
                if let Some(slot_dir) = template_el.props.iter().find_map(|p| {
                    if let PropNode::Directive(dir) = p
                        && dir.name.as_str() == "slot"
                    {
                        return Some(dir.as_ref());
                    }
                    None
                }) {
                    if !first_slot {
                        ctx.push(",");
                    }
                    first_slot = false;
                    ctx.newline();

                    let slot_name = get_slot_name(slot_dir);
                    let is_dynamic = slot_dir
                        .arg
                        .as_ref()
                        .map(|arg| match arg {
                            ExpressionNode::Simple(exp) => !exp.is_static,
                            ExpressionNode::Compound(_) => true,
                        })
                        .unwrap_or(false);

                    if is_dynamic {
                        let trimmed_name = slot_name.trim();
                        if trimmed_name.starts_with('`') && trimmed_name.ends_with('`') {
                            // Template literal slot name: `item.name` → ["item.name"]
                            let inner = &trimmed_name[1..trimmed_name.len() - 1];
                            ctx.push("[\"");
                            ctx.push(&escape_js_string(inner));
                            ctx.push("\"]");
                        } else {
                            // Dynamic slot name: [_ctx.slotName]
                            ctx.push("[");
                            ctx.push("_ctx.");
                            ctx.push(&slot_name);
                            ctx.push("]");
                        }
                    } else if is_valid_js_identifier(&slot_name) {
                        ctx.push(&slot_name);
                    } else {
                        ctx.push("\"");
                        ctx.push(&escape_js_string(&slot_name));
                        ctx.push("\"");
                    }

                    if slot_name.as_str() == "default" {
                        has_generated_default = true;
                    }

                    ctx.push(": ");
                    ctx.use_helper(RuntimeHelper::WithCtx);
                    ctx.push(ctx.helper(RuntimeHelper::WithCtx));
                    ctx.push("(");

                    // Slot props - use raw source with default value prefix
                    let params = if let Some(props_str) = get_slot_props(slot_dir) {
                        let processed = prefix_slot_defaults(&props_str);
                        ctx.push("(");
                        ctx.push(&processed);
                        ctx.push(")");
                        extract_slot_params(&props_str)
                    } else {
                        ctx.push("()");
                        vec![]
                    };

                    // Track slot params for stripping _ctx. prefix
                    ctx.add_slot_params(&params);

                    ctx.push(" => [");
                    ctx.indent();
                    generate_slot_children(ctx, &template_el.children);
                    ctx.deindent();
                    ctx.newline();
                    ctx.push("])");

                    // Remove slot params
                    ctx.remove_slot_params(&params);
                }
            }
        }

        // Generate default slot for non-template children
        let default_children: Vec<_> = el
            .children
            .iter()
            .filter(|child| {
                if let TemplateChildNode::Element(template_el) = child {
                    !(template_el.tag.as_str() == "template" && has_v_slot(template_el))
                } else {
                    true
                }
            })
            .collect();

        if !default_children.is_empty() && !has_generated_default {
            if !first_slot {
                ctx.push(",");
            }
            ctx.newline();
            ctx.push("default: ");
            ctx.use_helper(RuntimeHelper::WithCtx);
            ctx.push(ctx.helper(RuntimeHelper::WithCtx));
            ctx.push("(() => [");
            ctx.indent();
            for (i, child) in default_children.iter().enumerate() {
                if i > 0 {
                    ctx.push(",");
                }
                ctx.newline();
                generate_slot_child_node(ctx, child);
            }
            ctx.deindent();
            ctx.newline();
            ctx.push("])");
        }
    }

    // Add slot stability flag
    ctx.push(",");
    ctx.newline();
    if has_forwarded_slots {
        ctx.push("_: 3 /* FORWARDED */");
    } else if has_dynamic_slots {
        ctx.push("_: 2 /* DYNAMIC */");
    } else {
        ctx.push("_: 1 /* STABLE */");
    }

    ctx.deindent();
    ctx.newline();
    ctx.push("}");
}

/// Generate slots using createSlots for conditional/looped slot templates
fn generate_create_slots(ctx: &mut CodegenContext, el: &ElementNode<'_>) {
    ctx.use_helper(RuntimeHelper::CreateSlots);
    ctx.push(ctx.helper(RuntimeHelper::CreateSlots));
    ctx.push("(");
    generate_create_slots_base(ctx, el);
    ctx.push(", [");
    ctx.indent();

    let mut first = true;
    for child in &el.children {
        match child {
            TemplateChildNode::If(if_node) => {
                // v-if on slot template: generate conditional slot entry
                if !first {
                    ctx.push(",");
                }
                first = false;
                ctx.newline();
                generate_conditional_slot(ctx, if_node);
            }
            TemplateChildNode::For(for_node) => {
                // v-for on slot template: generate looped slot entries
                if !first {
                    ctx.push(",");
                }
                first = false;
                ctx.newline();
                generate_looped_slot(ctx, for_node);
            }
            TemplateChildNode::Element(template_el)
                if template_el.tag.as_str() == "template" && has_v_slot(template_el) =>
            {
                // Regular named slot (no v-if/v-for)
                if !first {
                    ctx.push(",");
                }
                first = false;
                ctx.newline();
                // Generate as static slot entry
                generate_static_slot_entry(ctx, template_el);
            }
            _ => {}
        }
    }

    ctx.deindent();
    ctx.newline();
    ctx.push("])");
}

fn generate_create_slots_base(ctx: &mut CodegenContext, el: &ElementNode<'_>) {
    let default_children: Vec<_> = el
        .children
        .iter()
        .filter(|child| !child_is_slot_template(child))
        .collect();
    let has_default_children = slot_children_have_meaningful_content(&default_children);

    if !has_default_children {
        ctx.push("{ _: 2 /* DYNAMIC */ }");
        return;
    }

    ctx.push("{");
    ctx.indent();

    ctx.newline();
    ctx.push("default: ");
    ctx.use_helper(RuntimeHelper::WithCtx);
    ctx.push(ctx.helper(RuntimeHelper::WithCtx));
    ctx.push("(() => [");
    ctx.indent();
    for (i, child) in default_children.iter().enumerate() {
        if i > 0 {
            ctx.push(",");
        }
        ctx.newline();
        generate_slot_child_node(ctx, child);
    }
    ctx.deindent();
    ctx.newline();
    ctx.push("]),");

    ctx.newline();
    ctx.push("_: 2 /* DYNAMIC */");

    ctx.deindent();
    ctx.newline();
    ctx.push("}");
}

/// Generate a conditional slot entry (v-if on slot template)
fn generate_conditional_slot(ctx: &mut CodegenContext, if_node: &IfNode<'_>) {
    // For each branch: condition ? { name, fn, key } : undefined
    for (i, branch) in if_node.branches.iter().enumerate() {
        if i > 0 {
            ctx.newline();
            ctx.push(": ");
        }

        // Generate condition
        if let Some(condition) = &branch.condition {
            ctx.push("(");
            generate_expression(ctx, condition);
            ctx.push(")");
            ctx.indent();
            ctx.newline();
            ctx.push("? ");
        }

        // Find the slot template in this branch
        let slot_template = branch.children.iter().find_map(|child| {
            if let TemplateChildNode::Element(el) = child
                && el.tag.as_str() == "template"
                && has_v_slot(el)
            {
                return Some(el.as_ref());
            }
            None
        });

        if let Some(template_el) = slot_template {
            generate_slot_object_entry(ctx, template_el, Some(i));
        } else {
            ctx.push("undefined");
        }

        if branch.condition.is_some() {
            ctx.deindent();
        }
    }
    if if_node
        .branches
        .last()
        .is_none_or(|branch| branch.condition.is_some())
    {
        ctx.newline();
        ctx.push(": undefined");
    }
}

/// Generate a looped slot entry (v-for on slot template)
fn generate_looped_slot(ctx: &mut CodegenContext, for_node: &ForNode<'_>) {
    ctx.use_helper(RuntimeHelper::RenderList);
    ctx.push(ctx.helper(RuntimeHelper::RenderList));
    ctx.push("(");
    generate_expression(ctx, &for_node.source);
    ctx.push(", (");

    // Collect callback parameter names for scope registration
    let mut callback_params: Vec<String> = Vec::new();

    if let Some(value) = &for_node.value_alias {
        generate_expression(ctx, value);
        super::super::v_for::helpers::extract_for_params(value, &mut callback_params);
    }
    if let Some(key) = &for_node.key_alias {
        ctx.push(", ");
        generate_expression(ctx, key);
        super::super::v_for::helpers::extract_for_params(key, &mut callback_params);
    }
    if let Some(index) = &for_node.object_index_alias {
        ctx.push(", ");
        generate_expression(ctx, index);
        super::super::v_for::helpers::extract_for_params(index, &mut callback_params);
    }

    ctx.add_slot_params(&callback_params);

    ctx.push(") => {");
    ctx.indent();
    ctx.newline();
    ctx.push("return ");

    // Find the slot template in the for body
    let slot_template = for_node.children.iter().find_map(|child| {
        if let TemplateChildNode::Element(el) = child
            && el.tag.as_str() == "template"
            && has_v_slot(el)
        {
            return Some(el.as_ref());
        }
        None
    });

    if let Some(template_el) = slot_template {
        generate_slot_object_entry(ctx, template_el, None);
    }

    ctx.remove_slot_params(&callback_params);

    ctx.deindent();
    ctx.newline();
    ctx.push("})");
}

/// Generate a slot object entry: { name: "slotName", fn: _withCtx(() => [...]), key: "N" }
fn generate_slot_object_entry(
    ctx: &mut CodegenContext,
    template_el: &ElementNode<'_>,
    key_index: Option<usize>,
) {
    let slot_dir = template_el.props.iter().find_map(|p| {
        if let PropNode::Directive(dir) = p
            && dir.name.as_str() == "slot"
        {
            return Some(dir.as_ref());
        }
        None
    });

    if let Some(dir) = slot_dir {
        let slot_name = get_slot_name(dir);

        ctx.push("{");
        ctx.indent();
        ctx.newline();

        // name
        ctx.push("name: \"");
        ctx.push(&escape_js_string(&slot_name));
        ctx.push("\",");
        ctx.newline();

        // fn
        ctx.push("fn: ");
        ctx.use_helper(RuntimeHelper::WithCtx);
        ctx.push(ctx.helper(RuntimeHelper::WithCtx));
        ctx.push("(");

        // Slot props
        let params = if let Some(props_str) = get_slot_props(dir) {
            let processed = prefix_slot_defaults(&props_str);
            ctx.push("(");
            ctx.push(&processed);
            ctx.push(")");
            extract_slot_params(&props_str)
        } else {
            ctx.push("()");
            vec![]
        };

        ctx.add_slot_params(&params);

        ctx.push(" => [");
        ctx.indent();
        generate_slot_children(ctx, &template_el.children);
        ctx.deindent();
        ctx.newline();
        ctx.push("])");

        ctx.remove_slot_params(&params);

        // key (for v-if branches)
        if let Some(key) = key_index {
            ctx.push(",");
            ctx.newline();
            ctx.push("key: \"");
            ctx.push(&key.to_compact_string());
            ctx.push("\"");
        }

        ctx.deindent();
        ctx.newline();
        ctx.push("}");
    }
}

/// Generate a static slot entry for createSlots context
fn generate_static_slot_entry(ctx: &mut CodegenContext, template_el: &ElementNode<'_>) {
    generate_slot_object_entry(ctx, template_el, None);
}

/// Generate children for a slot
fn generate_slot_children(ctx: &mut CodegenContext, children: &[TemplateChildNode<'_>]) {
    // Check if all children are text/interpolation - if so, concatenate into single _createTextVNode
    let all_text_or_interp = children.iter().all(|child| {
        matches!(
            child,
            TemplateChildNode::Text(_) | TemplateChildNode::Interpolation(_)
        )
    });

    if all_text_or_interp && !children.is_empty() {
        ctx.newline();
        ctx.use_helper(RuntimeHelper::CreateText);
        ctx.push(ctx.helper(RuntimeHelper::CreateText));
        ctx.push("(");

        let has_interpolation = children
            .iter()
            .any(|c| matches!(c, TemplateChildNode::Interpolation(_)));

        for (i, child) in children.iter().enumerate() {
            if i > 0 {
                ctx.push(" + ");
            }
            match child {
                TemplateChildNode::Text(text) => {
                    ctx.push("\"");
                    ctx.push(&super::super::helpers::escape_js_string(&text.content));
                    ctx.push("\"");
                }
                TemplateChildNode::Interpolation(interp) => {
                    // Vue 1.x raw-HTML `{{{ … }}}` renders unescaped.
                    #[cfg(feature = "legacy")]
                    let raw = interp.raw;
                    #[cfg(not(feature = "legacy"))]
                    let raw = false;
                    if raw {
                        generate_slot_expression(ctx, &interp.content);
                    } else {
                        ctx.use_helper(RuntimeHelper::ToDisplayString);
                        ctx.push(ctx.helper(RuntimeHelper::ToDisplayString));
                        ctx.push("(");
                        generate_slot_expression(ctx, &interp.content);
                        ctx.push(")");
                    }
                }
                _ => {}
            }
        }

        if has_interpolation {
            ctx.push(", 1 /* TEXT */)");
        } else {
            ctx.push(")");
        }
    } else {
        for (i, child) in children.iter().enumerate() {
            if i > 0 {
                ctx.push(",");
            }
            ctx.newline();
            generate_slot_child_node(ctx, child);
        }
    }
}

/// Generate a single child node for slot content
fn generate_slot_child_node(ctx: &mut CodegenContext, child: &TemplateChildNode<'_>) {
    match child {
        TemplateChildNode::Text(text) => {
            ctx.use_helper(RuntimeHelper::CreateText);
            ctx.push(ctx.helper(RuntimeHelper::CreateText));
            ctx.push("(\"");
            ctx.push(&super::super::helpers::escape_js_string(&text.content));
            ctx.push("\")");
        }
        TemplateChildNode::Interpolation(interp) => {
            ctx.use_helper(RuntimeHelper::CreateText);
            ctx.push(ctx.helper(RuntimeHelper::CreateText));
            ctx.push("(");
            // Vue 1.x raw-HTML `{{{ … }}}` renders unescaped.
            #[cfg(feature = "legacy")]
            let raw = interp.raw;
            #[cfg(not(feature = "legacy"))]
            let raw = false;
            if raw {
                // Generate expression, stripping _ctx. prefix for slot params
                generate_slot_expression(ctx, &interp.content);
            } else {
                ctx.use_helper(RuntimeHelper::ToDisplayString);
                ctx.push(ctx.helper(RuntimeHelper::ToDisplayString));
                ctx.push("(");
                // Generate expression, stripping _ctx. prefix for slot params
                generate_slot_expression(ctx, &interp.content);
                ctx.push(")");
            }
            ctx.push(", 1 /* TEXT */)");
        }
        _ => {
            generate_node(ctx, child);
        }
    }
}

/// Generate expression for slot content, stripping _ctx. prefix for slot parameters
fn generate_slot_expression(ctx: &mut CodegenContext, expr: &ExpressionNode<'_>) {
    match expr {
        ExpressionNode::Simple(exp) => {
            if exp.is_static {
                ctx.push("\"");
                ctx.push(&exp.content);
                ctx.push("\"");
            } else {
                // Strip _ctx. prefix for slot parameters
                let content = strip_ctx_prefix_for_slot_params(ctx, &exp.content);
                ctx.push(&content);
            }
        }
        ExpressionNode::Compound(comp) => {
            for child in comp.children.iter() {
                match child {
                    crate::CompoundExpressionChild::Simple(exp) => {
                        if exp.is_static {
                            ctx.push("\"");
                            ctx.push(&exp.content);
                            ctx.push("\"");
                        } else {
                            let content = strip_ctx_prefix_for_slot_params(ctx, &exp.content);
                            ctx.push(&content);
                        }
                    }
                    crate::CompoundExpressionChild::String(s) => {
                        ctx.push(s);
                    }
                    crate::CompoundExpressionChild::Symbol(helper) => {
                        ctx.push(ctx.helper(*helper));
                    }
                    _ => {}
                }
            }
        }
    }
}

/// Strip _ctx. prefix from identifiers that are slot parameters
fn strip_ctx_prefix_for_slot_params(ctx: &CodegenContext, content: &str) -> String {
    let mut result = String::new(content);
    for param in &ctx.slot_params {
        // Replace _ctx.paramName with paramName
        let mut prefixed = String::with_capacity(5 + param.len());
        prefixed.push_str("_ctx.");
        prefixed.push_str(param);
        let replaced = result.replace(prefixed.as_str(), param.as_str());
        result = String::from(replaced);
    }
    result
}