From 76af4ee855f6ba4995fa27f9d57229c22eaac63b Mon Sep 17 00:00:00 2001 From: bherbruck Date: Tue, 20 Oct 2026 13:51:01 -0400 Subject: [PATCH] =?UTF-8?q?Web:=20Save=20to=20computer=E2=80=A6=20for=20de?= =?UTF-8?q?signs=20kept=20in=20the=20browser;=20OPFS=20writes=20route=20as?= =?UTF-8?q?=20before=20(#104)=20(#3687)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- apps/solidcraft-web/src/disk.rs | 99 ++++++++++++++++++++++++++++---- apps/solidcraft-web/src/files.rs | 44 +++++++------- apps/solidcraft-web/src/main.rs | 11 ++++ 3 files changed, 124 insertions(+), 30 deletions(-) diff --git a/apps/solidcraft-web/src/disk.rs b/apps/solidcraft-web/src/disk.rs index 0b6b839ab..dc3396903 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, name: &str) -> impl std::future::Future> + 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, name: &str, bytes: Vec) { + 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::(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, name: &str) -> impl std::future::Future> + 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.rs index 42be96dee..79341a976 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) { /// Store what commands wrote: OPFS paths into OPFS, download paths as downloads. pub fn flush(files: &Rc) { 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.rs index 72de50bb3..feb74f40a 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