rejoice 0.12.0

A simple and delightful little web framework for Rust
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
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use std::path::Path;

/// Checks if there are any island components (tsx/jsx files) in client/
pub fn has_island_components() -> bool {
    let client_dir = Path::new("client");
    let Ok(entries) = std::fs::read_dir(client_dir) else {
        return false;
    };

    for entry in entries.flatten() {
        let path = entry.path();
        if let Some(ext) = path.extension()
            && (ext == "tsx" || ext == "jsx")
            && let Some(stem) = path.file_stem()
        {
            let name = stem.to_string_lossy().to_string();
            if name != "islands" && name != "styles" {
                return true;
            }
        }
    }

    false
}

/// Generates the islands.tsx registry file from all component files in client/
/// Returns true if islands were found and the file was generated.
pub fn generate_islands_registry() -> bool {
    let client_dir = Path::new("client");
    let Ok(entries) = std::fs::read_dir(client_dir) else {
        return false;
    };

    let mut components: Vec<String> = Vec::new();

    for entry in entries.flatten() {
        let path = entry.path();
        if let Some(ext) = path.extension()
            && (ext == "tsx" || ext == "jsx")
            && let Some(stem) = path.file_stem()
        {
            let name = stem.to_string_lossy().to_string();
            // Skip the islands.tsx file itself
            if name != "islands" {
                components.push(name);
            }
        }
    }

    if components.is_empty() {
        return false;
    }

    let output = generate_islands_code(&components);
    std::fs::write(client_dir.join("islands.tsx"), output).expect("Failed to write islands.tsx");
    true
}

fn generate_islands_code(components: &[String]) -> String {
    let mut output = String::new();

    // Imports
    output.push_str("import { render } from \"solid-js/web\";\n\n");

    for name in components {
        output.push_str(&format!("import {name} from \"./{name}\";\n"));
    }

    // Islands registry
    output.push_str("\nconst islands: Record<string, any> = {\n");
    for name in components {
        output.push_str(&format!("  {name},\n"));
    }
    output.push_str("};\n\n");

    // Hydration function
    output.push_str(HYDRATE_ISLANDS_CODE);

    output
}

/// Generates a vite.config.ts appropriate for the current project
/// If has_islands is true, includes islands.tsx as an input
pub fn generate_vite_config(has_islands: bool) {
    let content = if has_islands {
        r#"import { defineConfig } from "vite";
import solid from "vite-plugin-solid";
import tailwindcss from "@tailwindcss/vite";

export default defineConfig({
  plugins: [solid(), tailwindcss()],
  build: {
    outDir: "dist",
    rollupOptions: {
      input: {
        islands: "client/islands.tsx",
        styles: "client/styles.css",
      },
      output: {
        entryFileNames: "[name].js",
        assetFileNames: "[name].[ext]",
      },
    },
  },
});
"#
    } else {
        r#"import { defineConfig } from "vite";
import tailwindcss from "@tailwindcss/vite";

export default defineConfig({
  plugins: [tailwindcss()],
  build: {
    outDir: "dist",
    rollupOptions: {
      input: {
        styles: "client/styles.css",
      },
      output: {
        assetFileNames: "[name].[ext]",
      },
    },
  },
});
"#
    };

    std::fs::write("vite.config.ts", content).expect("Failed to write vite.config.ts");
}

const HYDRATE_ISLANDS_CODE: &str = r#"function hydrateIslands() {
  document.querySelectorAll("[data-island]").forEach((el) => {
    const name = el.getAttribute("data-island");
    const props = JSON.parse(el.getAttribute("data-props") || "{}");
    const Component = islands[name!];
    if (Component) {
      el.innerHTML = "";
      render(() => <Component {...props} />, el);
    }
  });
}

// Expose for live reload re-hydration
(window as any).__hydrateIslands = hydrateIslands;

if (document.readyState === "loading") {
  document.addEventListener("DOMContentLoaded", hydrateIslands);
} else {
  hydrateIslands();
}
"#;