Files
craft-libs/crates/web-host/src/web.rs
T
aiongg 577055bc34 Merge storytold main 3c59a2aa5 into craft-framework (sync 13 Nov)
202 upstream commits since 6cb00467a. Resolutions:
- craft-window, craft-platform: ours. Upstream's frame policy v2, restore
  store and GNOME light/wait_first are the versions carried on 28 Oct;
  ours moved place() to craft-behavior and kept LayoutWatch and the
  appearance/portal.rs split.
- craft-timeline: ours. craft-time (crates/time) lands as upstream wrote
  it and is not yet used by craft-timeline.
- Old crates/ui modules stay removed. Upstream's frosted backdrops, shape
  gallery, dialog tabs and the iconic flyout top-edge rendering are not
  carried. The #1094 model half is in craft-behavior's dock:
  Group::flyout_offset and Action::MoveFlyoutTop.
- craft-update: #586 Save and Update, the install probe on the check
  thread and quiet per-user MSI self-updates, carried into updater.rs,
  stack_dialogs.rs, install/windows.rs and self_update/helper.rs.
- craft-jpeg: progressive Huffman decoding, carried into huffman.rs,
  parse.rs and scan.rs.
- craft-print: the driver settings dialog's new tests and the bounded
  XML parse's tests, as trials.
- Test-only conflicts: upstream tests from before the base that our side
  cut stay cut; tests new upstream are kept.
2026-11-13 17:11:48 +00:00

