vize_atelier_ssr 0.258.0

Vue SSR compiler for Vize
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use super::SsrCodegenContext;
use vize_atelier_core::{BindingType, RuntimeHelper};
use vize_carton::{String, ToCompactString, camelize, capitalize};

struct ComponentBinding {
    name: String,
    binding_type: BindingType,
    suffix: Option<String>,
}

impl<'a> SsrCodegenContext<'a> {
    pub(crate) fn resolve_component_binding_expr(&mut self, component: &str) -> Option<String> {
        let binding = self.resolve_component_binding(component)?;
        let needs_unref = self.options.inline
            && matches!(
                binding.binding_type,
                BindingType::SetupLet | BindingType::SetupMaybeRef | BindingType::SetupRef
            );
        let mut resolved = String::default();

        if needs_unref {
            self.use_core_helper(RuntimeHelper::Unref);
            resolved.push_str("_unref(");
        } else if !self.options.inline {
            resolved.push_str("$setup.");
        }
        resolved.push_str(binding.name.as_str());
        if needs_unref {
            resolved.push(')');
        }
        if let Some(suffix) = binding.suffix {
            resolved.push('.');
            resolved.push_str(suffix.as_str());
        }

        Some(resolved)
    }

    fn resolve_component_binding(&self, component: &str) -> Option<ComponentBinding> {
        let metadata = self.options.binding_metadata.as_ref()?;
        let resolve_base = |name: &str| {
            if let Some(binding_type) = metadata.bindings.get(name) {
                return Some((name.to_compact_string(), *binding_type));
            }
            let camel = camelize(name);
            if let Some(binding_type) = metadata.bindings.get(camel.as_str()) {
                return Some((camel, *binding_type));
            }
            let pascal = capitalize(camel.as_str());
            metadata
                .bindings
                .get(pascal.as_str())
                .map(|binding_type| (pascal, *binding_type))
        };

        let (base, suffix) = component
            .split_once('.')
            .map_or((component, None), |(base, suffix)| (base, Some(suffix)));
        let (name, binding_type) = resolve_base(base)?;
        Some(ComponentBinding {
            name,
            binding_type,
            suffix: suffix.map(|suffix| suffix.to_compact_string()),
        })
    }
}