From 58b3fda2dfded2df67c3bfa4afd8f35dd792e00c Mon Sep 17 00:00:00 2001 From: Martin Ball Date: Wed, 18 Nov 2026 17:25:03 +0000 Subject: [PATCH] platform-w5: net change of 3 commits - platform-w5: written from its sheet - platform-w5: review fixes (review-1) - platform-w5: review fixes (review-1b) --- crates/platform/src/browser_files.rs | 311 +++++++++++++++++++-- crates/platform/src/browser_files_tests.rs | 37 +++ 2 files changed, 317 insertions(+), 31 deletions(-) create mode 100644 crates/platform/src/browser_files_tests.rs diff --git a/crates/platform/src/browser_files.rs b/crates/platform/src/browser_files.rs index f5a5eb845..171d24fe9 100644 --- a/crates/platform/src/browser_files.rs +++ b/crates/platform/src/browser_files.rs @@ -1,8 +1,14 @@ //! The browser's file service: picks and saves through the page. use std::path::{Path, PathBuf}; +use std::sync::{Arc, Mutex, MutexGuard}; -use craft_host::{FileError, Files, PickId, PickRequest, Picked}; +use craft_host::{FileError, Files, PickId, PickKind, PickRequest, Picked, Wake}; +use js_sys::{Array, Function, Object, Promise, Reflect}; +use wasm_bindgen::{JsCast, JsValue}; +use wasm_bindgen_futures::{JsFuture, spawn_local}; + +use crate::browser::{DownloadOptions, download_bytes}; /// How much a browser pick may hand over. #[derive(Clone, Copy, Debug)] @@ -18,78 +24,321 @@ impl PickLimits { pub const DEFAULT: PickLimits = PickLimits { files: 2000, pending_bytes: 256 << 20 }; } +/// How long a fallback download's object URL lives; the download keeps its own reference. +const REVOKE_AFTER_MS: i32 = 10_000; + /// Browser picks and saves. [`Files::can_pick`] answers false and [`Files::browser_saves`] true. The save picker /// is reached through `js_sys::Reflect`, and a save it refuses falls back to one download. pub struct BrowserFiles { - _limits: PickLimits, + state: Arc>, + wake: Wake, + limits: PickLimits, +} + +/// Tickets of one service, shared with the tasks that answer them. +#[derive(Default)] +struct State { + next: u64, + /// Picks and saves whose task has not finished, forgotten or not: a save already writing + /// still holds the page. + running: Vec, + /// Running tickets whose owner gave them up; their answer is dropped when it comes. + forgotten: Vec, + /// Answers not yet taken. + answered: Vec<(PickId, Picked)>, +} + +impl State { + fn issue(&mut self) -> PickId { + self.next = self.next.wrapping_add(1); + PickId(self.next) + } + + /// Records the answer of `id`, unless its owner forgot it. + fn finish(&mut self, id: PickId, picked: Picked) { + self.running.retain(|r| *r != id); + if let Some(at) = self.forgotten.iter().position(|f| *f == id) { + self.forgotten.swap_remove(at); + return; + } + self.answered.push((id, picked)); + } + + /// Bytes of picked files answered and not yet taken. + fn held_bytes(&self) -> usize { + self.answered + .iter() + .filter_map(|(_, picked)| match picked { + Picked::Contents(files) => Some(files.iter().map(|(_, bytes)| bytes.len()).fold(0, usize::saturating_add)), + _ => None, + }) + .fold(0, usize::saturating_add) + } +} + +fn lock(state: &Mutex) -> MutexGuard<'_, State> { + state.lock().unwrap_or_else(std::sync::PoisonError::into_inner) +} + +/// Answers ticket `id` from a task and wakes the app to take it. +fn finish(state: &Mutex, wake: &Wake, id: PickId, picked: Picked) { + lock(state).finish(id, picked); + wake.wake(); } impl BrowserFiles { /// A service whose late answers call `wake`. pub fn new(wake: impl Fn() + Send + Sync + 'static) -> Self { - let _ = wake; - todo!("pf.C-F6") + Self { state: Arc::new(Mutex::new(State::default())), wake: Wake::new(wake), limits: PickLimits::DEFAULT } } /// The service with `limits` in place of [`PickLimits::DEFAULT`]. pub fn limits(self, limits: PickLimits) -> Self { - let _ = (&self, limits); - todo!("pf.C-F6") + Self { limits, ..self } + } + + /// A ticket whose task is about to start. + fn start(&self) -> PickId { + let mut state = lock(&self.state); + let id = state.issue(); + state.running.push(id); + id + } + + /// A ticket answered in the call itself. + fn answer_now(&self, picked: Picked) -> PickId { + let id = { + let mut state = lock(&self.state); + let id = state.issue(); + state.finish(id, picked); + id + }; + self.wake.wake(); + id } } /// The MIME type a picked file of `name` is read as. -#[allow(dead_code)] // P3(platform-w5): pf.C-F6 fn mime_for(name: &str) -> &'static str { - let _ = name; - todo!("pf.C-F6") + match name.rsplit('.').next().map(str::to_ascii_lowercase).as_deref() { + Some("png") => "image/png", + Some("jpg" | "jpeg") => "image/jpeg", + Some("pdf") => "application/pdf", + Some("docx") => "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + Some("odt") => "application/vnd.oasis.opendocument.text", + Some("ott") => "application/vnd.oasis.opendocument.text-template", + Some("fodt") => "application/vnd.oasis.opendocument.text-flat-xml", + Some("rtf") => "application/rtf", + Some("html") => "text/html", + Some("md" | "txt") => "text/plain", + Some("tex") => "application/x-tex", + Some("json") => "application/json", + Some("xml") => "application/xml", + _ => "application/octet-stream", + } } /// What a rejected save picker answers: a cancel for `AbortError` (`error_name`), otherwise the `download` fallback's outcome. -#[allow(dead_code)] // P3(platform-w5): pf.C-F6 -pub(crate) fn rejected(error_name: &str, download: impl FnOnce() -> Result<(), String>) -> Picked { - let _ = (error_name, download); - todo!("pf.C-F6") +/// A browser can expose the picker and still reject it (a cross-origin frame); cancelling must never start a +/// download (#1246). +pub(crate) fn rejected(error_name: &str, name: &str, download: impl FnOnce() -> Result<(), String>) -> Picked { + if error_name == "AbortError" { + return Picked::Cancelled; + } + downloaded(name, download()) +} + +/// The answer of a download of `name` that `result` says started or failed. +fn downloaded(name: &str, result: Result<(), String>) -> Picked { + match result { + Ok(()) => Picked::Downloaded(name.to_owned()), + Err(error) => Picked::Failed(error), + } +} + +/// One download of `bytes` as `name`. +fn download(name: &str, mime: &str, bytes: &[u8]) -> Result<(), String> { + download_bytes(name, mime, bytes, DownloadOptions { revoke_after_ms: REVOKE_AFTER_MS }).map_err(|e| js_text(&e)) +} + +fn js_text(value: &JsValue) -> String { + format!("{value:?}") +} + +/// The JS error's `name` (`AbortError`), empty when it has none. +fn error_name(error: &JsValue) -> String { + Reflect::get(error, &JsValue::from_str("name")).ok().and_then(|v| v.as_string()).unwrap_or_default() +} + +/// The name a save goes out under: the last component of the request's name, `document` when blank. +fn save_name(request: &PickRequest) -> String { + request + .file_name + .as_deref() + .and_then(|n| Path::new(n).file_name()) + .map(|n| n.to_string_lossy().into_owned()) + .filter(|n| !n.trim().is_empty()) + .unwrap_or_else(|| "document".into()) +} + +/// The save picker's name for files of `ext`: the format's name, as its extension says it. +fn type_description(ext: &str) -> String { + match ext { + "htm" => "HTML".into(), + "txt" => "Text".into(), + e if !e.is_empty() && e.len() <= 8 && e.chars().all(|c| c.is_ascii_alphanumeric()) => e.to_ascii_uppercase(), + _ => "Document".into(), + } +} + +fn set(target: &JsValue, key: &str, value: &JsValue) -> Result<(), JsValue> { + Reflect::set(target, &JsValue::from_str(key), value).map(|_| ()) +} + +/// Opens `showSaveFilePicker` for `name`. `Ok(None)` when the browser has no such picker; an `Err` is the value the +/// call threw, whose name tells a cancel from a refusal. It must run in the call of the user's gesture: the picker +/// needs the page's transient activation. +fn open_save_picker(name: &str, ext: Option<&str>, mime: &str) -> Result, JsValue> { + let window = web_sys::window().ok_or_else(|| JsValue::from_str("no browser window"))?; + let Ok(picker) = Reflect::get(&window, &JsValue::from_str("showSaveFilePicker")) else { return Ok(None) }; + let Ok(picker) = picker.dyn_into::() else { return Ok(None) }; + let options = Object::new(); + set(&options, "suggestedName", &JsValue::from_str(name))?; + if let Some(ext) = ext { + let accept = Object::new(); + set(&accept, mime, &Array::of1(&JsValue::from_str(&format!(".{ext}"))))?; + let kind = Object::new(); + set(&kind, "description", &JsValue::from_str(&type_description(ext)))?; + set(&kind, "accept", &accept)?; + set(&options, "types", &Array::of1(&kind))?; + } + let promise = picker.call1(&window, &options)?; + promise.dyn_into::().map(Some).map_err(|_| JsValue::from_str("showSaveFilePicker answered no promise")) +} + +/// Calls `target.method(arg)` and awaits the promise it answers. +async fn await_call(target: &JsValue, method: &str, arg: Option<&JsValue>) -> Result { + let function: Function = Reflect::get(target, &JsValue::from_str(method)) + .map_err(|e| js_text(&e))? + .dyn_into() + .map_err(|_| format!("{method} is not a function"))?; + let value = match arg { + Some(arg) => function.call1(target, arg), + None => function.call0(target), + } + .map_err(|e| js_text(&e))?; + let promise: Promise = value.dyn_into().map_err(|_| format!("{method} answered no promise"))?; + JsFuture::from(promise).await.map_err(|e| js_text(&e)) +} + +/// Writes `bytes` through a picked file handle; the file counts as saved only once it is closed. +async fn write_handle(handle: &JsValue, bytes: &[u8]) -> Result<(), String> { + let stream = await_call(handle, "createWritable", None).await?; + let data: JsValue = js_sys::Uint8Array::from(bytes).into(); + await_call(&stream, "write", Some(&data)).await?; + await_call(&stream, "close", None).await?; + Ok(()) } impl Files for BrowserFiles { fn pick(&self, request: PickRequest) -> PickId { - let _ = request; - todo!("pf.C-F6") + let many = match request.kind { + PickKind::Open => false, + PickKind::OpenMany => true, + PickKind::Folder => return self.answer_now(Picked::Unavailable("the browser picks no folders".into())), + PickKind::Save => return self.answer_now(Picked::Unavailable("the browser saves through Files::save".into())), + }; + let mut dialog = rfd::AsyncFileDialog::new(); + if let Some(title) = &request.title { + dialog = dialog.set_title(title.as_str()); + } + for filter in &request.filters { + dialog = dialog.add_filter(filter.name.as_str(), &filter.extensions); + } + let id = self.start(); + let (state, wake, limits) = (Arc::clone(&self.state), self.wake.clone(), self.limits); + spawn_local(async move { + let handles = if many { dialog.pick_files().await.unwrap_or_default() } else { dialog.pick_file().await.into_iter().collect() }; + let mut files = Vec::new(); + let mut this_pick = 0usize; + for handle in handles.into_iter().take(limits.files) { + let mut bytes = handle.read().await; + // Several files waiting to be taken stay under a byte cap. A file over it answers empty, so + // the feature reports that file on its own. + if many { + let held = lock(&state).held_bytes().saturating_add(this_pick); + if held.saturating_add(bytes.len()) > limits.pending_bytes { + bytes = Vec::new(); + } + } + this_pick = this_pick.saturating_add(bytes.len()); + files.push((handle.file_name(), bytes)); + } + let picked = if files.is_empty() { Picked::Cancelled } else { Picked::Contents(files) }; + finish(&state, &wake, id, picked); + }); + id } fn take_answer(&self, id: PickId) -> Option { - let _ = id; - todo!("pf.C-F6") + let mut state = lock(&self.state); + let at = state.answered.iter().position(|(a, _)| *a == id)?; + Some(state.answered.remove(at).1) } fn forget(&self, id: PickId) { - let _ = id; - todo!("pf.C-F6") + let mut state = lock(&self.state); + state.answered.retain(|(a, _)| *a != id); + if state.running.contains(&id) && !state.forgotten.contains(&id) { + state.forgotten.push(id); + } } fn pick_pending(&self) -> bool { - todo!("pf.C-F6") + !lock(&self.state).running.is_empty() } - fn read(&self, path: &Path) -> Result, FileError> { - let _ = path; - todo!("pf.C-F6") + fn read(&self, _path: &Path) -> Result, FileError> { + Err(FileError::Unsupported) } - fn write(&self, path: &Path, bytes: &[u8]) -> Result<(), FileError> { - let _ = (path, bytes); - todo!("pf.C-F6") + fn write(&self, _path: &Path, _bytes: &[u8]) -> Result<(), FileError> { + Err(FileError::Unsupported) } - fn last_folder(&self, purpose: &str) -> Option { - let _ = purpose; - todo!("pf.C-F6") + fn last_folder(&self, _purpose: &str) -> Option { + None } fn save(&self, request: PickRequest, bytes: Vec) -> PickId { - let _ = (request, bytes); - todo!("pf.C-F6") + let name = save_name(&request); + let mime = mime_for(&name); + let ext = Path::new(&name) + .extension() + .and_then(std::ffi::OsStr::to_str) + .map(str::to_ascii_lowercase) + .or_else(|| request.suggested_extension.clone()); + let promise = match open_save_picker(&name, ext.as_deref(), mime) { + Ok(Some(promise)) => promise, + // No picker: the browser's download is the save. + Ok(None) => return self.answer_now(downloaded(&name, download(&name, mime, &bytes))), + // A picker that threw in the call is refused like one that rejected later. + Err(error) => return self.answer_now(rejected(&error_name(&error), &name, || download(&name, mime, &bytes))), + }; + let id = self.start(); + let (state, wake) = (Arc::clone(&self.state), self.wake.clone()); + spawn_local(async move { + let picked = match JsFuture::from(promise).await { + // A failed write or close is the save's failure; it never downloads. + Ok(handle) => match write_handle(&handle, &bytes).await { + Ok(()) => Picked::Paths(vec![PathBuf::from(&name)]), + Err(error) => Picked::Failed(error), + }, + Err(error) => rejected(&error_name(&error), &name, || download(&name, mime, &bytes)), + }; + finish(&state, &wake, id, picked); + }); + id } fn can_pick(&self) -> bool { diff --git a/crates/platform/src/browser_files_tests.rs b/crates/platform/src/browser_files_tests.rs new file mode 100644 index 000000000..49db88499 --- /dev/null +++ b/crates/platform/src/browser_files_tests.rs @@ -0,0 +1,37 @@ +//! The browser save picker's refusal rule (#1246). + +use craft_host::Picked; +use wasm_bindgen_test::{wasm_bindgen_test, wasm_bindgen_test_configure}; + +use crate::browser_files::rejected; + +wasm_bindgen_test_configure!(run_in_browser); + +#[wasm_bindgen_test] +fn a_rejected_picker_downloads_once_unless_cancelled() { + let mut calls = 0; + let picked = rejected("AbortError", "Report.docx", || { + calls += 1; + Ok(()) + }); + assert_eq!(picked, Picked::Cancelled); + assert_eq!(calls, 0, "a cancelled picker never downloads"); + + for error in ["SecurityError", "NotSupportedError", "TypeError", ""] { + let mut calls = 0; + let picked = rejected(error, "Report.docx", || { + calls += 1; + Ok(()) + }); + assert_eq!(calls, 1, "{error:?} downloads exactly once"); + assert_eq!(picked, Picked::Downloaded("Report.docx".into()), "{error:?}"); + } + + let mut calls = 0; + let picked = rejected("SecurityError", "Report.docx", || { + calls += 1; + Err("the download was blocked".into()) + }); + assert_eq!(calls, 1); + assert_eq!(picked, Picked::Failed("the download was blocked".into()), "a failed fallback stays a failed save"); +}