Files
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

64 lines
5.4 KiB
JavaScript

window.addEventListener('load', async () => {
const assert=(condition,message)=>{if(!condition)throw new Error(message);};
const wait=async condition=>{for(let i=0;i<240;i++){if(condition())return;await new Promise(r=>setTimeout(r,25));}throw new Error('City worker fixture timed out');};
const rejectName=async(promise,name)=>{let rejected=false;try{await promise;}catch(error){rejected=true;if(name)assert(error.name===name,`Expected ${name}, got ${error.name}`);}assert(rejected,'Operation unexpectedly resolved');};
const fabric={generator:'test',version:'test',width:180,height:100,roads:[[10,10,20,20]],buildings:[[[1,1],[1,2],[2,2]]]};
const WorkerClient=window.PagesWikiCityFabricClient;
class FakeWorker {
constructor(){this.terminated=false;this.message=null;}
postMessage(message){this.message=message;}
terminate(){this.terminated=true;}
result(value=fabric){this.onmessage({data:{id:this.message.id,fabric:value}});}
}
class MemoryStorage {
constructor(){this.values=new Map();}
get length(){return this.values.size;}
key(index){return [...this.values.keys()][index];}
getItem(key){return this.values.get(key)||null;}
setItem(key,value){this.values.set(key,String(value));}
removeItem(key){this.values.delete(key);}
}
try{
await wait(()=>document.querySelector('.city-quartier-tile'));
assert(window.PagesWikiGenCity instanceof WorkerClient,'Main thread loaded the synchronous generator');
assert(!document.querySelector('script[src*="gen-city.bundle"]'),'Generator bundle executes in the page');
const real=new WorkerClient({storage:null});
const first=await real.generateFabric('deterministic-domain',240,160);
assert(first.generator==='gen-city'&&first.roads.length>0&&first.buildings.length>0,'Real Worker generated no city');
const second=await new WorkerClient({storage:null}).generateFabric('deterministic-domain',240,160);
assert(JSON.stringify(first)===JSON.stringify(second),'Domain seed is nondeterministic');
// Force expensive synchronous work inside an actual Worker and ensure that
// main-thread timers continue to run throughout it.
const blob=URL.createObjectURL(new Blob([`onmessage=e=>{const until=performance.now()+180;while(performance.now()<until){};postMessage({id:e.data.id,fabric:${JSON.stringify(fabric)}});};`],{type:'text/javascript'}));
let ticks=0;const timer=setInterval(()=>ticks++,10);
try{await new WorkerClient({storage:null,workerFactory:()=>new Worker(blob)}).generateFabric('busy');}finally{clearInterval(timer);URL.revokeObjectURL(blob);}
assert(ticks>=5,'Worker computation starved main-thread timers');
const workers=[], storage=new MemoryStorage();
const client=new WorkerClient({storage,workerFactory:()=>{const w=new FakeWorker();workers.push(w);return w;}});
const a=client.generateFabric('a');const aRejected=rejectName(a,'AbortError');
const b=client.generateFabric('b');await aRejected;
assert(workers[0].terminated,'Superseded Worker stayed alive');
workers[0].result();assert(client.pending?.key.includes('"b"'),'Stale Worker replaced the active job');
workers[1].result();await b;assert(workers[1].terminated&&!client.pending,'Completed Worker was not released');
const count=workers.length;await client.generateFabric('b');assert(workers.length===count,'Memory cache regenerated a stable Domain');
const warm=new WorkerClient({storage,workerFactory:()=>{throw new Error('Cache miss');}});
await warm.generateFabric('b');
const abort=new AbortController(), pending=client.generateFabric('cancel',180,100,{signal:abort.signal});
const cancelled=rejectName(pending,'AbortError');abort.abort();await cancelled;assert(workers.at(-1).terminated,'Abort did not terminate Worker');
const timed=new FakeWorker();await rejectName(new WorkerClient({storage:null,timeout:30,workerFactory:()=>timed}).generateFabric('timeout'));
assert(timed.terminated,'Timed-out Worker stayed alive');
await rejectName(new WorkerClient({storage:null,workerFactory:()=>{throw new Error('Blocked');}}).generateFabric('unsupported'));
const invalid=client.generateFabric('invalid');const invalidRejected=rejectName(invalid);workers.at(-1).result({...fabric,roads:[[Infinity,0,0,0]]});await invalidRejected;
await rejectName(client.generateFabric('too-large',100000,100),'RangeError');
for(const name of ['c','d','e','f']){const task=client.generateFabric(name);workers.at(-1).result();await task;}
assert(client.memory.size<=3&&storage.length<=3,'Geometry cache grew without a bound');
const global=window.PagesWikiGenCity, factory=global.workerFactory, lifecycle=new FakeWorker();global.workerFactory=()=>lifecycle;
const task=global.generateFabric('lifecycle-cancelled'), stopped=rejectName(task,'AbortError');
window.dispatchEvent(new PageTransitionEvent('pagehide',{persisted:true}));await stopped;
assert(lifecycle.terminated&&!global.pending,'Page suspension retained CPU work');
global.workerFactory=factory;const previous=document.querySelector('.city-quartier-tile');window.dispatchEvent(new PageTransitionEvent('pageshow',{persisted:true}));
await wait(()=>document.querySelector('.city-quartier-tile')&&document.querySelector('.city-quartier-tile')!==previous);
document.body.dataset.vimReady='true';
}catch(error){const box=document.createElement('div');box.id='error';box.textContent=error.stack||error.message;document.body.append(box);}
});