368 lines
16 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! The bridge an app's web shell calls: find the host, hear its messages, post the app's.
//!
//! ```ignore
//! if let Some(host) = craft_web_host::web::Host::connect("pdfcraft", &canvas) {
//! host.listen(move |message| inbox.push(message));
//! host.post_ready(env!("CARGO_PKG_VERSION"), false);
//! }
//! ```
use std::cell::Cell;
use std::rc::Rc;
use wasm_bindgen::closure::Closure;
use wasm_bindgen::{JsCast as _, JsValue};
use web_sys::js_sys;
use crate::{Inbox, Incoming, Mode, Outgoing, VERSION, file_name, message_type};
/// A file the host passes in, not yet copied into the app's memory: check its size first.
pub enum FileData {
/// `bytes`: an `ArrayBuffer` or `Uint8Array`, viewed in place.
Bytes(js_sys::Uint8Array),
/// `file`: a `File` or `Blob`, for the app to read in slices.
Blob(web_sys::Blob),
}
impl FileData {
/// The file's length in bytes, from the data itself (a host's `size` field is not trusted).
pub fn size(&self) -> f64 {
match self {
Self::Bytes(array) => f64::from(array.length()),
Self::Blob(blob) => blob.size(),
}
}
}
/// A message from the host.
pub enum Message {
/// What the host supports; `handoff`: it routes files the app hands off.
Host { version: String, handoff: bool },
/// Open a document as File › Open would. `name` is already cleaned ([`crate::file_name`]).
Open { name: String, data: FileData },
/// Attach one PDF page to the current drawing without opening another document.
/// Bytes stay a view until the app checks their length. Page numbers start at one.
AttachPdf { name: String, bytes: js_sys::Uint8Array, page: u32, insertion: [f64; 3], width: f64, height: f64 },
/// The save with this `id` is stored.
Saved { id: String },
/// The host gave a handed-off file to the app that edits it.
HandoffDone { name: String, app: String },
}
enum Transport {
/// The same-origin parent window; only it is heard and answered.
Parent { window: web_sys::Window, parent: web_sys::Window, origin: String },
/// The app's canvas; messages are `CustomEvent`s on it.
Page { canvas: web_sys::EventTarget },
}
/// The connection to the page hosting the app.
pub struct Host {
app: &'static str,
transport: Transport,
dirty: Cell<Option<bool>>,
}
impl Host {
/// The host for `app` (its id, as in `<app>:ready`) running on `canvas`, or `None` when the
/// app is not hosted: no `?host=parent` and no `data-host="page"`, no framing parent, or a
/// parent on another origin (messages only go to this origin, so the browser would drop them).
pub fn connect(app: &'static str, canvas: &web_sys::Element) -> Option<Self> {
let window = web_sys::window()?;
let query = window.location().search().unwrap_or_default();
let transport = match Mode::detect(&query, canvas.get_attribute("data-host").as_deref())? {
Mode::Parent => {
let parent = window.parent().ok().flatten()?;
if js_sys::Object::is(&parent, &window) {
return None;
}
let origin = window.location().origin().ok()?;
// Reading another origin's location throws, which is `None` too.
if parent.location().origin().ok()? != origin {
return None;
}
Transport::Parent { window, parent, origin }
}
Mode::Page => Transport::Page { canvas: canvas.clone().into() },
};
Some(Self { app, transport, dirty: Cell::new(None) })
}
pub fn mode(&self) -> Mode {
match self.transport {
Transport::Parent { .. } => Mode::Parent,
Transport::Page { .. } => Mode::Page,
}
}
/// Hear the host's messages for this app. The listener lives as long as the page. The
/// listeners are `Fn`: a page host can dispatch an event while one is still running (a
/// `saved` for the `save` the handler just posted), and wasm-bindgen refuses to re-enter an
/// `FnMut` closure before its body runs, so the message would never reach the queue.
pub fn listen(&self, handler: impl FnMut(Message) + 'static) {
let app = self.app;
let inbox = Rc::new(Inbox::new(handler));
match &self.transport {
Transport::Parent { window, parent, origin } => {
let (parent, origin, inbox) = (parent.clone(), origin.clone(), inbox.clone());
let on_message = Closure::<dyn Fn(web_sys::MessageEvent)>::new(move |event: web_sys::MessageEvent| {
if event.origin() != origin || !event.source().is_some_and(|s| js_sys::Object::is(&s, &parent)) {
return;
}
let data = event.data();
let Some(kind) = string(&data, "type").and_then(|t| Incoming::parse(app, &t)) else { return };
if let Some(message) = read(kind, &data) {
inbox.deliver(message);
}
});
if window.add_event_listener_with_callback("message", on_message.as_ref().unchecked_ref()).is_ok() {
on_message.forget();
}
}
Transport::Page { canvas } => {
for kind in Incoming::ALL {
let inbox = inbox.clone();
let on_event = Closure::<dyn Fn(web_sys::CustomEvent)>::new(move |event: web_sys::CustomEvent| {
if let Some(message) = read(kind, &event.detail()) {
inbox.deliver(message);
}
});
let name = message_type(app, kind.kind());
if canvas.add_event_listener_with_callback(&name, on_event.as_ref().unchecked_ref()).is_ok() {
on_event.forget();
}
}
}
}
}
/// The app is listening: send a document now. `app_version` is the app's own release;
/// `reads_files`: it takes a `File`/`Blob` and reads it in slices.
pub fn post_ready(&self, app_version: &str, reads_files: bool) -> Result<(), String> {
self.post(Outgoing::Ready, &[("version", VERSION.into()), ("appVersion", app_version.into()), ("file", reads_files.into())], None)
}
/// Unsaved changes appeared or went away. Repeats of the last state reported are not sent.
/// The new state is recorded before the send: a page host can report another state while the
/// event is still dispatching, and that later report wins. A failed send is forgotten.
pub fn post_dirty(&self, dirty: bool) {
crate::note_dirty(&self.dirty, dirty, || self.post(Outgoing::Dirty, &[("dirty", dirty.into())], None).is_ok());
}
/// Hand the host a file the app would otherwise download: Save, Save As, Export. With an
/// `id`, the host answers [`Message::Saved`] once it is stored; without one the save is done
/// once it is posted. The bytes go as a transferred `ArrayBuffer`.
pub fn post_save(&self, name: &str, bytes: &[u8], id: Option<&str>, save_as: bool) -> Result<(), String> {
let buffer = js_sys::Uint8Array::from(bytes).buffer();
let mut fields =
vec![("name", JsValue::from(file_name(Some(name), "document"))), ("bytes", buffer.clone().into()), ("saveAs", save_as.into())];
if let Some(id) = id {
fields.push(("id", id.into()));
}
self.post(Outgoing::Save, &fields, Some(&buffer))
}
/// The app couldn't start, couldn't take a document, or a save went unconfirmed (`id`).
pub fn post_failed(&self, error: &str, id: Option<&str>) -> Result<(), String> {
let mut fields = vec![("error", JsValue::from(error))];
if let Some(id) = id {
fields.push(("id", id.into()));
}
self.post(Outgoing::Failed, &fields, None)
}
/// Pass the host a file another app edits; it answers [`Message::HandoffDone`] or, when no
/// app it hosts takes the type, `failed`. Without a host, tell the user which app the file
/// needs instead.
pub fn post_handoff(&self, name: &str, bytes: &[u8]) -> Result<(), String> {
let buffer = js_sys::Uint8Array::from(bytes).buffer();
self.post(Outgoing::Handoff, &[("name", file_name(Some(name), "document").into()), ("bytes", buffer.clone().into())], Some(&buffer))
}
fn post(&self, kind: Outgoing, fields: &[(&str, JsValue)], transfer: Option<&js_sys::ArrayBuffer>) -> Result<(), String> {
let message_type = message_type(self.app, kind.kind());
let error = |e: JsValue| e.as_string().unwrap_or_else(|| format!("{e:?}"));
match &self.transport {
Transport::Parent { parent, origin, .. } => {
let message = object(&[("type", message_type.as_str().into())], fields)?;
match transfer {
Some(buffer) => parent.post_message_with_transfer(&message, origin, &js_sys::Array::of1(buffer)),
None => parent.post_message(&message, origin),
}
.map_err(error)
}
Transport::Page { canvas } => {
let init = web_sys::CustomEventInit::new();
init.set_detail(&object(&[], fields)?.into());
let event = web_sys::CustomEvent::new_with_event_init_dict(&message_type, &init).map_err(error)?;
canvas.dispatch_event(&event).map(|_| ()).map_err(error)
}
}
}
}
/// The message a host's object describes, or `None` when a required field is missing.
fn read(kind: Incoming, data: &JsValue) -> Option<Message> {
Some(match kind {
Incoming::Host => Message::Host {
version: string(data, "version").unwrap_or_else(|| VERSION.to_string()),
handoff: get(data, "handoff").as_bool() == Some(true),
},
Incoming::Open => {
let name = file_name(string(data, "name").as_deref(), "document");
Message::Open { name, data: file_data(data)? }
}
Incoming::AttachPdf => {
let FileData::Bytes(bytes) = file_data(data)? else { return None };
let page = get(data, "page").as_f64()?;
if !(page.is_finite() && page >= 1.0 && page <= f64::from(u32::MAX) && page.fract() == 0.0) {
return None;
}
let coords = get(data, "insertion").dyn_into::<js_sys::Array>().ok()?;
if coords.length() != 3 {
return None;
}
let mut insertion = [0.0; 3];
for (i, out) in insertion.iter_mut().enumerate() {
*out = coords.get(u32::try_from(i).ok()?).as_f64().filter(|v| v.is_finite())?;
}
let width = get(data, "width").as_f64().filter(|v| v.is_finite() && *v > 0.0)?;
let height = get(data, "height").as_f64().filter(|v| v.is_finite() && *v > 0.0)?;
Message::AttachPdf {
name: file_name(string(data, "name").as_deref(), "document.pdf"),
bytes,
page: page as u32,
insertion,
width,
height,
}
}
Incoming::Saved => Message::Saved { id: string(data, "id")? },
Incoming::HandoffDone => {
Message::HandoffDone { name: string(data, "name").unwrap_or_default(), app: string(data, "app").unwrap_or_default() }
}
})
}
/// `file` (a `Blob`; its `size` field is ignored for the Blob's own) or `bytes` (an `ArrayBuffer` or `Uint8Array`), not copied.
fn file_data(data: &JsValue) -> Option<FileData> {
let file = get(data, "file");
if let Some(blob) = file.dyn_ref::<web_sys::Blob>() {
return Some(FileData::Blob(blob.clone()));
}
let bytes = get(data, "bytes");
if let Some(array) = bytes.dyn_ref::<js_sys::Uint8Array>() {
Some(FileData::Bytes(array.clone()))
} else if bytes.is_instance_of::<js_sys::ArrayBuffer>() {
Some(FileData::Bytes(js_sys::Uint8Array::new(&bytes)))
} else {
None
}
}
fn object(head: &[(&str, JsValue)], fields: &[(&str, JsValue)]) -> Result<js_sys::Object, String> {
let m = js_sys::Object::new();
for (key, value) in head.iter().chain(fields) {
js_sys::Reflect::set(&m, &JsValue::from_str(key), value).map_err(|_| "couldn't build the message".to_string())?;
}
Ok(m)
}
fn get(data: &JsValue, key: &str) -> JsValue {
js_sys::Reflect::get(data, &JsValue::from_str(key)).unwrap_or(JsValue::UNDEFINED)
}
fn string(data: &JsValue, key: &str) -> Option<String> {
get(data, key).as_string()
}
/// Browser tests for parsing and delivery of a host's objects, including origin/source checks.
#[cfg(test)]
mod tests {
use super::*;
use wasm_bindgen_test::wasm_bindgen_test;
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
#[wasm_bindgen_test]
fn test_attach_pdf_rejects_foreign_origin() {
let window = web_sys::window().unwrap();
let origin = window.location().origin().unwrap();
let host = Host {
app: "pdf-attach-test",
transport: Transport::Parent { window: window.clone(), parent: window.clone(), origin: origin.clone() },
dirty: Cell::new(None),
};
let received = Rc::new(Cell::new(0));
let counter = received.clone();
host.listen(move |_| counter.set(counter.get() + 1));
let data = obj(&[
("type", "pdf-attach-test:attach-pdf".into()),
("name", "page.pdf".into()),
("bytes", buffer(3).into()),
("page", 1.into()),
("insertion", js_sys::Array::of3(&10.into(), &20.into(), &3.into()).into()),
("width", 100.into()),
("height", 80.into()),
]);
let send = |origin: &str, source: Option<&web_sys::Window>| {
let init = web_sys::MessageEventInit::new();
init.set_origin(origin);
init.set_source(source.map(|s| s.as_ref()));
init.set_data(&data);
let event = web_sys::MessageEvent::new_with_event_init_dict("message", &init).unwrap();
window.dispatch_event(&event).unwrap();
};
send("https://foreign.example", Some(&window));
assert_eq!(received.get(), 0, "a foreign origin changes nothing");
send(&origin, None);
assert_eq!(received.get(), 0, "the expected origin with another source changes nothing");
send(&origin, Some(&window));
assert_eq!(received.get(), 1, "the same payload from the authorized parent is delivered");
}
fn obj(fields: &[(&str, JsValue)]) -> JsValue {
object(&[], fields).expect("an object").into()
}
#[wasm_bindgen_test]
fn attach_pdf_checks_page_rectangle_and_bytes() {
let valid = || {
obj(&[
("name", "../sheet.pdf".into()),
("bytes", buffer(3).into()),
("page", 2.into()),
("insertion", js_sys::Array::of3(&10.into(), &20.into(), &3.into()).into()),
("width", 100.into()),
("height", 80.into()),
])
};
let Some(Message::AttachPdf { name, bytes, page, insertion, width, height }) = read(Incoming::AttachPdf, &valid()) else {
panic!("valid attachment must be delivered");
};
assert_eq!(name, "sheet.pdf");
assert_eq!(bytes.length(), 3);
assert_eq!((page, insertion, width, height), (2, [10.0, 20.0, 3.0], 100.0, 80.0));
for (key, value) in [
("bytes", JsValue::NULL),
("page", 0.into()),
("page", 1.5.into()),
("page", f64::INFINITY.into()),
("page", 4294967296.0.into()),
("insertion", js_sys::Array::of2(&0.into(), &0.into()).into()),
("insertion", js_sys::Array::of3(&0.into(), &f64::NAN.into(), &0.into()).into()),
("width", 0.into()),
("height", (-1).into()),
("width", "100".into()),
] {
let data = valid();
js_sys::Reflect::set(&data, &key.into(), &value).unwrap();
assert!(read(Incoming::AttachPdf, &data).is_none(), "invalid {key} must be dropped");
}
}
fn buffer(len: u32) -> js_sys::ArrayBuffer {
js_sys::ArrayBuffer::new(len)
}
}