SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Web: Save to computer… for designs kept in the browser; OPFS writes route as before (#104) (#3687)
bherbruck76af4ee855f6
diff --git a/apps/solidcraft-web/src/disk.rs b/apps/solidcraft-web/src/disk.rsindex 0b6b839ab5..dc3396903c 100644--- a/apps/solidcraft-web/src/disk.rs+++ b/apps/solidcraft-web/src/disk.rs@@ -11,6 +11,38 @@/// Where a design on the computer's disk appears to the engine.pub const PREFIX: &str = "/disk/";+/// Where designs kept in the browser's private storage (OPFS) appear to the engine.+pub const OPFS_PREFIX: &str = "/opfs/";+/// Paths written here are handed to the user as downloads.+pub const DOWNLOADS_PREFIX: &str = "/downloads/";++/// Where what a command wrote to an engine path goes.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum WriteTo {+ /// The browser's private storage: the design (or recovery file) keeps its name there.+ Opfs,+ /// A file on the computer, through its handle.+ Disk,+ /// A download.+ Download,+ /// Kept only in memory (uploads).+ Memory,+}++/// Route a write by its path. OPFS paths always go to OPFS, whatever the browser can do: a design+/// opened from the browser's storage keeps saving there until the user picks Save As.+pub fn route(path: &str) -> WriteTo {+ if path.starts_with(OPFS_PREFIX) {+ WriteTo::Opfs+ } else if parse(path).is_some() {+ WriteTo::Disk+ } else if path.starts_with(DOWNLOADS_PREFIX) {+ WriteTo::Download+ } else {+ WriteTo::Memory+ }+}+/// The engine path of the design `name` kept under handle `id`.pub fn path(id: &str, name: &str) -> String {format!("{PREFIX}{id}/{name}")@@ -112,11 +144,6 @@ mod web {window.is_secure_context() && has("showSaveFilePicker") && has("showOpenFilePicker")}- /// Is `path` a design on the disk?- pub fn is_disk(path: &str) -> bool {- parse(path).is_some()- }-fn types(description: &str, mime: &str, extension: &str) -> Array {let accept = Object::new();let _ = Reflect::set(&accept, &mime.into(), &Array::of1(&extension.into()));@@ -150,14 +177,45 @@ mod web {path(&id, &name)}- /// Save As, step one: show the browser's save dialog (call in the click). The answer is the- /// engine path the design is saved to, `None` when the dialog was closed.- pub fn pick_save(files: &Rc<Files>, name: &str) -> impl std::future::Future<Output = Option<String>> + use<> {+ fn save_options(name: &str) -> Object {let options = Object::new();let _ = Reflect::set(&options, &"suggestedName".into(), &name.into());let (description, mime, extension) = save_type(name);let _ = Reflect::set(&options, &"types".into(), &types(description, mime, extension));- let promise = start_picker("showSaveFilePicker", &options);+ options+ }++ /// "Save to computer…" for a design kept in the browser: write a copy of `bytes` to a file the+ /// user picks (call in the click), or download it where the browser can't pick one. The design+ /// itself stays where it is.+ pub fn save_copy(files: &Rc<Files>, name: &str, bytes: Vec<u8>) {+ if !supported() {+ if let Err(e) = crate::files::download(name, &bytes) {+ files.say(format!("{name}: {e}"), true);+ }+ return;+ }+ let promise = start_picker("showSaveFilePicker", &save_options(name));+ let files = files.clone();+ spawn_local(async move {+ let r = async {+ let h: FileSystemFileHandle =+ JsFuture::from(promise?).await.map_err(failed)?.dyn_into().map_err(|_| Pick::Failed("not a file".into()))?;+ write_handle(&h, &bytes).await.map_err(Pick::Failed)?;+ Ok::<String, Pick>(h.name())+ };+ match r.await {+ Ok(saved) => files.say(format!("Saved a copy to {saved}"), false),+ Err(Pick::Cancelled) => {}+ Err(Pick::Failed(e)) => files.say(format!("save to computer: {e}"), true),+ }+ });+ }++ /// Save As, step one: show the browser's save dialog (call in the click). The answer is the+ /// engine path the design is saved to, `None` when the dialog was closed.+ pub fn pick_save(files: &Rc<Files>, name: &str) -> impl std::future::Future<Output = Option<String>> + use<> {+ let promise = start_picker("showSaveFilePicker", &save_options(name));let files = files.clone();async move {let handle = match promise {@@ -261,7 +319,11 @@ mod web {async fn write(path: &str, bytes: &[u8]) -> Result<(), String> {let (id, name) = parse(path).ok_or("not a file on the computer")?;let handle = handle_for(id).await.map_err(|e| format!("{name}: {e}"))?;- ensure_readwrite(&handle).await.map_err(|e| format!("{name}: {e}"))?;+ write_handle(&handle, bytes).await.map_err(|e| format!("{name}: {e}"))+ }++ async fn write_handle(handle: &FileSystemFileHandle, bytes: &[u8]) -> Result<(), String> {+ ensure_readwrite(handle).await?;let w: web_sys::FileSystemWritableFileStream =JsFuture::from(handle.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)?;@@ -376,6 +438,23 @@ mod tests {}}+ /// Designs already stored in OPFS (and the recovery files) keep saving to OPFS under their own+ /// names, whether or not the browser can write to the disk.+ #[test]+ fn writes_to_opfs_paths_still_go_to_opfs() {+ for p in+ ["/opfs/Bracket.solidcraft", "/opfs/Bracket (2).solidcraft", "/opfs/recovery.solidcraft", "/opfs/recovery.json", "/opfs/old.solvecraft"]+ {+ assert_eq!(route(p), WriteTo::Opfs, "{p}");+ }+ // A design opened from OPFS saves to its own path; only a Save As can pick the disk.+ assert_eq!(save_target(false, true), SaveTarget::Browser);+ assert_eq!(route(&format!("{OPFS_PREFIX}Bracket.solidcraft")), WriteTo::Opfs);+ assert_eq!(route("/disk/18f-2a/Bracket.solidcraft"), WriteTo::Disk);+ assert_eq!(route("/downloads/part.step"), WriteTo::Download);+ assert_eq!(route("/upload/part.step"), WriteTo::Memory);+ }+#[test]fn handle_ids_differ_by_time_and_by_chance() {assert_ne!(make_id(1, 5), make_id(2, 5));diff --git a/apps/solidcraft-web/src/files.rs b/apps/solidcraft-web/src/files.rsindex 42be96deee..79341a9768 100644--- a/apps/solidcraft-web/src/files.rs+++ b/apps/solidcraft-web/src/files.rs@@ -19,9 +19,9 @@ 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/";+pub const OPFS: &str = disk::OPFS_PREFIX;/// Paths written here are handed to the user as downloads.-pub const DOWNLOADS: &str = "/downloads/";+pub const DOWNLOADS: &str = disk::DOWNLOADS_PREFIX;/// Files brought in from the computer.pub const UPLOAD: &str = "/upload/";/// The autosave of unsaved work (in OPFS: `recovery.solidcraft` and `recovery.json`).@@ -309,28 +309,32 @@ pub fn start(files: &Rc<Files>) {/// 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());+ match disk::route(&path) {+ disk::WriteTo::Opfs => {+ let name = path.strip_prefix(OPFS).unwrap_or(&path).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);+ }+ });}- let files = files.clone();- spawn_local(async move {- if let Err(e) = write_file(&name, &bytes).await {+ disk::WriteTo::Disk => disk::enqueue(files, &path, bytes),+ disk::WriteTo::Download => {+ let name = path.strip_prefix(DOWNLOADS).unwrap_or(&path);+ if let Err(e) = download(name, &bytes) {files.say(format!("{name}: {e}"), true);}- });- } else if crate::disk::is_disk(&path) {- disk::enqueue(files, &path, bytes);- } else if let Some(name) = path.strip_prefix(DOWNLOADS)- && let Err(e) = download(name, &bytes)- {- files.say(format!("{name}: {e}"), true);+ }+ disk::WriteTo::Memory => {}}}}diff --git a/apps/solidcraft-web/src/main.rs b/apps/solidcraft-web/src/main.rsindex 72de50bb34..feb74f40af 100644--- a/apps/solidcraft-web/src/main.rs+++ b/apps/solidcraft-web/src/main.rs@@ -288,6 +288,13 @@ mod web {self.renaming = Some((e.name.clone(), e.name.clone()));self.rename_focus = true;}+ if ui+ .small_button("Save to computer…")+ .on_hover_text("A copy in a file you choose; the stored design stays here")+ .clicked()+ {+ act = Some(("save_copy", e.name.clone()));+ }if ui.small_button("Download").clicked() {act = Some(("download", e.name.clone()));}@@ -323,6 +330,10 @@ mod web {}Err(e) => self.app.set_status(e.to_string(), true),},+ "save_copy" => match vfs::read(&path, solidcraft_engine::io::MAX_DESIGN_BYTES) {+ Ok(b) => disk::save_copy(&self.files, &name, b),+ Err(e) => self.app.set_status(e.to_string(), true),+ },"download_open" => {let d = &self.app.session.doc;let result = self