Implement window.history History API (Phase 17)

+73

crates/browser/src/main.rs

··· 597 597 state.page_scroll_y = 0.0; 598 598 state.scroll_offsets.clear(); 599 599 rerender(state); 600 + 601 + // Process any History API commands queued during page script execution. 602 + process_history_commands(state); 600 603 } 601 604 602 605 /// Load a page from a parsed URL (for form GET submission and navigation). ··· 1828 1831 state.page_scroll_y = 0.0; 1829 1832 state.scroll_offsets.clear(); 1830 1833 rerender(state); 1834 + 1835 + // Process any History API commands queued during page script execution. 1836 + process_history_commands(state); 1831 1837 } 1832 1838 1833 1839 /// Traverse the session history by `delta` steps (negative = back, positive = ··· 1861 1867 state.page_scroll_y = entry.scroll_y; 1862 1868 state.scroll_offsets.clear(); 1863 1869 rerender(state); 1870 + 1871 + // Process any History API commands queued during page script execution. 1872 + process_history_commands(state); 1873 + } 1874 + 1875 + /// Process any pending History API commands queued by JavaScript. 1876 + /// 1877 + /// Called after script execution or page load to handle `pushState`, 1878 + /// `replaceState`, and `back()`/`forward()`/`go()` commands. 1879 + fn process_history_commands(state: &mut BrowserState) { 1880 + let commands = we_js::history::drain_history_queue(); 1881 + for cmd in commands { 1882 + match cmd { 1883 + we_js::history::HistoryCommand::PushState { 1884 + state: js_state, 1885 + title, 1886 + url, 1887 + } => { 1888 + let target_url = if let Some(url_str) = url { 1889 + match Url::parse_with_base(&url_str, &state.page.base_url) { 1890 + Ok(u) => u, 1891 + Err(e) => { 1892 + eprintln!("[we] Invalid pushState URL \"{url_str}\": {e}"); 1893 + continue; 1894 + } 1895 + } 1896 + } else { 1897 + state.page.base_url.clone() 1898 + }; 1899 + 1900 + eprintln!("[we] pushState: {}", target_url.serialize()); 1901 + state 1902 + .history 1903 + .push_state(target_url.clone(), js_state, title); 1904 + // Update the base URL so subsequent relative URL resolution works. 1905 + state.page.base_url = target_url; 1906 + // No page reload — pushState only updates URL and history. 1907 + } 1908 + we_js::history::HistoryCommand::ReplaceState { 1909 + state: js_state, 1910 + title, 1911 + url, 1912 + } => { 1913 + let target_url = if let Some(url_str) = url { 1914 + match Url::parse_with_base(&url_str, &state.page.base_url) { 1915 + Ok(u) => u, 1916 + Err(e) => { 1917 + eprintln!("[we] Invalid replaceState URL \"{url_str}\": {e}"); 1918 + continue; 1919 + } 1920 + } 1921 + } else { 1922 + state.page.base_url.clone() 1923 + }; 1924 + 1925 + eprintln!("[we] replaceState: {}", target_url.serialize()); 1926 + state 1927 + .history 1928 + .replace_state(target_url.clone(), js_state, title); 1929 + state.page.base_url = target_url; 1930 + } 1931 + we_js::history::HistoryCommand::Traverse { delta } => { 1932 + // Traverse triggers a full page load (like clicking back/forward). 1933 + navigate_history(state, delta); 1934 + } 1935 + } 1936 + } 1864 1937 } 1865 1938 1866 1939 /// Called by the platform crate on scroll wheel events.

+134

crates/browser/src/navigation_history.rs

