From b7563556d8d96a87c79603f5633028caad092e92 Mon Sep 17 00:00:00 2001 From: zheng1114567 Date: Thu, 19 Nov 2026 14:26:57 +0800 Subject: [PATCH] fix(flow): keep the canvas usable when a coordinate goes non-finite A non-finite node position or viewport x/y/zoom poisons every transform and fit computed from the canvas. Browsers drop the invalid transform, so panning and zooming freeze while the zoom label keeps changing. Repair non-finite viewport state before it is written, skip nodes without usable coordinates when fitting the view, park broken nodes on a grid slot at render time, and keep the previous position when an AI edit draft omits one coordinate. --- web/app/flow-viewport.js | 31 ++++++++- web/app/flows.js | 11 ++++ web/orchestrate.js | 4 +- webtest/tests/flow-viewport-recovery.test.mjs | 65 +++++++++++++++++++ 4 files changed, 106 insertions(+), 5 deletions(-) create mode 100644 webtest/tests/flow-viewport-recovery.test.mjs diff --git a/web/app/flow-viewport.js b/web/app/flow-viewport.js index 2be96fef0..e7a259fc7 100644 --- a/web/app/flow-viewport.js +++ b/web/app/flow-viewport.js @@ -7,9 +7,18 @@ const flowViewport=(()=>{ const byId=id=>document.getElementById(id); const canvas=()=>byId('canvas'); const clamp=z=>Math.min(MAX,Math.max(MIN,z)); + const finite=n=>Number.isFinite(n); + // A non-finite x/y/zoom renders an invalid transform that the browser drops, + // freezing the canvas for good. Repair it before anyone divides by it. + function heal(){ + if(!finite(vp.x))vp.x=40; + if(!finite(vp.y))vp.y=40; + vp.zoom=finite(vp.zoom)?clamp(vp.zoom):1; + } function apply(anim){ const stage=byId('canvasStage'),c=canvas();if(!stage||!c)return; + heal(); stage.classList.toggle('anim',!!anim); stage.style.transform=`translate(${vp.x}px,${vp.y}px) scale(${vp.zoom})`; const g=GRID*vp.zoom;c.style.backgroundSize=`${g}px ${g}px`;c.style.backgroundPosition=`${vp.x}px ${vp.y}px`; @@ -19,7 +28,7 @@ const flowViewport=(()=>{ if(anim)animTimer=setTimeout(()=>stage.classList.remove('anim'),400); } function rect(){return canvas()?.getBoundingClientRect()||{left:0,top:0,width:0,height:0}} - function toWorld(clientX,clientY){const r=rect();return {x:(clientX-r.left-vp.x)/vp.zoom,y:(clientY-r.top-vp.y)/vp.zoom}} + function toWorld(clientX,clientY){heal();const r=rect();return {x:(clientX-r.left-vp.x)/vp.zoom,y:(clientY-r.top-vp.y)/vp.zoom}} function drawerWidth(){ const wrap=byId('flowStageWrap');if(!wrap||!wrap.classList.contains('has-drawer'))return 0; const open=wrap.querySelector('.fd-drawer.open,.fd-ai-panel:not([hidden])'); @@ -28,13 +37,15 @@ const flowViewport=(()=>{ // Visible canvas size, minus the drawer that overlays its right edge. function visible(){const c=canvas();return {w:Math.max(0,(c?.clientWidth||0)-drawerWidth()),h:c?.clientHeight||0}} function zoomAt(z,clientX,clientY,anim){ + heal(); + if(!finite(z)){apply(anim);return} const r=rect(),v=visible(); const cx=clientX??r.left+v.w/2,cy=clientY??r.top+v.h/2; const w=toWorld(cx,cy); vp.zoom=clamp(z);vp.x=cx-r.left-w.x*vp.zoom;vp.y=cy-r.top-w.y*vp.zoom; apply(anim); } - function zoomBy(factor,clientX,clientY){zoomAt(vp.zoom*factor,clientX,clientY,clientX==null)} + function zoomBy(factor,clientX,clientY){heal();zoomAt(vp.zoom*factor,clientX,clientY,clientX==null)} function setZoom(z){zoomAt(z,null,null,true)} function nodeSize(id){ const m=typeof flowNodeMetrics==='function'?flowNodeMetrics(id):null; @@ -46,20 +57,31 @@ const flowViewport=(()=>{ const nodes=state.workflow?.nodes||[]; if(!nodes.length)return null; let x0=Infinity,y0=Infinity,x1=-Infinity,y1=-Infinity; - nodes.forEach(n=>{const p=n.position||{x:0,y:0},s=nodeSize(n.id);x0=Math.min(x0,p.x);y0=Math.min(y0,p.y);x1=Math.max(x1,p.x+s.w);y1=Math.max(y1,p.y+s.h+(n.rejectTo?60:0))}); + nodes.forEach(n=>{ + const p=n.position; + if(!p||!finite(p.x)||!finite(p.y))return; + const s=nodeSize(n.id); + if(!finite(s.w)||!finite(s.h))return; + x0=Math.min(x0,p.x);y0=Math.min(y0,p.y);x1=Math.max(x1,p.x+s.w);y1=Math.max(y1,p.y+s.h+(n.rejectTo?60:0)); + }); + if(!finite(x0)||!finite(y0)||!(x1>=x0)||!(y1>=y0))return null; return {x:x0,y:y0,w:x1-x0,h:y1-y0}; } function fit(opts={}){ const smooth=opts.smooth!==false,pad=opts.padding??72,v=visible(); if(!v.w||!v.h)return; + heal(); const b=bounds(); if(!b){vp.zoom=1;vp.x=40;vp.y=40;apply(smooth);return} vp.zoom=clamp(Math.min(opts.maxZoom??1,(v.w-pad*2)/b.w,(v.h-pad*2)/b.h)); vp.x=(v.w-b.w*vp.zoom)/2-b.x*vp.zoom; vp.y=(v.h-b.h*vp.zoom)/2-b.y*vp.zoom; + if(!finite(vp.x)||!finite(vp.y)||!finite(vp.zoom)){vp.zoom=1;vp.x=40;vp.y=40} apply(smooth); } function centerOn(x,y,opts={}){ + heal(); + if(!finite(x)||!finite(y)){apply(!!opts.smooth);return} const v=visible();if(!v.w)return; vp.x=v.w/2-x*vp.zoom;vp.y=v.h/2-y*vp.zoom; apply(!!opts.smooth); @@ -68,8 +90,10 @@ const flowViewport=(()=>{ // Pans the least distance that brings a node fully into the visible area. function reveal(nodeId){ const n=(state.workflow?.nodes||[]).find(x=>x.id===nodeId);if(!n)return; + heal(); const v=visible(),s=nodeSize(nodeId),m=24,top=64,bottom=72; const sx=n.position.x*vp.zoom+vp.x,sy=n.position.y*vp.zoom+vp.y,sw=s.w*vp.zoom,sh=s.h*vp.zoom; + if(!finite(sx)||!finite(sy)||!finite(sw)||!finite(sh))return; let dx=0,dy=0; if(sx+sw>v.w-m)dx=v.w-m-(sx+sw); if(sx+dx{ } // A world point inside the visible area that does not sit on another node. function freeSpot(){ + heal(); const v=visible(),nodes=state.workflow?.nodes||[]; const c={x:(v.w/2-vp.x)/vp.zoom-NODE_W/2,y:(v.h/2-vp.y)/vp.zoom-NODE_H/2}; for(let i=0;i<24;i++){ diff --git a/web/app/flows.js b/web/app/flows.js index a52efd57c..1492bfb24 100644 --- a/web/app/flows.js +++ b/web/app/flows.js @@ -322,12 +322,23 @@ function flowNodeHTML(n,run,ro){ const outs=`
成功
`+(kind==='preview'?'':`
失败打回
`); return `
${tile}
${title}
${escapeHTML(m.subtitle)}
${status?`${statusText(status)||escapeHTML(status)}`:''}${ro?'':``}
${tags}
${outs}
`; } +// Drafts and old saves occasionally leave a node without usable coordinates; +// one of those poisons every transform and fit computed from the canvas, so +// park it on a grid slot instead. +function repairNodePositions(wf){ + (wf?.nodes||[]).forEach((n,i)=>{ + const p=n.position; + if(p&&Number.isFinite(p.x)&&Number.isFinite(p.y))return; + n.position={x:80+(i%4)*280,y:80+Math.floor(i/4)*170}; + }); +} function renderCanvas(){ const nodes=$('#nodes');if(!nodes)return; const wf=state.workflow,empty=$('#canvasEmpty'); flowNodeMetrics.cache?.clear(); if(!wf){nodes.innerHTML='';if(empty)empty.hidden=false;renderEdges();flowViewport.afterRender();return} if(empty)empty.hidden=(wf.nodes||[]).length>0; + repairNodePositions(wf); spreadCrowdedNodes(wf); const ro=flowReadOnly(); nodes.innerHTML=wf.nodes.map(n=>flowNodeHTML(n,state.activeRun,ro)).join(''); diff --git a/web/orchestrate.js b/web/orchestrate.js index 4cbab4177..d5941b7c5 100644 --- a/web/orchestrate.js +++ b/web/orchestrate.js @@ -581,7 +581,7 @@ function drainAIBuild() { } async function aiPlaceNode(build, node) { - if (!node.position) node.position = aiProvisionalPosition(build.placed.size); + if (!node.position || !Number.isFinite(node.position.x) || !Number.isFinite(node.position.y)) node.position = aiProvisionalPosition(build.placed.size); state.workflow.nodes.push(node); build.placed.set(node.id, node); build.spawned = (build.spawned || 0) + 1; @@ -805,7 +805,7 @@ function mergeAIEdit(base, incoming, goal, referenced) { if (normalized.id && normalized.id !== prev.id) idMap.set(normalized.id, prev.id); const merged = {...prev, ...normalized, id: prev.id}; if (!raw.script) merged.script = prev.script; - if (!raw.position || !Number.isFinite(raw.position.x)) merged.position = prev.position; + if (!raw.position || !Number.isFinite(raw.position.x) || !Number.isFinite(raw.position.y)) merged.position = prev.position; return merged; }); const known = new Set(nodes.map(node => node.id)); diff --git a/webtest/tests/flow-viewport-recovery.test.mjs b/webtest/tests/flow-viewport-recovery.test.mjs new file mode 100644 index 000000000..467f8fd29 --- /dev/null +++ b/webtest/tests/flow-viewport-recovery.test.mjs @@ -0,0 +1,65 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import { loadApp } from '../lib/load-app.mjs'; + +async function flowApp(t) { + const app = await loadApp(); + t.after(app.close); + app.evaluate(` + switchView('flow'); + state.workflow={...clone(state.data.workflows[0]),id:'viewport-flow',projectId:state.projectFilter, + nodes:[ + {id:'a',name:'A',type:'script',script:'echo a',position:{x:80,y:80},artifactOutputs:[],onFailure:'fail'}, + {id:'b',name:'B',type:'script',script:'echo b',position:{x:560,y:80},artifactOutputs:[],onFailure:'fail'} + ],edges:[{id:'e',source:'a',target:'b',when:'success'}], + sandboxProfileId:state.data.sandboxes[0]?.id||'local'}; + state.workflowDirty=false;renderCanvas(); + const c=document.getElementById('canvas'); + Object.defineProperty(c,'clientWidth',{configurable:true,value:960}); + Object.defineProperty(c,'clientHeight',{configurable:true,value:640}); + `); + return app; +} + +test('a non-finite viewport heals instead of freezing pan and zoom', async (t) => { + const app = await flowApp(t); + app.evaluate(`flowViewport._set({x:NaN,y:NaN,zoom:NaN});flowViewport.zoomBy(1.2)`); + const view = JSON.parse(app.evaluate(`JSON.stringify({ + x:flowViewport.x,y:flowViewport.y,zoom:flowViewport.zoom, + transform:document.getElementById('canvasStage').style.transform, + label:document.getElementById('canvasZoomValue').textContent})`)); + assert.ok(Number.isFinite(view.x) && Number.isFinite(view.y) && Number.isFinite(view.zoom)); + assert.doesNotMatch(view.transform, /NaN|Infinity/); + assert.match(view.transform, new RegExp(`scale\\(${view.zoom}\\)`)); + assert.equal(view.label, `${Math.round(view.zoom * 100)}%`); +}); + +test('freeSpot returns finite coordinates from a broken viewport', async (t) => { + const app = await flowApp(t); + app.evaluate(`flowViewport._set({x:NaN,y:NaN,zoom:NaN});window.__spot=flowViewport.freeSpot()`); + assert.equal(app.evaluate(`Number.isFinite(window.__spot.x)&&Number.isFinite(window.__spot.y)`), true); +}); + +test('a node with a broken position is repaired instead of freezing fit', async (t) => { + const app = await flowApp(t); + app.evaluate(` + state.workflow.nodes.push({id:'broken',name:'Broken',type:'script',script:'echo x',position:{x:NaN,y:NaN},artifactOutputs:[],onFailure:'fail'}); + state.workflow.edges.push({id:'e2',source:'b',target:'broken',when:'success'}); + renderCanvas(); + `); + assert.equal(app.evaluate(`state.workflow.nodes.every(n=>Number.isFinite(n.position.x)&&Number.isFinite(n.position.y))`), true); + assert.equal(app.evaluate(`/NaN|Infinity/.test([...document.querySelectorAll('#nodes .flow-node')].map(el=>el.getAttribute('style')).join(''))`), false); + app.evaluate(`flowViewport.fit({smooth:false})`); + assert.equal(app.evaluate(`[flowViewport.x,flowViewport.y,flowViewport.zoom].every(Number.isFinite)`), true); + assert.equal(app.evaluate(`/NaN|Infinity/.test(document.getElementById('canvasStage').style.transform)`), false); +}); + +test('AI edits keep a node position when the draft omits a coordinate', async (t) => { + const app = await flowApp(t); + const kept = app.evaluate(`(() => { + const base={id:'w',nodes:[{id:'A',name:'A',type:'agent',position:{x:10,y:20}}],edges:[]}; + const out=mergeAIEdit(base,{nodes:[{id:'A',name:'A',type:'agent',position:{x:99}}],edges:[]},'',[]); + return JSON.stringify(out.nodes[0].position); + })()`); + assert.equal(kept, '{"x":10,"y":20}'); +});