SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Web files: designs live in the browser (OPFS), files come in by picker or drop and go out as downloads
bherbruckc9ed3d154d53
diff --git a/Cargo.lock b/Cargo.lockindex 19b464055a..7f0b7069b0 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3260,7 +3260,9 @@ version = "0.1.0"dependencies = ["eframe","egui",+ "js-sys","log",+ "serde_json","solvecraft-engine","solvecraft-ui-egui","wasm-bindgen",diff --git a/apps/solvecraft-web/Cargo.toml b/apps/solvecraft-web/Cargo.tomlindex 0a093c3c21..e29ae19812 100644--- a/apps/solvecraft-web/Cargo.toml+++ b/apps/solvecraft-web/Cargo.toml@@ -23,4 +23,10 @@ log = { workspace = true }eframe = { workspace = true, features = ["default_fonts", "wgpu", "accesskit"] }wasm-bindgen = "0.2"wasm-bindgen-futures = "0.4"-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "Location"] }+js-sys = "0.3"+serde_json = { workspace = true }+web-sys = { version = "0.3", features = [+ "Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "Location", "Navigator", "StorageManager",+ "FileSystemHandle", "FileSystemDirectoryHandle", "FileSystemFileHandle", "FileSystemGetFileOptions", "FileSystemWritableFileStream",+ "WritableStream", "File", "FileList", "Blob", "BlobPropertyBag", "Url", "HtmlAnchorElement", "HtmlInputElement", "Storage",+] }diff --git a/apps/solvecraft-web/src/files.rs b/apps/solvecraft-web/src/files.rsnew file mode 100644index 0000000000..8f20438e3a--- /dev/null+++ b/apps/solvecraft-web/src/files.rs@@ -0,0 +1,476 @@+//! Files in the browser. Designs are kept in the origin private file system (OPFS): read into+//! the engine's in-memory files (`solvecraft_engine::io::vfs`) at start, written back whenever a+//! command writes one. Files come in from the computer through a file picker (the File System+//! Access API where the browser has it, an `<input type=file>` otherwise) or a drop on the page,+//! and go out as downloads (exports, and "Download design"). An autosave of unsaved work is kept+//! in OPFS too and offered again after a reload or a crash.++use std::cell::{Cell, RefCell};+use std::rc::Rc;++use js_sys::{Array, Function, Object, Reflect, Uint8Array};+use solvecraft_engine::io::vfs;+use wasm_bindgen::{JsCast as _, JsValue, closure::Closure};+use wasm_bindgen_futures::{JsFuture, spawn_local};+use web_sys::{FileSystemDirectoryHandle, FileSystemFileHandle, FileSystemGetFileOptions, FileSystemWritableFileStream};++/// Where OPFS files appear to the engine.+pub const OPFS: &str = "/opfs/";+/// Paths written here are handed to the user as downloads.+pub const DOWNLOADS: &str = "/downloads/";+/// Files brought in from the computer.+pub const UPLOAD: &str = "/upload/";+/// The autosave of unsaved work (in OPFS: `recovery.solvecraft` and `recovery.json`).+const RECOVERY: &str = "recovery.solvecraft";+const RECOVERY_META: &str = "recovery.json";++/// What to do with a file brought in from the computer.+#[derive(Clone, Copy, Debug, PartialEq)]+pub enum Intent {+ /// Open it (a design, or STEP/mesh as a new design).+ Open,+ /// Add its bodies to the open design (STEP, 3MF, STL).+ Insert,+}++/// A stored design, as the file panel lists it.+#[derive(Clone, Debug)]+pub struct Entry {+ pub name: String,+ pub size: u64,+ /// Last written (ms since 1970; 0 when unknown).+ pub modified: f64,+}++/// State shared between the async browser calls and the app's frames.+#[derive(Default)]+pub struct Files {+ pub entries: RefCell<Vec<Entry>>,+ /// Files read from the computer: (name, bytes, what to do).+ pub incoming: RefCell<Vec<(String, Vec<u8>, Intent)>>,+ /// Messages for the status line (errors and confirmations).+ pub messages: RefCell<Vec<(String, bool)>>,+ /// The stored designs are loaded (the app may open them).+ pub ready: Cell<bool>,+ /// The file panel is open.+ pub panel: Cell<bool>,+ /// An autosave left by an earlier session: its design's name and file.+ pub recovery: RefCell<Option<(String, Option<String>)>>,+ /// The app's context, to wake it when a browser call finishes.+ pub ctx: RefCell<Option<egui::Context>>,+}++impl Files {+ fn say(&self, text: impl Into<String>, error: bool) {+ self.messages.borrow_mut().push((text.into(), error));+ self.wake();+ }++ /// A file arrived from the computer.+ fn arrive(&self, name: String, bytes: Vec<u8>, intent: Intent) {+ self.incoming.borrow_mut().push((name, bytes, intent));+ self.wake();+ }++ /// Run a frame (the app sleeps until something happens).+ fn wake(&self) {+ if let Some(c) = self.ctx.borrow().as_ref() {+ c.request_repaint();+ }+ }+}++thread_local! {+ /// The private file system isn't there (an insecure page: http on a network address, or an+ /// old browser): designs are kept in local storage instead.+ static LOCAL: Cell<bool> = const { Cell::new(false) };+}++/// Local storage keys of stored files.+const LOCAL_PREFIX: &str = "solvecraft.file.";++fn local() -> Result<web_sys::Storage, String> {+ web_sys::window().and_then(|w| w.local_storage().ok().flatten()).ok_or_else(|| "this browser keeps no local storage".to_string())+}++/// Text as is, anything else as hex (local storage holds strings).+fn encode(bytes: &[u8]) -> String {+ match std::str::from_utf8(bytes) {+ Ok(t) => format!("t{t}"),+ Err(_) => {+ let mut s = String::with_capacity(bytes.len() * 2 + 1);+ s.push('x');+ for b in bytes {+ s.push_str(&format!("{b:02x}"));+ }+ s+ }+ }+}++fn decode(s: &str) -> Vec<u8> {+ if let Some(t) = s.strip_prefix('t') {+ return t.as_bytes().to_vec();+ }+ let h = s.strip_prefix('x').unwrap_or("");+ (0..h.len() / 2).filter_map(|i| h.get(2 * i..2 * i + 2).and_then(|x| u8::from_str_radix(x, 16).ok())).collect()+}++/// Is the browser's storage local storage (no OPFS here)?+pub fn local_only() -> bool {+ LOCAL.with(Cell::get)+}++fn err(e: JsValue) -> String {+ e.as_string().or_else(|| Reflect::get(&e, &"message".into()).ok().and_then(|m| m.as_string())).unwrap_or_else(|| format!("{e:?}"))+}++/// The browser's storage manager: missing on insecure pages (http on a network address) and in+/// old browsers, where calling into it would throw.+fn storage_manager() -> Option<web_sys::StorageManager> {+ let nav = web_sys::window()?.navigator();+ let sm = Reflect::get(&nav, &"storage".into()).ok().filter(|v| v.is_object())?;+ Some(sm.unchecked_into())+}++/// Does the storage manager have `method`?+fn has(sm: &web_sys::StorageManager, method: &str) -> bool {+ Reflect::get(sm, &method.into()).is_ok_and(|f| f.is_function())+}++async fn root() -> Result<FileSystemDirectoryHandle, String> {+ let sm = storage_manager().filter(|sm| has(sm, "getDirectory")).ok_or("this page has no private file storage (it needs https or localhost)")?;+ let dir = JsFuture::from(sm.get_directory()).await.map_err(err)?;+ dir.dyn_into::<FileSystemDirectoryHandle>().map_err(|_| "this browser has no private file storage (OPFS)".to_string())+}++async fn read_handle(h: &FileSystemFileHandle) -> Result<Vec<u8>, String> {+ let file: web_sys::File = JsFuture::from(h.get_file()).await.map_err(err)?.dyn_into().map_err(|_| "not a file".to_string())?;+ blob_bytes(&file).await+}++async fn blob_bytes(b: &web_sys::Blob) -> Result<Vec<u8>, String> {+ let buf = JsFuture::from(b.array_buffer()).await.map_err(err)?;+ Ok(Uint8Array::new(&buf).to_vec())+}++async fn file_handle(dir: &FileSystemDirectoryHandle, name: &str, create: bool) -> Result<FileSystemFileHandle, String> {+ let opts = FileSystemGetFileOptions::new();+ opts.set_create(create);+ JsFuture::from(dir.get_file_handle_with_options(name, &opts)).await.map_err(err)?.dyn_into().map_err(|_| "not a file".to_string())+}++async fn write_file(name: &str, bytes: &[u8]) -> Result<(), String> {+ if local_only() {+ return local()?+ .set_item(&format!("{LOCAL_PREFIX}{name}"), &encode(bytes))+ .map_err(|e| format!("local storage is full or blocked: {}", err(e)));+ }+ let dir = root().await?;+ let h = file_handle(&dir, name, true).await?;+ let w: FileSystemWritableFileStream =+ JsFuture::from(h.create_writable()).await.map_err(err)?.dyn_into().map_err(|_| "no writable stream".to_string())?;+ JsFuture::from(w.write_with_u8_array(bytes).map_err(err)?).await.map_err(err)?;+ JsFuture::from(w.close()).await.map_err(err)?;+ Ok(())+}++async fn remove_file(name: &str) -> Result<(), String> {+ if local_only() {+ return local()?.remove_item(&format!("{LOCAL_PREFIX}{name}")).map_err(err);+ }+ let dir = root().await?;+ JsFuture::from(dir.remove_entry(name)).await.map_err(err)?;+ Ok(())+}++/// Every stored file in local storage.+fn read_local() -> Result<Vec<(String, Vec<u8>, f64)>, String> {+ let st = local()?;+ let mut out = Vec::new();+ for i in 0..st.length().unwrap_or(0).min(10_000) {+ let Some(k) = st.key(i).ok().flatten() else { continue };+ let Some(name) = k.strip_prefix(LOCAL_PREFIX) else { continue };+ if let Some(v) = st.get_item(&k).ok().flatten() {+ out.push((name.to_string(), decode(&v), 0.0));+ }+ }+ Ok(out)+}++/// Every stored file: (name, bytes). Without OPFS, local storage takes over from here on.+async fn read_all() -> Result<Vec<(String, Vec<u8>, f64)>, String> {+ let dir = match root().await {+ Ok(d) => d,+ Err(e) => {+ log::warn!("no OPFS ({e}): designs go to local storage");+ LOCAL.with(|l| l.set(true));+ return read_local();+ }+ };+ let iter: JsValue = dir.values().into();+ let next: Function = Reflect::get(&iter, &"next".into()).map_err(err)?.dyn_into().map_err(|_| "no iterator".to_string())?;+ let mut out = Vec::new();+ for _ in 0..10_000 {+ let step = JsFuture::from(js_sys::Promise::resolve(&next.call0(&iter).map_err(err)?)).await.map_err(err)?;+ if Reflect::get(&step, &"done".into()).ok().and_then(|d| d.as_bool()).unwrap_or(true) {+ break;+ }+ let Ok(h) = Reflect::get(&step, &"value".into()).map_err(err)?.dyn_into::<FileSystemFileHandle>() else { continue };+ let file =+ match JsFuture::from(h.get_file()).await.map_err(err).and_then(|f| f.dyn_into::<web_sys::File>().map_err(|_| "not a file".to_string())) {+ Ok(f) => f,+ Err(e) => {+ log::warn!("{}: {e}", h.name());+ continue;+ }+ };+ match blob_bytes(&file).await {+ Ok(b) => out.push((h.name(), b, file.last_modified())),+ Err(e) => log::warn!("{}: {e}", h.name()),+ }+ }+ Ok(out)+}++/// Ask the browser to keep the storage (not evict it under pressure), then load every stored+/// file into the engine's files.+pub fn start(files: &Rc<Files>) {+ if let Some(sm) = storage_manager().filter(|sm| has(sm, "persist"))+ && let Ok(p) = sm.persist()+ {+ spawn_local(async move {+ let _ = JsFuture::from(p).await;+ });+ }+ let files = files.clone();+ spawn_local(async move {+ match read_all().await {+ Ok(all) => {+ if local_only() {+ files.say("This page can't use the browser's file storage (it needs https or localhost): designs are kept in local storage, a few MB at most.", false);+ }+ let mut entries = Vec::new();+ for (name, bytes, modified) in all {+ if name == RECOVERY_META {+ let meta: serde_json::Value = serde_json::from_slice(&bytes).unwrap_or_default();+ let n = meta["name"].as_str().unwrap_or("Untitled").to_string();+ *files.recovery.borrow_mut() = Some((n, meta["path"].as_str().map(str::to_string)));+ continue;+ }+ if name != RECOVERY {+ entries.push(Entry { name: name.clone(), size: bytes.len() as u64, modified });+ }+ vfs::insert(&format!("{OPFS}{name}"), bytes);+ }+ entries.sort_by_key(|a| a.name.to_lowercase());+ *files.entries.borrow_mut() = entries;+ // An autosave without its design file is nothing to recover.+ if !vfs::exists(&format!("{OPFS}{RECOVERY}")) {+ *files.recovery.borrow_mut() = None;+ }+ }+ Err(e) => files.say(format!("browser storage: {e}"), true),+ }+ files.ready.set(true);+ files.wake();+ });+}++/// Store what commands wrote: OPFS paths into OPFS, download paths as downloads.+pub fn flush(files: &Rc<Files>) {+ for (path, bytes) in vfs::take_writes() {+ if let Some(name) = path.strip_prefix(OPFS) {+ let name = name.to_string();+ {+ let mut e = files.entries.borrow_mut();+ e.retain(|x| x.name != name);+ if name != RECOVERY && name != RECOVERY_META {+ e.push(Entry { name: name.clone(), size: bytes.len() as u64, modified: js_sys::Date::now() });+ e.sort_by_key(|a| a.name.to_lowercase());+ }+ }+ let files = files.clone();+ spawn_local(async move {+ if let Err(e) = write_file(&name, &bytes).await {+ files.say(format!("{name}: {e}"), true);+ }+ });+ } else if let Some(name) = path.strip_prefix(DOWNLOADS)+ && let Err(e) = download(name, &bytes)+ {+ files.say(format!("{name}: {e}"), true);+ }+ }+}++/// Hand `bytes` to the user as a download named `name`.+pub fn download(name: &str, bytes: &[u8]) -> Result<(), String> {+ let doc = web_sys::window().and_then(|w| w.document()).ok_or("no document")?;+ let parts = Array::new();+ parts.push(&Uint8Array::from(bytes));+ let opts = web_sys::BlobPropertyBag::new();+ opts.set_type("application/octet-stream");+ let blob = web_sys::Blob::new_with_u8_array_sequence_and_options(&parts, &opts).map_err(err)?;+ let url = web_sys::Url::create_object_url_with_blob(&blob).map_err(err)?;+ let a: web_sys::HtmlAnchorElement = doc.create_element("a").map_err(err)?.dyn_into().map_err(|_| "no anchor".to_string())?;+ a.set_href(&url);+ a.set_download(name);+ a.click();+ // Let the browser start the download before the URL goes.+ let revoke = Closure::once_into_js(move || {+ let _ = web_sys::Url::revoke_object_url(&url);+ });+ if let Some(w) = web_sys::window() {+ let _ = w.set_timeout_with_callback_and_timeout_and_arguments_0(revoke.unchecked_ref(), 10_000);+ }+ Ok(())+}++/// Delete a stored design.+pub fn delete(files: &Rc<Files>, name: &str) {+ let _ = vfs::remove(&format!("{OPFS}{name}"));+ files.entries.borrow_mut().retain(|e| e.name != name);+ let (files, name) = (files.clone(), name.to_string());+ spawn_local(async move {+ if let Err(e) = remove_file(&name).await {+ files.say(format!("{name}: {e}"), true);+ }+ });+}++/// Rename a stored design (a copy under the new name, then the old one goes: not every browser+/// can move OPFS files).+pub fn rename(files: &Rc<Files>, from: &str, to: &str) -> Result<(), String> {+ let to = to.trim();+ if to.is_empty() || to.contains('/') || to.contains('\\') || to.len() > 200 {+ return Err("give a file name without slashes".into());+ }+ if files.entries.borrow().iter().any(|e| e.name == to) {+ return Err(format!("there is already a file named {to}"));+ }+ let bytes = vfs::read(&format!("{OPFS}{from}")).map_err(|e| e.to_string())?;+ vfs::write(&format!("{OPFS}{to}"), &bytes).map_err(|e| e.to_string())?;+ delete(files, from);+ flush(files);+ Ok(())+}++/// Keep (or drop) the autosave of the open design.+pub fn autosave(files: &Rc<Files>, doc: Option<(&solvecraft_engine::doc::Document, Option<&str>)>) {+ let files = files.clone();+ match doc {+ Some((d, path)) => {+ let bytes = solvecraft_engine::io::write_design(d);+ let meta = serde_json::json!({"name": d.name, "path": path, "saved_at": js_sys::Date::now()}).to_string();+ spawn_local(async move {+ let r = async {+ write_file(RECOVERY, &bytes).await?;+ write_file(RECOVERY_META, meta.as_bytes()).await+ };+ if let Err(e) = r.await {+ files.say(format!("autosave: {e}"), true);+ }+ });+ }+ None => spawn_local(async move {+ let _ = remove_file(RECOVERY).await;+ let _ = remove_file(RECOVERY_META).await;+ }),+ }+}++/// A stored path for `name` that no stored file has: `name`, else `name (2)`, `name (3)`…+pub fn free_name(name: &str) -> String {+ let (stem, ext) = name.rsplit_once('.').map(|(s, e)| (s.to_string(), format!(".{e}"))).unwrap_or((name.to_string(), String::new()));+ for i in 1..1000 {+ let n = if i == 1 { name.to_string() } else { format!("{stem} ({i}){ext}") };+ let p = format!("{OPFS}{n}");+ if !vfs::exists(&p) {+ return p;+ }+ }+ format!("{OPFS}{stem} ({}){ext}", js_sys::Date::now() as u64)+}++/// The autosaved design's path (in the engine's files) for opening it.+pub fn recovery_path() -> String {+ format!("{OPFS}{RECOVERY}")+}++/// Pick files on the computer: the File System Access picker where there is one, else an+/// `<input type=file>`. Read files arrive in `files.incoming`.+pub fn pick_from_disk(files: &Rc<Files>, intent: Intent) {+ let Some(window) = web_sys::window() else { return };+ let picker = Reflect::get(&window, &"showOpenFilePicker".into()).ok().and_then(|f| f.dyn_into::<Function>().ok());+ match picker {+ Some(f) => {+ let opts = Object::new();+ let _ = Reflect::set(&opts, &"multiple".into(), &JsValue::FALSE);+ let promise = f.call1(&window, &opts);+ let files = files.clone();+ spawn_local(async move {+ let r = async {+ let p: js_sys::Promise = promise.map_err(err)?.dyn_into().map_err(|_| "no promise".to_string())?;+ let handles: Array = JsFuture::from(p).await.map_err(err)?.dyn_into().map_err(|_| "no files".to_string())?;+ for h in handles.iter() {+ let h: FileSystemFileHandle = h.dyn_into().map_err(|_| "not a file".to_string())?;+ let bytes = read_handle(&h).await?;+ files.arrive(h.name(), bytes, intent);+ }+ Ok::<(), String>(())+ };+ match r.await {+ Ok(()) => {}+ // Closing the picker is no error.+ Err(e) if e.contains("abort") || e.contains("Abort") => {}+ Err(e) => files.say(format!("open: {e}"), true),+ }+ });+ }+ None => input_picker(files, intent),+ }+}++fn input_picker(files: &Rc<Files>, intent: Intent) {+ let Some(doc) = web_sys::window().and_then(|w| w.document()) else { return };+ let Ok(input) = doc.create_element("input").map(|e| e.unchecked_into::<web_sys::HtmlInputElement>()) else { return };+ input.set_type("file");+ input.set_accept(".solvecraft,.step,.stp,.3mf,.stl");+ // Attached (hidden) while it is open: some browsers ignore a click on a detached input.+ let _ = input.set_attribute("style", "display:none");+ if let Some(body) = doc.body() {+ let _ = body.append_child(&input);+ }+ let (files, el) = (files.clone(), input.clone());+ let on_change = Closure::once_into_js(move || {+ el.remove();+ let Some(list) = el.files() else { return };+ for i in 0..list.length() {+ let Some(f) = list.get(i) else { continue };+ let files = files.clone();+ spawn_local(async move {+ match blob_bytes(&f).await {+ Ok(b) => files.arrive(f.name(), b, intent),+ Err(e) => files.say(format!("{}: {e}", f.name()), true),+ }+ });+ }+ });+ input.set_onchange(Some(on_change.unchecked_ref()));+ input.click();+}++/// Read files dropped on the page.+pub fn take_drops(files: &Rc<Files>, raw: &mut egui::RawInput) {+ for f in std::mem::take(&mut raw.dropped_files) {+ let files = files.clone();+ spawn_local(async move {+ let name = f.path().file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped".into());+ match f.bytes_async().await {+ Ok(b) => files.arrive(name, b, Intent::Insert),+ Err(e) => files.say(format!("{name}: {e}"), true),+ }+ });+ }+}diff --git a/apps/solvecraft-web/src/main.rs b/apps/solvecraft-web/src/main.rsindex b64f779dfb..4dde3a1591 100644--- a/apps/solvecraft-web/src/main.rs+++ b/apps/solvecraft-web/src/main.rs@@ -6,30 +6,304 @@//! sample part.#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]+#[cfg(target_arch = "wasm32")]+mod files;+#[cfg(target_arch = "wasm32")]mod web {+ use std::rc::Rc;+use solvecraft_engine::Session;+ use solvecraft_engine::io::vfs;use solvecraft_ui_egui::{Services, SolveApp};use wasm_bindgen::JsCast as _;+ use crate::files::{self, Files, Intent};+const CANVAS_ID: &str = "solvecraft_canvas";const LOADING_ID: &str = "solvecraft_loading";const DEPTH_BITS: u8 = 24;- struct Shell(SolveApp);+ /// Seconds between autosaves of unsaved work.+ const AUTOSAVE_S: f64 = 30.0;++ struct Shell {+ app: SolveApp,+ files: Rc<Files>,+ /// When the last autosave was (seconds), and the revision it holds (none stored: `None`).+ autosaved_at: f64,+ autosaved: Option<u64>,+ /// A stored design being renamed: (its name, the new name).+ renaming: Option<(String, String)>,+ /// The rename field takes the keyboard when it appears.+ rename_focus: bool,+ /// The start page's recent designs were filled from the stored ones.+ recents_synced: bool,+ }++ impl Shell {+ /// Files from the computer, writes to store, messages and the autosave.+ fn files_tick(&mut self, ctx: &egui::Context) {+ if self.files.ctx.borrow().is_none() {+ *self.files.ctx.borrow_mut() = Some(ctx.clone());+ }+ files::flush(&self.files);+ for (text, error) in self.files.messages.borrow_mut().drain(..) {+ self.app.set_status(text, error);+ }+ let incoming: Vec<_> = self.files.incoming.borrow_mut().drain(..).collect();+ for (name, bytes, intent) in incoming {+ let design = name.ends_with(&format!(".{}", solvecraft_engine::io::DESIGN_EXT));+ let path = if design && intent == Intent::Open {+ // A design from the computer is kept in the browser (a copy), so Save works.+ let path = files::free_name(&name);+ if let Err(e) = vfs::write(&path, &bytes) {+ self.app.set_status(e.to_string(), true);+ }+ files::flush(&self.files);+ path+ } else {+ let path = format!("{}{name}", files::UPLOAD);+ vfs::insert(&path, bytes);+ path+ };+ match intent {+ Intent::Open => self.app.open_path(&path),+ Intent::Insert => self.app.drop_path(&path),+ }+ self.files.panel.set(false);+ }+ if self.files.ready.get() && !self.recents_synced {+ self.recents_synced = true;+ self.sync_recents();+ }+ let now = ctx.input(|i| i.time);+ // Unsaved work is kept (at most every AUTOSAVE_S); saved work needs no autosave.+ if self.files.ready.get() && self.files.recovery.borrow().is_none() {+ let s = &self.app.session;+ let changed = s.is_dirty() && self.autosaved != Some(s.revision);+ let wait = AUTOSAVE_S - (now - self.autosaved_at);+ if changed && wait <= 0.0 {+ files::autosave(&self.files, Some((&s.doc, s.path.as_deref())));+ self.autosaved = Some(s.revision);+ self.autosaved_at = now;+ } else if changed {+ // Come back for it even when nothing else happens.+ ctx.request_repaint_after(std::time::Duration::from_secs_f64(wait));+ } else if !s.is_dirty() && self.autosaved.is_some() {+ files::autosave(&self.files, None);+ self.autosaved = None;+ }+ }+ if !self.files.ready.get() || !self.files.incoming.borrow().is_empty() {+ ctx.request_repaint_after(std::time::Duration::from_millis(100));+ }+ }++ /// The start page's recent designs are the stored ones: the remembered order first (those+ /// still stored), then the others, newest first.+ fn sync_recents(&mut self) {+ let mut entries = self.files.entries.borrow().clone();+ entries.sort_by(|a, b| b.modified.total_cmp(&a.modified));+ let recent = &mut self.app.home.recent;+ recent.retain(|p| vfs::exists(p));+ for e in entries.iter().filter(|e| e.name.ends_with(&format!(".{}", solvecraft_engine::io::DESIGN_EXT))) {+ let p = format!("{}{}", files::OPFS, e.name);+ if !recent.contains(&p) {+ recent.push(p);+ }+ }+ recent.truncate(solvecraft_ui_egui::home::MAX_RECENT);+ }++ /// The stored designs: open, insert, rename, delete, download; open from the computer.+ fn file_panel(&mut self, ctx: &egui::Context) {+ if !self.files.panel.get() {+ return;+ }+ let mut open = true;+ let mut act: Option<(&'static str, String)> = None;+ egui::Window::new("Files in this browser")+ .open(&mut open)+ .collapsible(false)+ .resizable(true)+ .default_width(520.0)+ .pivot(egui::Align2::CENTER_CENTER)+ .default_pos(ctx.content_rect().center())+ .show(ctx, |ui| {+ ui.horizontal(|ui| {+ if ui.button("Open from computer…").clicked() {+ files::pick_from_disk(&self.files, Intent::Open);+ }+ if ui.button("Insert from computer…").on_hover_text("STEP, 3MF or STL into the open design").clicked() {+ files::pick_from_disk(&self.files, Intent::Insert);+ }+ if ui.button("Download open design").clicked() {+ act = Some(("download_open", String::new()));+ }+ });+ ui.separator();+ if !self.files.ready.get() {+ ui.horizontal(|ui| {+ ui.spinner();+ ui.label("Reading the browser's storage…");+ });+ return;+ }+ let entries = self.files.entries.borrow().clone();+ if entries.is_empty() {+ ui.label("Designs you save appear here. They stay in this browser.");+ }+ egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {+ egui::Grid::new("opfs_files").num_columns(3).spacing([12.0, 6.0]).show(ui, |ui| {+ for e in &entries {+ match &mut self.renaming {+ Some((from, to)) if *from == e.name => {+ let r = ui.add(egui::TextEdit::singleline(to).desired_width(200.0));+ if std::mem::take(&mut self.rename_focus) {+ r.request_focus();+ }+ if r.lost_focus() {+ act = Some(if ui.input(|i| i.key_pressed(egui::Key::Enter)) {+ ("rename", to.clone())+ } else {+ ("rename_cancel", String::new())+ });+ }+ }+ _ => {+ ui.label(&e.name);+ }+ }+ ui.label(format!("{:.1} KB", e.size as f64 / 1024.0));+ ui.horizontal(|ui| {+ if ui.small_button("Open").clicked() {+ act = Some(("open", e.name.clone()));+ }+ let design = e.name.ends_with(&format!(".{}", solvecraft_engine::io::DESIGN_EXT));+ if !design && ui.small_button("Insert").on_hover_text("Into the open design (STEP, 3MF, STL)").clicked() {+ act = Some(("insert", e.name.clone()));+ }+ if ui.small_button("Rename").clicked() {+ self.renaming = Some((e.name.clone(), e.name.clone()));+ self.rename_focus = true;+ }+ if ui.small_button("Download").clicked() {+ act = Some(("download", e.name.clone()));+ }+ if ui.small_button("Delete").clicked() {+ act = Some(("delete", e.name.clone()));+ }+ });+ ui.end_row();+ }+ });+ });+ });+ if !open {+ self.files.panel.set(false);+ self.renaming = None;+ }+ let Some((what, name)) = act else { return };+ let path = format!("{}{name}", files::OPFS);+ match what {+ "open" => {+ self.app.open_path(&path);+ self.files.panel.set(false);+ }+ "insert" => {+ self.app.insert_path(&path);+ self.files.panel.set(false);+ }+ "download" => match vfs::read(&path) {+ Ok(b) => {+ if let Err(e) = files::download(&name, &b) {+ self.app.set_status(e, true);+ }+ }+ Err(e) => self.app.set_status(e.to_string(), true),+ },+ "download_open" => {+ let d = &self.app.session.doc;+ let bytes = solvecraft_engine::io::write_design(d);+ if let Err(e) = files::download(&format!("{}.{}", d.name, solvecraft_engine::io::DESIGN_EXT), &bytes) {+ self.app.set_status(e, true);+ }+ }+ "delete" => {+ files::delete(&self.files, &name);+ self.app.home.recent.retain(|r| *r != path);+ }+ "rename_cancel" => self.renaming = None,+ "rename" => {+ if let Some((from, _)) = self.renaming.take() {+ match files::rename(&self.files, &from, &name) {+ Ok(()) => {+ // Recent designs follow the new name.+ let (old, new) = (format!("{}{from}", files::OPFS), format!("{}{name}", files::OPFS));+ for r in &mut self.app.home.recent {+ if *r == old {+ *r = new.clone();+ }+ }+ }+ Err(e) => self.app.set_status(e, true),+ }+ }+ }+ _ => {}+ }+ }++ /// Offer the autosave an earlier session left.+ fn recovery_prompt(&mut self, ctx: &egui::Context) {+ let Some((name, path)) = self.files.recovery.borrow().clone() else { return };+ let mut answer = None;+ egui::Window::new("Recover unsaved work?").collapsible(false).resizable(false).anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0]).show(+ ctx,+ |ui| {+ ui.label(format!("“{name}” had unsaved changes when this page last closed."));+ ui.horizontal(|ui| {+ if ui.button("Recover").clicked() {+ answer = Some(true);+ }+ if ui.button("Discard").clicked() {+ answer = Some(false);+ }+ });+ },+ );+ let Some(recover) = answer else { return };+ *self.files.recovery.borrow_mut() = None;+ if recover {+ self.app.open_path(&files::recovery_path());+ // It belongs to its own file again (saving goes there); it is unsaved.+ self.app.session.path = path;+ self.app.session.doc_mut().name = name;+ self.app.session.mark_unsaved();+ self.app.home.open = false;+ }+ files::autosave(&self.files, None);+ }+ }impl eframe::App for Shell {fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {- self.0.logic(ctx);+ self.app.logic(ctx);+ self.files_tick(ctx);}fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {- self.0.raw_input_hook(raw);+ files::take_drops(&self.files, raw);+ self.app.raw_input_hook(raw);}fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {- self.0.ui(ui);+ self.app.ui(ui);+ let ctx = ui.ctx().clone();+ self.file_panel(&ctx);+ self.recovery_prompt(&ctx);}fn save(&mut self, storage: &mut dyn eframe::Storage) {- storage.set_string(PREFS_KEY, self.0.prefs());+ storage.set_string(PREFS_KEY, self.app.prefs());}}@@ -59,7 +333,23 @@ mod web {canvas,options,Box::new(move |cc| {- let mut app = SolveApp::new(Session::default(), Services::default());+ let files = Rc::new(Files::default());+ files::start(&files);+ let panel = files.clone();+ let services = Services {+ // Open shows the browser's files (and the computer's, from there).+ pick_open: Some(Box::new(move || {+ panel.panel.set(true);+ None+ })),+ // Designs are kept in the browser; everything else is downloaded.+ pick_save: Some(Box::new(|name: &str, exts: &[&str]| {+ let design = exts.contains(&solvecraft_engine::io::DESIGN_EXT);+ Some(format!("{}{name}", if design { files::OPFS } else { files::DOWNLOADS }))+ })),+ ..Default::default()+ };+ let mut app = SolveApp::new(Session::default(), services);if let Some(p) = cc.storage.and_then(|s| s.get_string(PREFS_KEY)) {app.load_prefs(&p);}@@ -73,7 +363,19 @@ mod web {app.session.doc_mut().name = "Sample Plate".into();app.session.mark_saved();}- Ok(Box::new(Shell(app)))+ if !query().contains("sample") {+ let rev = app.session.revision;+ app.home.show(rev);+ }+ Ok(Box::new(Shell {+ app,+ files,+ autosaved_at: f64::NEG_INFINITY,+ autosaved: None,+ renaming: None,+ rename_focus: false,+ recents_synced: false,+ }))}),).await;diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rsindex d991a28019..db754d7772 100644--- a/crates/engine/src/cmd/file.rs+++ b/crates/engine/src/cmd/file.rs@@ -51,11 +51,11 @@ fn path_arg<'a>(p: &'a Value, cmd: &str) -> Result<&'a str> {/// Read a STEP file as an Import feature.fn read_step(path: &str) -> Result<solvecraft_io::StepFeature> {- let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;- if meta.len() > solvecraft_io::MAX_STEP_BYTES as u64 {+ let meta = solvecraft_io::vfs::len(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ if meta > solvecraft_io::MAX_STEP_BYTES as u64 {return Err(EngineError::Other(format!("{path}: file too large")));}- let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ let bytes = solvecraft_io::vfs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;solvecraft_io::step_import_feature(&bytes, path).map_err(|e| EngineError::Other(format!("{path}: {e}")))}@@ -80,11 +80,11 @@ fn add_step(s: &mut Session, path: &str, name: Option<&str>) -> Result<Value> {/// Add a MeshImport feature for a 3MF or STL file.fn add_mesh(s: &mut Session, path: &str, name: Option<&str>) -> Result<Value> {- let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;- if meta.len() > solvecraft_io::MAX_3MF_BYTES as u64 {+ let meta = solvecraft_io::vfs::len(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ if meta > solvecraft_io::MAX_3MF_BYTES as u64 {return Err(EngineError::Other(format!("{path}: file too large")));}- let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ let bytes = solvecraft_io::vfs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;let mf = solvecraft_io::mesh_import_feature(&bytes, path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;let fname = name.filter(|n| !n.trim().is_empty()).unwrap_or(&mf.name).to_string();let id = s.doc_mut().add_feature(mf.kind, Some(&fname))?;@@ -132,11 +132,11 @@ fn open(s: &mut Session, p: &Value) -> Result<Value> {let errors = s.model.results.iter().filter(|r| r.error.is_some()).count();return Ok(json!({"path": path, "features": s.doc.features.len(), "errors": errors, "bodies": r["bodies"], "warnings": r["warnings"]}));}- let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;- if meta.len() as usize > solvecraft_io::MAX_DESIGN_BYTES {+ let meta = solvecraft_io::vfs::len(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ if meta as usize > solvecraft_io::MAX_DESIGN_BYTES {return Err(EngineError::Other(format!("{path}: file too large")));}- let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ let bytes = solvecraft_io::vfs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;let doc = solvecraft_io::read_design(&bytes)?;*s = Session::new(doc);s.path = Some(path.to_string());@@ -175,7 +175,7 @@ fn export_to(s: &Session, path: &str, format: Format, bodies: &[String]) -> Resu// Bodies carry the colour they are shown in (appearance, material or imported).solvecraft_io::export(&s.doc.painted(&s.world_state()), bodies, format, &name)?};- std::fs::write(path, &bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ solvecraft_io::vfs::write(path, &bytes).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;Ok(json!({"path": path, "bytes": bytes.len(), "format": format!("{format:?}")}))}diff --git a/crates/engine/src/cmd/parameters.rs b/crates/engine/src/cmd/parameters.rsindex 1ca10f9e93..282a44633e 100644--- a/crates/engine/src/cmd/parameters.rs+++ b/crates/engine/src/cmd/parameters.rs@@ -219,7 +219,7 @@ fn export(s: &mut Session, p: &Value) -> Result<Value> {other => return Err(bad(cmd, format!("unknown format `{other}` (csv or json)"))),};if let Some(path) = path {- std::fs::write(path, &text).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ solvecraft_io::vfs::write(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;}Ok(json!({"format": format, "path": path, "text": text}))}@@ -229,11 +229,11 @@ fn import(s: &mut Session, p: &Value) -> Result<Value> {let text = match (str_(p, "text"), str_(p, "path")) {(Some(t), _) => t.to_string(),(None, Some(path)) => {- let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;- if meta.len() > 16 << 20 {+ let meta = solvecraft_io::vfs::len(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ if meta > 16 << 20 {return Err(bad(cmd, "file too large"));}- std::fs::read_to_string(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?+ solvecraft_io::vfs::read_to_string(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?}_ => return Err(bad(cmd, "give `text` or `path`")),};diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rsindex 0a8228eecf..9f2807c523 100644--- a/crates/engine/src/cmd/sheet.rs+++ b/crates/engine/src/cmd/sheet.rs@@ -369,7 +369,7 @@ fn export_dxf(s: &mut Session, p: &Value) -> Result<Value> {let sh = sheet_of(s, p, cmd)?;let text = flat_dxf(&sh)?;if let Some(path) = str_(p, "path").filter(|x| !x.trim().is_empty()) {- std::fs::write(path, &text).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ solvecraft_io::vfs::write(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;return Ok(json!({"path": path, "bends": sh.bends().len()}));}Ok(json!({"dxf": text, "bends": sh.bends().len()}))diff --git a/crates/engine/src/cmd/sketch_canvas.rs b/crates/engine/src/cmd/sketch_canvas.rsindex 9c973aef3c..731664f03e 100644--- a/crates/engine/src/cmd/sketch_canvas.rs+++ b/crates/engine/src/cmd/sketch_canvas.rs@@ -31,11 +31,11 @@ fn image_bytes(p: &Value, cmd: &str) -> Result<Vec<u8>> {base64_decode(d).ok_or_else(|| bad(cmd, "`data` is not base64"))?} else {let path = str_(p, "path").filter(|x| !x.trim().is_empty() && x.len() < 4096).ok_or_else(|| bad(cmd, "give `path` or `data`"))?;- let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;- if meta.len() as usize > MAX_CANVAS_BYTES {+ let meta = solvecraft_io::vfs::len(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ if meta as usize > MAX_CANVAS_BYTES {return Err(bad(cmd, "the image is too large"));}- std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?+ solvecraft_io::vfs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?};if b.len() > MAX_CANVAS_BYTES {return Err(bad(cmd, "the image is too large"));diff --git a/crates/engine/src/cmd/sketch_import.rs b/crates/engine/src/cmd/sketch_import.rsindex 58c4362f59..fd405b0d0e 100644--- a/crates/engine/src/cmd/sketch_import.rs+++ b/crates/engine/src/cmd/sketch_import.rs@@ -34,11 +34,11 @@ fn source_text(p: &Value, cmd: &str) -> Result<String> {return Ok(t.to_string());}let path = str_(p, "path").filter(|x| !x.trim().is_empty() && x.len() < 4096).ok_or_else(|| bad(cmd, "give `path` or `text`"))?;- let meta = std::fs::metadata(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;- if meta.len() as usize > MAX_DRAWING_BYTES {+ let meta = solvecraft_io::vfs::len(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ if meta as usize > MAX_DRAWING_BYTES {return Err(EngineError::Other(format!("{path}: file too large")));}- let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ let bytes = solvecraft_io::vfs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;Ok(String::from_utf8_lossy(&bytes).to_string())}@@ -186,7 +186,7 @@ fn export_dxf(s: &mut Session, p: &Value) -> Result<Value> {}let text = solvecraft_io::write_dxf(&geom);if let Some(path) = str_(p, "path").filter(|x| !x.trim().is_empty()) {- std::fs::write(path, &text).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;+ solvecraft_io::vfs::write(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;return Ok(json!({"path": path, "entities": geom.len()}));}Ok(json!({"dxf": text, "entities": geom.len()}))diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rsindex 77c63f20a6..f1155f1c14 100644--- a/crates/io/src/lib.rs+++ b/crates/io/src/lib.rs@@ -10,6 +10,7 @@ pub mod safe_write;mod sketch2d;mod svg;mod threemf;+pub mod vfs;pub use dxf::{read_dxf, write_dxf};pub use safe_write::{backup_path, write_atomic};diff --git a/crates/io/src/safe_write.rs b/crates/io/src/safe_write.rsindex 65109953e9..2f6fb41e81 100644--- a/crates/io/src/safe_write.rs+++ b/crates/io/src/safe_write.rs@@ -87,6 +87,11 @@ fn write_steps(path: &Path, bytes: &[u8], backup: bool, stop: Option<Step>) -> s/// Write `bytes` to `path` atomically; with `backup`, the file being replaced is kept as/// `<path>.bak` first.pub fn write_atomic(path: &Path, bytes: &[u8], backup: bool) -> std::io::Result<()> {+ // In the browser the host stores files (one write is already atomic there).+ if cfg!(target_arch = "wasm32") {+ let _ = backup;+ return crate::vfs::write(&path.to_string_lossy(), bytes);+ }write_steps(path, bytes, backup, None)}diff --git a/crates/io/src/vfs.rs b/crates/io/src/vfs.rsnew file mode 100644index 0000000000..839a246db8--- /dev/null+++ b/crates/io/src/vfs.rs@@ -0,0 +1,102 @@+//! File access for the engine. Natively it is the disk. In the browser (wasm32) there is no+//! file system to call synchronously, so files live in memory here: the web host loads them+//! (from the browser's private storage, a file picker or a drop) before a command reads them,+//! and takes what commands wrote ([`take_writes`]) to store it or hand it out as a download.++use std::io::{Error, ErrorKind, Result};++#[cfg(not(target_arch = "wasm32"))]+mod imp {+ use super::*;++ pub fn read(path: &str) -> Result<Vec<u8>> {+ std::fs::read(path)+ }+ pub fn write(path: &str, bytes: &[u8]) -> Result<()> {+ std::fs::write(path, bytes)+ }+ pub fn len(path: &str) -> Result<u64> {+ std::fs::metadata(path).map(|m| m.len())+ }+ pub fn exists(path: &str) -> bool {+ std::path::Path::new(path).exists()+ }+ pub fn remove(path: &str) -> Result<()> {+ std::fs::remove_file(path)+ }+}++#[cfg(target_arch = "wasm32")]+mod imp {+ use std::cell::RefCell;+ use std::collections::BTreeMap;++ use super::*;++ thread_local! {+ static FILES: RefCell<BTreeMap<String, Vec<u8>>> = const { RefCell::new(BTreeMap::new()) };+ static WRITES: RefCell<Vec<String>> = const { RefCell::new(Vec::new()) };+ }++ fn missing(path: &str) -> Error {+ Error::new(ErrorKind::NotFound, format!("{path}: no such file in this browser"))+ }++ pub fn read(path: &str) -> Result<Vec<u8>> {+ FILES.with(|f| f.borrow().get(path).cloned()).ok_or_else(|| missing(path))+ }+ pub fn write(path: &str, bytes: &[u8]) -> Result<()> {+ FILES.with(|f| f.borrow_mut().insert(path.to_string(), bytes.to_vec()));+ WRITES.with(|w| {+ let mut w = w.borrow_mut();+ w.retain(|p| p != path);+ w.push(path.to_string());+ });+ Ok(())+ }+ pub fn len(path: &str) -> Result<u64> {+ FILES.with(|f| f.borrow().get(path).map(|b| b.len() as u64)).ok_or_else(|| missing(path))+ }+ pub fn exists(path: &str) -> bool {+ FILES.with(|f| f.borrow().contains_key(path))+ }+ pub fn remove(path: &str) -> Result<()> {+ FILES.with(|f| f.borrow_mut().remove(path)).map(|_| ()).ok_or_else(|| missing(path))+ }+ pub fn insert(path: &str, bytes: Vec<u8>) {+ FILES.with(|f| f.borrow_mut().insert(path.to_string(), bytes));+ }+ pub fn take_writes() -> Vec<(String, Vec<u8>)> {+ let paths = WRITES.with(|w| std::mem::take(&mut *w.borrow_mut()));+ paths.into_iter().filter_map(|p| FILES.with(|f| f.borrow().get(&p).cloned()).map(|b| (p, b))).collect()+ }+ pub fn list(prefix: &str) -> Vec<(String, u64)> {+ FILES.with(|f| f.borrow().iter().filter(|(p, _)| p.starts_with(prefix)).map(|(p, b)| (p.clone(), b.len() as u64)).collect())+ }+}++pub use imp::*;++/// A file's text.+pub fn read_to_string(path: &str) -> Result<String> {+ String::from_utf8(read(path)?).map_err(|e| Error::new(ErrorKind::InvalidData, e))+}++#[cfg(test)]+mod tests {+ #[test]+ fn files_round_trip() {+ let dir = std::env::temp_dir().join(format!("solvecraft-vfs-{}", std::process::id()));+ let _ = std::fs::create_dir_all(&dir);+ let p = dir.join("a.txt").to_string_lossy().to_string();+ assert!(!super::exists(&p));+ assert!(super::read(&p).is_err());+ super::write(&p, b"hello").unwrap();+ assert!(super::exists(&p));+ assert_eq!(super::len(&p).unwrap(), 5);+ assert_eq!(super::read_to_string(&p).unwrap(), "hello");+ super::remove(&p).unwrap();+ assert!(!super::exists(&p));+ let _ = std::fs::remove_dir_all(&dir);+ }+}diff --git a/crates/ui-egui/src/home.rs b/crates/ui-egui/src/home.rsindex 5fa2768fde..24feb9f920 100644--- a/crates/ui-egui/src/home.rs+++ b/crates/ui-egui/src/home.rs@@ -180,7 +180,7 @@ pub fn open_sample(app: &mut SolveApp, i: usize) {}fn open_recent(app: &mut SolveApp, path: &str) {- if !std::path::Path::new(path).exists() {+ if !solvecraft_engine::io::vfs::exists(path) {app.home.recent.retain(|p| p != path);app.set_status(format!("{path} is no longer there"), true);return;@@ -198,11 +198,15 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {poll(app, ui.ctx());let t = Tokens::get();let samples = solvecraft_engine::sample::samples();- for i in 0..samples.len() {- want(&mut app.home, &format!("sample:{i}"));+ // In the browser a picture blocks the page while it builds (no threads) and a kernel+ // failure there can't be caught: samples are built when they are opened.+ if !cfg!(target_arch = "wasm32") {+ for i in 0..samples.len() {+ want(&mut app.home, &format!("sample:{i}"));+ }}let recent = app.home.recent.clone();- for p in recent.iter().filter(|p| std::path::Path::new(p.as_str()).exists()) {+ for p in recent.iter().filter(|p| solvecraft_engine::io::vfs::exists(p)) {want(&mut app.home, p);}let mut action: Option<Box<dyn FnOnce(&mut SolveApp)>> = None;@@ -266,9 +270,19 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let path = std::path::Path::new(p);let name = path.file_stem().map(|x| x.to_string_lossy().to_string()).unwrap_or_else(|| p.clone());let folder = path.parent().map(|x| x.to_string_lossy().to_string()).unwrap_or_default();- let missing = !path.exists();- let sub = if missing { "missing".to_string() } else { folder };- if card(ui, app.home.thumbs.get(p.as_str()).and_then(Option::as_ref), &name, &sub, missing).on_hover_text(p.as_str()).clicked() {+ let missing = !solvecraft_engine::io::vfs::exists(p);+ let sub = if missing {+ "missing".to_string()+ } else if p.starts_with("/opfs/") {+ // The web build keeps designs in the browser's own storage.+ "in this browser".to_string()+ } else {+ folder+ };+ if card(ui, Pic::Ready(app.home.thumbs.get(p.as_str()).and_then(Option::as_ref)), &name, &sub, missing)+ .on_hover_text(p.as_str())+ .clicked()+ {let p = p.clone();action = Some(Box::new(move |app: &mut SolveApp| open_recent(app, &p)));}@@ -281,7 +295,11 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let key = format!("sample:{i}");let busy = app.home.wanted == Some(i);let sub = if busy { "opening…" } else { s.about };- if card(ui, app.home.thumbs.get(&key).and_then(Option::as_ref), s.name, sub, false).on_hover_text(s.about).clicked() {+ let tex = match app.home.thumbs.get(&key) {+ Some(t) => Pic::Ready(t.as_ref()),+ None => Pic::Icon("box"),+ };+ if card(ui, tex, s.name, sub, false).on_hover_text(s.about).clicked() {action = Some(Box::new(move |app: &mut SolveApp| open_sample(app, i)));}});@@ -313,8 +331,14 @@ fn grid(ui: &mut egui::Ui, n: usize, mut each: impl FnMut(&mut egui::Ui, usize))}}+/// A card's picture: rendered (`None` while it renders), or an icon until it is asked for.+enum Pic<'a> {+ Ready(Option<&'a egui::TextureHandle>),+ Icon(&'static str),+}+/// A design card: its picture (a spinner while it renders), name and a line under it.-fn card(ui: &mut egui::Ui, tex: Option<&egui::TextureHandle>, name: &str, sub: &str, dim: bool) -> egui::Response {+fn card(ui: &mut egui::Ui, pic: Pic, name: &str, sub: &str, dim: bool) -> egui::Response {let t = Tokens::get();let size = vec2(THUMB[0] as f32 + 16.0, THUMB[1] as f32 + 62.0);let (r, resp) = ui.allocate_exact_size(size, Sense::click());@@ -327,12 +351,16 @@ fn card(ui: &mut egui::Ui, tex: Option<&egui::TextureHandle>, name: &str, sub: &egui::StrokeKind::Inside,);let img = egui::Rect::from_min_size(r.min + vec2(8.0, 8.0), vec2(THUMB[0] as f32, THUMB[1] as f32));- match tex {- Some(tx) => {+ match pic {+ Pic::Icon(icon) => {+ ui.painter().rect_filled(img, CornerRadius::same(4), t.panel_header);+ crate::icons::paint(ui.painter(), egui::Rect::from_center_size(img.center(), vec2(56.0, 56.0)), icon, t.icon, t.icon_fill, t.icon);+ }+ Pic::Ready(Some(tx)) => {let tint = if dim { Color32::from_white_alpha(90) } else { Color32::WHITE };ui.painter().image(tx.id(), img, egui::Rect::from_min_max(egui::pos2(0.0, 0.0), egui::pos2(1.0, 1.0)), tint);}- None => {+ Pic::Ready(None) => {ui.painter().rect_filled(img, CornerRadius::same(4), t.panel_header);if !dim {egui::Spinner::new().size(18.0).paint_at(ui, egui::Rect::from_center_size(img.center(), vec2(18.0, 18.0)));