import test from 'node:test'; import assert from 'node:assert/strict'; import { createWorkspaceTransition, waitForWorkspaceContent } from '../src/workspaceTransition.ts'; const deferred=()=>{let resolve;const promise=new Promise(r=>resolve=r);return {promise,resolve};}; function nativeFixture(){const records=[];const start=update=>{const ready=deferred(),finished=deferred(),record={update,ready,finished,skipped:0};records.push(record);return {ready:ready.promise,finished:finished.promise,skipTransition(){record.skipped++;}};};return {start,records};} test('rapid selections only commit the latest route even when skipped native callbacks still execute',async()=>{ const native=nativeFixture(),controller=createWorkspaceTransition(native.start),pages=[]; controller.run(()=>pages.push('department'));controller.run(()=>pages.push('overall')); assert.equal(native.records[0].skipped,1);await native.records[0].update();await native.records[1].update();assert.deepEqual(pages,['overall']);controller.cancel(); }); test('new navigation interrupts preparation of the previous target without queueing behind it',async()=>{ const native=nativeFixture(),controller=createWorkspaceTransition(native.start),pages=[];let previousSignal; controller.run(signal=>{pages.push('department');previousSignal=signal;return new Promise(resolve=>signal.addEventListener('abort',resolve,{once:true}));}); const preparing=native.records[0].update();controller.run(()=>pages.push('product'));assert.equal(previousSignal.aborted,true);await preparing;await native.records[1].update();assert.deepEqual(pages,['department','product']);controller.cancel(); }); test('reduced motion and unavailable APIs commit immediately',()=>{ for(const reduced of [true,false]){let starts=0,commits=0;const controller=createWorkspaceTransition(reduced?()=>{starts++;throw Error('must not start');}:undefined,()=>reduced);controller.run(()=>commits++);assert.equal(starts,0);assert.equal(commits,1);controller.cancel();} }); test('native failure falls back exactly once and cancellation rejects stale pending navigation',async()=>{ let commits=0;createWorkspaceTransition(()=>{throw Error('unavailable snapshot');}).run(()=>commits++);assert.equal(commits,1); const native=nativeFixture(),controller=createWorkspaceTransition(native.start);controller.run(()=>commits++);controller.cancel();await native.records[0].update();assert.equal(commits,1); }); test('content preparation resolves on readiness, timeout or abort and always releases observers/timers',async()=>{ const previous={window:globalThis.window,document:globalThis.document,MutationObserver:globalThis.MutationObserver};let callback,disconnected=0;const timers=new Map();let timerId=0; globalThis.window={setTimeout(fn,delay){const id=++timerId;timers.set(id,{fn:()=>{timers.delete(id);fn();},delay});return id;},clearTimeout:id=>timers.delete(id)};globalThis.document={body:{}};globalThis.MutationObserver=class{constructor(fn){callback=fn;}observe(){}disconnect(){disconnected++;}}; try{let busy=true;const node={querySelector:()=>busy?{}:null};const a=new AbortController();let done=false;const first=waitForWorkspaceContent(()=>node,a.signal).then(()=>done=true);await Promise.resolve();assert.equal(done,false);busy=false;callback();[...timers.values()].find(x=>x.delay===32).fn();await first;assert.equal(timers.size,0); const b=new AbortController();const second=waitForWorkspaceContent(()=>null,b.signal);b.abort();await second;assert.equal(timers.size,0); const third=waitForWorkspaceContent(()=>null,new AbortController().signal);[...timers.values()][0].fn();await third;assert.equal(timers.size,0);assert.equal(disconnected,3); }finally{for(const [key,value] of Object.entries(previous)){if(value===undefined)delete globalThis[key];else globalThis[key]=value;}} }); test('an older completion never unlocks input while the newer transition is still running',async()=>{ const native=nativeFixture(),busy=[],controller=createWorkspaceTransition(native.start,()=>false,value=>busy.push(value));controller.run(()=>{});controller.run(()=>{});native.records[0].finished.resolve();await Promise.resolve();assert.equal(busy.at(-1),true);native.records[1].finished.resolve();await Promise.resolve();assert.equal(busy.at(-1),false);controller.cancel(); });