··· 87 87 } 88 88 } 89 89 90 + /// Push a new entry with associated state (used by `history.pushState()`). 91 + /// Unlike `push()`, this preserves the serialized state object and does NOT 92 + /// trigger a page load — only the URL and state are updated. 93 + pub fn push_state(&mut self, url: Url, state: Option<String>, title: String) { 94 + // Discard forward entries. 95 + self.entries.truncate(self.current + 1); 96 + 97 + let entry = HistoryEntry { 98 + url, 99 + scroll_x: 0.0, 100 + scroll_y: 0.0, 101 + state, 102 + title, 103 + }; 104 + self.entries.push(entry); 105 + self.current = self.entries.len() - 1; 106 + 107 + // Enforce size limit by dropping oldest entries. 108 + if self.entries.len() > MAX_HISTORY_SIZE { 109 + let excess = self.entries.len() - MAX_HISTORY_SIZE; 110 + self.entries.drain(..excess); 111 + self.current -= excess; 112 + } 113 + } 114 + 115 + /// Replace the current entry's URL and state (used by 116 + /// `history.replaceState()`). Does NOT trigger a page load. 117 + pub fn replace_state(&mut self, url: Url, state: Option<String>, title: String) { 118 + if let Some(entry) = self.entries.get_mut(self.current) { 119 + entry.url = url; 120 + entry.state = state; 121 + entry.title = title; 122 + // Preserve scroll position — replaceState doesn't reset scroll. 123 + } 124 + } 125 + 90 126 /// Save the current scroll position into the current entry. 91 127 pub fn save_scroll(&mut self, scroll_x: f32, scroll_y: f32) { 92 128 if let Some(entry) = self.entries.get_mut(self.current) { ··· 304 340 h.traverse_back(); 305 341 assert!(!h.can_go_back()); 306 342 assert!(h.can_go_forward()); 343 + } 344 + 345 + #[test] 346 + fn push_state_adds_entry_with_state() { 347 + let mut h = NavigationHistory::new(url("https://a.com/")); 348 + h.push_state( 349 + url("https://a.com/page2"), 350 + Some(r#"{"page":2}"#.to_string()), 351 + "Page 2".to_string(), 352 + ); 353 + assert_eq!(h.len(), 2); 354 + assert_eq!(h.current_index(), 1); 355 + assert_eq!(h.current_entry().url.serialize(), "https://a.com/page2"); 356 + assert_eq!(h.current_entry().state.as_deref(), Some(r#"{"page":2}"#)); 357 + assert_eq!(h.current_entry().title, "Page 2"); 358 + } 359 + 360 + #[test] 361 + fn push_state_discards_forward_entries() { 362 + let mut h = NavigationHistory::new(url("https://a.com/")); 363 + h.push_state(url("https://a.com/b"), None, String::new()); 364 + h.push_state(url("https://a.com/c"), None, String::new()); 365 + h.traverse_back(); // now at /b 366 + h.push_state(url("https://a.com/d"), None, String::new()); 367 + // /c should be discarded 368 + assert_eq!(h.len(), 3); // a, b, d 369 + assert!(!h.can_go_forward()); 370 + } 371 + 372 + #[test] 373 + fn replace_state_updates_current_entry() { 374 + let mut h = NavigationHistory::new(url("https://a.com/")); 375 + h.push(url("https://a.com/page1")); 376 + h.replace_state( 377 + url("https://a.com/page1-v2"), 378 + Some("new_state".to_string()), 379 + "Updated".to_string(), 380 + ); 381 + assert_eq!(h.len(), 2); // No new entry added. 382 + assert_eq!(h.current_entry().url.serialize(), "https://a.com/page1-v2"); 383 + assert_eq!(h.current_entry().state.as_deref(), Some("new_state")); 384 + assert_eq!(h.current_entry().title, "Updated"); 385 + // Previous entry unchanged. 386 + h.traverse_back(); 387 + assert_eq!(h.current_entry().url.serialize(), "https://a.com/"); 388 + } 389 + 390 + #[test] 391 + fn replace_state_preserves_scroll() { 392 + let mut h = NavigationHistory::new(url("https://a.com/")); 393 + h.save_scroll(10.0, 50.0); 394 + h.replace_state(url("https://a.com/replaced"), None, String::new()); 395 + // Scroll should be preserved after replaceState. 396 + assert_eq!(h.current_entry().scroll_x, 10.0); 397 + assert_eq!(h.current_entry().scroll_y, 50.0); 398 + } 399 + 400 + #[test] 401 + fn push_state_resets_scroll() { 402 + let mut h = NavigationHistory::new(url("https://a.com/")); 403 + h.save_scroll(10.0, 50.0); 404 + h.push_state(url("https://a.com/new"), None, String::new()); 405 + // New entry should have zero scroll. 406 + assert_eq!(h.current_entry().scroll_x, 0.0); 407 + assert_eq!(h.current_entry().scroll_y, 0.0); 408 + } 409 + 410 + #[test] 411 + fn push_state_size_bounded() { 412 + let mut h = NavigationHistory::new(url("https://page0.com/")); 413 + for i in 1..=60 { 414 + h.push_state( 415 + url(&format!("https://page{i}.com/")), 416 + Some(format!("{i}")), 417 + String::new(), 418 + ); 419 + } 420 + assert_eq!(h.len(), MAX_HISTORY_SIZE); 421 + assert_eq!(h.current_entry().url.serialize(), "https://page60.com/"); 422 + } 423 + 424 + #[test] 425 + fn state_survives_traversal() { 426 + let mut h = NavigationHistory::new(url("https://a.com/")); 427 + h.push_state( 428 + url("https://a.com/page2"), 429 + Some("state2".to_string()), 430 + String::new(), 431 + ); 432 + h.push_state( 433 + url("https://a.com/page3"), 434 + Some("state3".to_string()), 435 + String::new(), 436 + ); 437 + let e = h.traverse_back().unwrap(); 438 + assert_eq!(e.state.as_deref(), Some("state2")); 439 + let e = h.traverse_back().unwrap(); 440 + assert!(e.state.is_none()); // Initial entry has no state. 307 441 } 308 442 }

