cargo-leptos 0.1.2

Build tool for Leptos.
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::{
    ext::{
        anyhow::{anyhow, Result},
        MetadataExt, PathBufExt, PathExt,
    },
    service::site::{SiteFile, SourcedSiteFile},
    Opts,
};
use camino::Utf8PathBuf;
use cargo_metadata::Metadata;

use super::{project::ProjectDefinition, ProjectConfig};

pub struct LibPackage {
    pub name: String,
    /// absolute dir to package
    pub abs_dir: Utf8PathBuf,
    pub rel_dir: Utf8PathBuf,
    pub wasm_file: SourcedSiteFile,
    pub js_file: SiteFile,
    pub features: Vec<String>,
    pub default_features: bool,
    pub output_name: String,
    pub src_paths: Vec<Utf8PathBuf>,
}

impl LibPackage {
    pub fn resolve(
        cli: &Opts,
        metadata: &Metadata,
        project: &ProjectDefinition,
        config: &ProjectConfig,
    ) -> Result<Self> {
        let name = project.lib_package.clone();
        let packages = metadata.workspace_packages();
        let output_name = if !config.output_name.is_empty() {
            config.output_name.clone()
        } else {
            name.replace('-', "_")
        };

        let package = packages
            .iter()
            .find(|p| p.name == *name)
            .ok_or_else(|| anyhow!(r#"Could not find the project lib-package "{name}""#,))?;

        let features = if !config.lib_features.is_empty() {
            config.lib_features.clone()
        } else if !cli.lib_features.is_empty() {
            cli.lib_features.clone()
        } else {
            vec![]
        };

        let abs_dir = package.manifest_path.clone().without_last();
        let rel_dir = abs_dir.unbase(&metadata.workspace_root)?;
        let profile = cli.profile();

        let wasm_file = {
            let source = metadata
                .rel_target_dir()
                .join("front")
                .join("wasm32-unknown-unknown")
                .join(&profile)
                .join(&name.replace('-', "_"))
                .with_extension("wasm");
            let site = config
                .site_pkg_dir
                .join(&output_name)
                .with_extension("wasm");
            let dest = config.site_root.join(&site);
            SourcedSiteFile { source, dest, site }
        };

        let js_file = {
            let site = config.site_pkg_dir.join(&output_name).with_extension("js");
            let dest = config.site_root.join(&site);
            SiteFile { dest, site }
        };

        let mut src_deps = metadata.src_path_dependencies(&package.id);
        if rel_dir == "." {
            src_deps.push("src".into());
        } else {
            src_deps.push(rel_dir.join("src"));
        }
        Ok(Self {
            name,
            abs_dir,
            rel_dir,
            wasm_file,
            js_file,
            features,
            default_features: config.lib_default_features,
            output_name,
            src_paths: src_deps,
        })
    }
}

impl std::fmt::Debug for LibPackage {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("LibPackage")
            .field("name", &self.name)
            .field("rel_dir", &self.rel_dir.test_string())
            .field("wasm_file", &self.wasm_file)
            .field("js_file", &self.js_file)
            .field("features", &self.features)
            .field("default_features", &self.default_features)
            .field("output_name", &self.output_name)
            .field(
                "src_paths",
                &self
                    .src_paths
                    .iter()
                    .map(|p| p.test_string())
                    .collect::<Vec<_>>()
                    .join(", "),
            )
            .finish_non_exhaustive()
    }
}