+557

crates/js/src/history.rs

··· 1 + //! `window.history` — the History API. 2 + //! 3 + //! Exposes `pushState`, `replaceState`, `back`, `forward`, `go`, `length`, 4 + //! `state`, and `scrollRestoration` to JavaScript. History commands are queued 5 + //! in a thread-local queue and drained by the browser main loop, similar to 6 + //! the navigation command queue in `location.rs`. 7 + 8 + use std::cell::RefCell; 9 + 10 + use crate::builtins::{make_native, set_builtin_prop}; 11 + use crate::gc::{Gc, GcRef}; 12 + use crate::shape::ShapeTable; 13 + use crate::vm::*; 14 + 15 + /// Internal key marking an object as a History object. 16 + pub(crate) const HISTORY_MARKER_KEY: &str = "__history__"; 17 + 18 + // --------------------------------------------------------------------------- 19 + // History command queue 20 + // --------------------------------------------------------------------------- 21 + 22 + /// A command queued by History API methods, to be consumed by the browser. 23 + pub enum HistoryCommand { 24 + /// `history.pushState(state, title, url)` — push a new entry without 25 + /// triggering a page load. 26 + PushState { 27 + state: Option<String>, 28 + title: String, 29 + url: Option<String>, 30 + }, 31 + /// `history.replaceState(state, title, url)` — replace current entry 32 + /// without triggering a page load. 33 + ReplaceState { 34 + state: Option<String>, 35 + title: String, 36 + url: Option<String>, 37 + }, 38 + /// `history.back()` / `history.forward()` / `history.go(delta)` — traverse 39 + /// the session history by `delta` steps. 40 + Traverse { delta: i32 }, 41 + } 42 + 43 + thread_local! { 44 + static HISTORY_QUEUE: RefCell<Vec<HistoryCommand>> = const { RefCell::new(Vec::new()) }; 45 + } 46 + 47 + /// Drain all pending history commands from the queue. 48 + pub fn drain_history_queue() -> Vec<HistoryCommand> { 49 + HISTORY_QUEUE.with(|q| { 50 + let mut queue = q.borrow_mut(); 51 + std::mem::take(&mut *queue) 52 + }) 53 + } 54 + 55 + fn push_history_command(cmd: HistoryCommand) { 56 + HISTORY_QUEUE.with(|q| { 57 + q.borrow_mut().push(cmd); 58 + }); 59 + } 60 + 61 + // --------------------------------------------------------------------------- 62 + // History object creation 63 + // --------------------------------------------------------------------------- 64 + 65 + /// Create a History object with native methods. 66 + /// 67 + /// The object is marked with `HISTORY_MARKER_KEY` so it can be identified by 68 + /// the dynamic property resolver. The `length` and `state` properties are 69 + /// resolved dynamically from the browser's `NavigationHistory`. 70 + pub fn create_history_object(gc: &mut Gc<HeapObject>, shapes: &mut ShapeTable) -> GcRef { 71 + let mut data = ObjectData::new(); 72 + data.insert_property( 73 + HISTORY_MARKER_KEY.to_string(), 74 + Property::builtin(Value::Boolean(true)), 75 + shapes, 76 + ); 77 + 78 + // scrollRestoration defaults to "auto". 79 + data.insert_property( 80 + "scrollRestoration".to_string(), 81 + Property::data(Value::String("auto".to_string())), 82 + shapes, 83 + ); 84 + 85 + let hist_ref = gc.alloc(HeapObject::Object(data)); 86 + 87 + // pushState(state, title, url?) 88 + let push_fn = make_native(gc, "pushState", history_push_state); 89 + set_builtin_prop(gc, shapes, hist_ref, "pushState", Value::Function(push_fn)); 90 + 91 + // replaceState(state, title, url?) 92 + let replace_fn = make_native(gc, "replaceState", history_replace_state); 93 + set_builtin_prop( 94 + gc, 95 + shapes, 96 + hist_ref, 97 + "replaceState", 98 + Value::Function(replace_fn), 99 + ); 100 + 101 + // back() 102 + let back_fn = make_native(gc, "back", history_back); 103 + set_builtin_prop(gc, shapes, hist_ref, "back", Value::Function(back_fn)); 104 + 105 + // forward() 106 + let forward_fn = make_native(gc, "forward", history_forward); 107 + set_builtin_prop(gc, shapes, hist_ref, "forward", Value::Function(forward_fn)); 108 + 109 + // go(delta) 110 + let go_fn = make_native(gc, "go", history_go); 111 + set_builtin_prop(gc, shapes, hist_ref, "go", Value::Function(go_fn)); 112 + 113 + hist_ref 114 + } 115 + 116 + /// Check whether a GcRef is a History object. 117 + pub fn is_history_object(gc: &Gc<HeapObject>, shapes: &ShapeTable, gc_ref: GcRef) -> bool { 118 + if let Some(HeapObject::Object(data)) = gc.get(gc_ref) { 119 + data.contains_key(HISTORY_MARKER_KEY, shapes) 120 + } else { 121 + false 122 + } 123 + } 124 + 125 + // --------------------------------------------------------------------------- 126 + // Dynamic property resolution (getters) 127 + // --------------------------------------------------------------------------- 128 + 129 + /// Resolve a dynamic property on a History object. 130 + /// 131 + /// `length` and `state` are stored on the object by the browser when the 132 + /// history changes. `scrollRestoration` is stored statically on the object. 133 + pub fn resolve_history_get( 134 + gc: &Gc<HeapObject>, 135 + shapes: &ShapeTable, 136 + gc_ref: GcRef, 137 + key: &str, 138 + ) -> Option<Value> { 139 + if !is_history_object(gc, shapes, gc_ref) { 140 + return None; 141 + } 142 + 143 + // `length`, `state`, and `scrollRestoration` are stored as normal 144 + // properties and updated by the browser. Just resolve them from the 145 + // object's own properties. 146 + if let Some(HeapObject::Object(data)) = gc.get(gc_ref) { 147 + match key { 148 + "length" | "state" | "scrollRestoration" => { 149 + return data.get_property(key, shapes).map(|p| p.value.clone()); 150 + } 151 + _ => {} 152 + } 153 + } 154 + None 155 + } 156 + 157 + // --------------------------------------------------------------------------- 158 + // Native method implementations 159 + // --------------------------------------------------------------------------- 160 + 161 + /// Serialize a JS value to a JSON string for state storage. 162 + /// This is a simplified "structured clone" — we serialize to JSON. 163 + fn serialize_state(value: &Value, gc: &Gc<HeapObject>, shapes: &ShapeTable) -> Option<String> { 164 + match value { 165 + Value::Undefined | Value::Null => None, 166 + Value::Boolean(b) => Some(b.to_string()), 167 + Value::Number(n) => { 168 + if n.is_nan() || n.is_infinite() { 169 + Some("null".to_string()) 170 + } else { 171 + Some(format!("{n}")) 172 + } 173 + } 174 + Value::String(s) => Some(format!( 175 + "\"{}\"", 176 + s.replace('\\', "\\\\").replace('"', "\\\"") 177 + )), 178 + Value::Object(_) => { 179 + // Reuse the serializer from iframe_bridge (it's the same algorithm). 180 + Some(crate::iframe_bridge::serialize_for_post_message( 181 + value, gc, shapes, 182 + )) 183 + } 184 + Value::Function(_) => { 185 + // Functions cannot be serialized (DataCloneError in spec). 186 + None 187 + } 188 + } 189 + } 190 + 191 + /// `history.pushState(state, title, url?)` — push a new entry. 192 + fn history_push_state(args: &[Value], ctx: &mut NativeContext) -> Result<Value, RuntimeError> { 193 + let state = args.first().unwrap_or(&Value::Null); 194 + let title = args 195 + .get(1) 196 + .map(|v| v.to_js_string(ctx.gc)) 197 + .unwrap_or_default(); 198 + let url = args.get(2).and_then(|v| match v { 199 + Value::Undefined | Value::Null => None, 200 + _ => { 201 + let s = v.to_js_string(ctx.gc); 202 + if s.is_empty() { 203 + None 204 + } else { 205 + // Resolve against current document URL. 206 + Some(resolve_url_against_current(&s, ctx.dom_bridge)) 207 + } 208 + } 209 + }); 210 + 211 + // Validate same-origin if a URL was provided. 212 + if let Some(ref new_url) = url { 213 + if let Some(bridge) = ctx.dom_bridge { 214 + let current_origin = bridge.origin.borrow().clone(); 215 + if !is_same_origin(new_url, &current_origin) { 216 + return Err(RuntimeError::type_error(format!( 217 + "SecurityError: pushState URL '{new_url}' has a different origin than the document" 218 + ))); 219 + } 220 + } 221 + } 222 + 223 + let serialized = serialize_state(state, ctx.gc, ctx.shapes); 224 + 225 + push_history_command(HistoryCommand::PushState { 226 + state: serialized, 227 + title, 228 + url, 229 + }); 230 + 231 + Ok(Value::Undefined) 232 + } 233 + 234 + /// `history.replaceState(state, title, url?)` — replace current entry. 235 + fn history_replace_state(args: &[Value], ctx: &mut NativeContext) -> Result<Value, RuntimeError> { 236 + let state = args.first().unwrap_or(&Value::Null); 237 + let title = args 238 + .get(1) 239 + .map(|v| v.to_js_string(ctx.gc)) 240 + .unwrap_or_default(); 241 + let url = args.get(2).and_then(|v| match v { 242 + Value::Undefined | Value::Null => None, 243 + _ => { 244 + let s = v.to_js_string(ctx.gc); 245 + if s.is_empty() { 246 + None 247 + } else { 248 + Some(resolve_url_against_current(&s, ctx.dom_bridge)) 249 + } 250 + } 251 + }); 252 + 253 + // Validate same-origin if a URL was provided. 254 + if let Some(ref new_url) = url { 255 + if let Some(bridge) = ctx.dom_bridge { 256 + let current_origin = bridge.origin.borrow().clone(); 257 + if !is_same_origin(new_url, &current_origin) { 258 + return Err(RuntimeError::type_error(format!( 259 + "SecurityError: replaceState URL '{new_url}' has a different origin than the document" 260 + ))); 261 + } 262 + } 263 + } 264 + 265 + let serialized = serialize_state(state, ctx.gc, ctx.shapes); 266 + 267 + push_history_command(HistoryCommand::ReplaceState { 268 + state: serialized, 269 + title, 270 + url, 271 + }); 272 + 273 + Ok(Value::Undefined) 274 + } 275 + 276 + /// `history.back()` — go back one step. 277 + fn history_back(_args: &[Value], _ctx: &mut NativeContext) -> Result<Value, RuntimeError> { 278 + push_history_command(HistoryCommand::Traverse { delta: -1 }); 279 + Ok(Value::Undefined) 280 + } 281 + 282 + /// `history.forward()` — go forward one step. 283 + fn history_forward(_args: &[Value], _ctx: &mut NativeContext) -> Result<Value, RuntimeError> { 284 + push_history_command(HistoryCommand::Traverse { delta: 1 }); 285 + Ok(Value::Undefined) 286 + } 287 + 288 + /// `history.go(delta)` — traverse by delta steps. `go(0)` reloads. 289 + fn history_go(args: &[Value], _ctx: &mut NativeContext) -> Result<Value, RuntimeError> { 290 + let delta = args 291 + .first() 292 + .map(|v| match v { 293 + Value::Number(n) => *n as i32, 294 + _ => 0, 295 + }) 296 + .unwrap_or(0); 297 + 298 + if delta == 0 { 299 + // go(0) reloads the page — use the location reload mechanism. 300 + crate::location::push_reload_cmd(); 301 + } else { 302 + push_history_command(HistoryCommand::Traverse { delta }); 303 + } 304 + 305 + Ok(Value::Undefined) 306 + } 307 + 308 + // --------------------------------------------------------------------------- 309 + // Helpers 310 + // --------------------------------------------------------------------------- 311 + 312 + /// Resolve a (possibly relative) URL against the current document URL. 313 + fn resolve_url_against_current(input: &str, bridge: Option<&DomBridge>) -> String { 314 + let base = bridge.and_then(|b| b.document_url.borrow().clone()); 315 + match base { 316 + Some(base_url) => we_url::Url::parse_with_base(input, &base_url) 317 + .map(|u| u.serialize()) 318 + .unwrap_or_else(|_| input.to_string()), 319 + None => input.to_string(), 320 + } 321 + } 322 + 323 + /// Check whether a URL string is same-origin with the given origin string. 324 + fn is_same_origin(url_str: &str, current_origin: &str) -> bool { 325 + match we_url::Url::parse(url_str) { 326 + Ok(url) => { 327 + let new_origin = url.origin().serialize(); 328 + new_origin == current_origin 329 + } 330 + Err(_) => { 331 + // If we can't parse the URL, it will be resolved relative to the 332 + // current document — which is always same-origin. 333 + true 334 + } 335 + } 336 + } 337 + 338 + /// Create a PopStateEvent object with the given state. 339 + pub fn create_popstate_event( 340 + gc: &mut Gc<HeapObject>, 341 + shapes: &mut ShapeTable, 342 + state: Value, 343 + ) -> GcRef { 344 + let mut obj = ObjectData::new(); 345 + 346 + // Standard Event properties. 347 + obj.insert_property( 348 + "type".to_string(), 349 + Property::data(Value::String("popstate".to_string())), 350 + shapes, 351 + ); 352 + obj.insert_property( 353 + "bubbles".to_string(), 354 + Property::data(Value::Boolean(true)), 355 + shapes, 356 + ); 357 + obj.insert_property( 358 + "cancelable".to_string(), 359 + Property::data(Value::Boolean(false)), 360 + shapes, 361 + ); 362 + obj.insert_property( 363 + "defaultPrevented".to_string(), 364 + Property::data(Value::Boolean(false)), 365 + shapes, 366 + ); 367 + obj.insert_property( 368 + "eventPhase".to_string(), 369 + Property::data(Value::Number(0.0)), 370 + shapes, 371 + ); 372 + obj.insert_property("target".to_string(), Property::data(Value::Null), shapes); 373 + obj.insert_property( 374 + "currentTarget".to_string(), 375 + Property::data(Value::Null), 376 + shapes, 377 + ); 378 + obj.insert_property( 379 + "timeStamp".to_string(), 380 + Property::data(Value::Number(0.0)), 381 + shapes, 382 + ); 383 + 384 + // Internal event state keys. 385 + obj.insert_property( 386 + "__event_type__".to_string(), 387 + Property::builtin(Value::String("popstate".to_string())), 388 + shapes, 389 + ); 390 + obj.insert_property( 391 + "__event_bubbles__".to_string(), 392 + Property::builtin(Value::Boolean(true)), 393 + shapes, 394 + ); 395 + obj.insert_property( 396 + "__event_cancelable__".to_string(), 397 + Property::builtin(Value::Boolean(false)), 398 + shapes, 399 + ); 400 + obj.insert_property( 401 + "__event_stop_prop__".to_string(), 402 + Property::builtin(Value::Boolean(false)), 403 + shapes, 404 + ); 405 + obj.insert_property( 406 + "__event_stop_immediate__".to_string(), 407 + Property::builtin(Value::Boolean(false)), 408 + shapes, 409 + ); 410 + obj.insert_property( 411 + "__event_default_prevented__".to_string(), 412 + Property::builtin(Value::Boolean(false)), 413 + shapes, 414 + ); 415 + obj.insert_property( 416 + "__event_phase__".to_string(), 417 + Property::builtin(Value::Number(0.0)), 418 + shapes, 419 + ); 420 + 421 + // PopStateEvent-specific property. 422 + obj.insert_property("state".to_string(), Property::data(state), shapes); 423 + 424 + gc.alloc(HeapObject::Object(obj)) 425 + } 426 + 427 + // --------------------------------------------------------------------------- 428 + // Tests 429 + // --------------------------------------------------------------------------- 430 + 431 + #[cfg(test)] 432 + mod tests { 433 + use super::*; 434 + use crate::gc::Gc; 435 + 436 + #[test] 437 + fn history_object_has_marker() { 438 + let mut gc = Gc::<HeapObject>::new(); 439 + let mut shapes = ShapeTable::new(); 440 + let hist = create_history_object(&mut gc, &mut shapes); 441 + assert!(is_history_object(&gc, &shapes, hist)); 442 + } 443 + 444 + #[test] 445 + fn history_object_has_methods() { 446 + let mut gc = Gc::<HeapObject>::new(); 447 + let mut shapes = ShapeTable::new(); 448 + let hist = create_history_object(&mut gc, &mut shapes); 449 + if let Some(HeapObject::Object(data)) = gc.get(hist) { 450 + assert!(data.get_property("pushState", &shapes).is_some()); 451 + assert!(data.get_property("replaceState", &shapes).is_some()); 452 + assert!(data.get_property("back", &shapes).is_some()); 453 + assert!(data.get_property("forward", &shapes).is_some()); 454 + assert!(data.get_property("go", &shapes).is_some()); 455 + } else { 456 + panic!("expected Object"); 457 + } 458 + } 459 + 460 + #[test] 461 + fn history_object_default_scroll_restoration() { 462 + let mut gc = Gc::<HeapObject>::new(); 463 + let mut shapes = ShapeTable::new(); 464 + let hist = create_history_object(&mut gc, &mut shapes); 465 + let val = resolve_history_get(&gc, &shapes, hist, "scrollRestoration"); 466 + match val { 467 + Some(Value::String(s)) => assert_eq!(s, "auto"), 468 + other => panic!("expected 'auto', got {other:?}"), 469 + } 470 + } 471 + 472 + #[test] 473 + fn non_history_object_returns_none() { 474 + let mut gc = Gc::<HeapObject>::new(); 475 + let shapes = ShapeTable::new(); 476 + let plain = gc.alloc(HeapObject::Object(ObjectData::new())); 477 + assert!(!is_history_object(&gc, &shapes, plain)); 478 + assert!(resolve_history_get(&gc, &shapes, plain, "length").is_none()); 479 + } 480 + 481 + #[test] 482 + fn history_queue_drain() { 483 + // Clear leftover state. 484 + drain_history_queue(); 485 + 486 + push_history_command(HistoryCommand::PushState { 487 + state: Some("{}".to_string()), 488 + title: String::new(), 489 + url: Some("https://example.com/page2".to_string()), 490 + }); 491 + push_history_command(HistoryCommand::Traverse { delta: -1 }); 492 + 493 + let cmds = drain_history_queue(); 494 + assert_eq!(cmds.len(), 2); 495 + match &cmds[0] { 496 + HistoryCommand::PushState { state, url, .. } => { 497 + assert_eq!(state.as_deref(), Some("{}")); 498 + assert_eq!(url.as_deref(), Some("https://example.com/page2")); 499 + } 500 + _ => panic!("expected PushState"), 501 + } 502 + match &cmds[1] { 503 + HistoryCommand::Traverse { delta } => assert_eq!(*delta, -1), 504 + _ => panic!("expected Traverse"), 505 + } 506 + 507 + // Queue should be empty after drain. 508 + assert!(drain_history_queue().is_empty()); 509 + } 510 + 511 + #[test] 512 + fn popstate_event_creation() { 513 + let mut gc = Gc::<HeapObject>::new(); 514 + let mut shapes = ShapeTable::new(); 515 + let state_val = Value::String("test_state".to_string()); 516 + let event = create_popstate_event(&mut gc, &mut shapes, state_val); 517 + 518 + if let Some(HeapObject::Object(data)) = gc.get(event) { 519 + let type_val = data.get_property("type", &shapes); 520 + match type_val.as_ref().map(|p| &p.value) { 521 + Some(Value::String(s)) => assert_eq!(s, "popstate"), 522 + other => panic!("expected 'popstate', got {other:?}"), 523 + } 524 + let state = data.get_property("state", &shapes); 525 + match state.as_ref().map(|p| &p.value) { 526 + Some(Value::String(s)) => assert_eq!(s, "test_state"), 527 + other => panic!("expected 'test_state', got {other:?}"), 528 + } 529 + // popstate should bubble. 530 + let bubbles = data.get_property("bubbles", &shapes); 531 + match bubbles.as_ref().map(|p| &p.value) { 532 + Some(Value::Boolean(true)) => {} 533 + other => panic!("expected true, got {other:?}"), 534 + } 535 + } else { 536 + panic!("Expected Object"); 537 + } 538 + } 539 + 540 + #[test] 541 + fn same_origin_check() { 542 + assert!(is_same_origin( 543 + "https://example.com/page2", 544 + "https://example.com" 545 + )); 546 + assert!(!is_same_origin( 547 + "https://evil.com/page", 548 + "https://example.com" 549 + )); 550 + assert!(is_same_origin( 551 + "https://example.com:443/path", 552 + "https://example.com" 553 + )); 554 + // Relative URLs are same-origin by definition. 555 + assert!(is_same_origin("/relative/path", "https://example.com")); 556 + } 557 + }

+15 -1

crates/js/src/iframe_bridge.rs

··· 104 104 *bridge.location_object.borrow_mut() = Some(location_ref); 105 105 } 106 106 107 + // window.history — proper History object. 108 + let history_ref = crate::history::create_history_object(&mut vm.gc, &mut vm.shapes); 109 + set_builtin_prop( 110 + &mut vm.gc, 111 + &mut vm.shapes, 112 + window_ref, 113 + "history", 114 + Value::Object(history_ref), 115 + ); 116 + 107 117 // window.origin 108 118 set_builtin_prop( 109 119 &mut vm.gc, ··· 217 227 } 218 228 219 229 /// Serialize a JS Value to a string for postMessage (simplified structured clone). 220 - fn serialize_for_post_message(value: &Value, gc: &Gc<HeapObject>, shapes: &ShapeTable) -> String { 230 + pub fn serialize_for_post_message( 231 + value: &Value, 232 + gc: &Gc<HeapObject>, 233 + shapes: &ShapeTable, 234 + ) -> String { 221 235 match value { 222 236 Value::Undefined => "undefined".to_string(), 223 237 Value::Null => "null".to_string(),

+1

crates/js/src/lib.rs

··· 7 7 pub mod dom_bridge; 8 8 pub mod fetch; 9 9 pub mod gc; 10 + pub mod history; 10 11 pub mod iframe_bridge; 11 12 pub mod indexeddb; 12 13 pub mod jit;

+5

crates/js/src/location.rs

··· 54 54 }); 55 55 } 56 56 57 + /// Public API for queuing a reload command (used by `history.go(0)`). 58 + pub fn push_reload_cmd() { 59 + push_reload(); 60 + } 61 + 57 62 // --------------------------------------------------------------------------- 58 63 // Location object creation 59 64 // ---------------------------------------------------------------------------

+5

crates/js/src/vm.rs

··· 2643 2643 { 2644 2644 return Some(val); 2645 2645 } 2646 + // Try History object properties (length, state, scrollRestoration). 2647 + if let Some(val) = crate::history::resolve_history_get(&self.gc, &self.shapes, gc_ref, key) 2648 + { 2649 + return Some(val); 2650 + } 2646 2651 // Try window properties (parent, top, frames, length). 2647 2652 if let Some(val) = 2648 2653 crate::iframe_bridge::resolve_window_property(&self.gc, &self.shapes, gc_ref, key)

Configure Feed

Configure Feed