minerva-design 1.3.0 → 1.5.0

package/dist/charts/engine/graph/dag.cjs

@@ -0,0 +1,2 @@
+const e=require("./force.cjs");var t=(e,t)=>{if(e.length<2)return 0;e.sort((e,t)=>e[0]-t[0]||e[1]-t[1]);let n=new Int32Array(t+1),r=0,i=0;for(let[,a]of e){let e=0;for(let t=a+1;t>0;t-=t&-t)e+=n[t];r+=i-e;for(let e=a+1;e<=t;e+=e&-e)n[e]++;i++}return r},n=(e,n)=>{let r=new Map,i=new Map;e.forEach((e,t)=>e.forEach((e,n)=>{r.set(e,t),i.set(e,n)}));let a=e.map(()=>[]);for(let[e,t]of n){let n=r.get(e),o=r.get(t);n!==void 0&&o!==void 0&&(o===n+1?a[n].push([i.get(e),i.get(t)]):n===o+1&&a[o].push([i.get(t),i.get(e)]))}let o=0;return a.forEach((n,r)=>{r+1<e.length&&(o+=t(n,e[r+1].length))}),o},r=(e,t,n)=>{let r=new Float64Array(n),i=new Float64Array(n),a=new Int32Array(n),o=0;for(let s=0;s<n;s++)for(r[o]=t[s],i[o]=e[s],a[o]=1,o++;o>1&&i[o-2]>i[o-1];){let e=r[o-2]+r[o-1];i[o-2]=(i[o-2]*r[o-2]+i[o-1]*r[o-1])/e,r[o-2]=e,a[o-2]+=a[o-1],o--}let s=0;for(let t=0;t<o;t++)for(let n=0;n<a[t];n++)e[s++]=i[t]},i=e=>{let{n,direction:i}=e,a=i===`LR`||i===`RL`,o=a?e.height:e.width,s=a?e.width:e.height,c=e.source.length,l=Array.from({length:n},()=>[]),u=new Int32Array(n);for(let t=0;t<c;t++){let r=e.source[t],i=e.target[t];r===i||r<0||i<0||r>=n||i>=n||(l[r].push(t),u[i]++)}let d=new Uint8Array(c),f=new Uint8Array(n),p=t=>{let n=[[t,0]];for(f[t]=1;n.length;){let t=n[n.length-1],[r,i]=t;if(i>=l[r].length){f[r]=2,n.pop();continue}t[1]++;let a=l[r][i],o=e.target[a];f[o]===1?d[a]=1:f[o]===0&&(f[o]=1,n.push([o,0]))}};for(let e=0;e<n;e++)!u[e]&&!f[e]&&p(e);for(let e=0;e<n;e++)f[e]||p(e);let m=new Map,h=[],g=[],_=new Int32Array(c).fill(-1);for(let t=0;t<c;t++){let r=e.source[t],i=e.target[t];if(r===i||r<0||i<0||r>=n||i>=n)continue;let a=d[t]?i:r,o=d[t]?r:i,s=a*n+o,c=m.get(s);c===void 0&&(c=h.length,m.set(s,c),h.push(a),g.push(o)),_[t]=c}let v=h.length,y=Array.from({length:n},()=>[]),b=Array.from({length:n},()=>[]);for(let e=0;e<v;e++)y[h[e]].push(g[e]),b[g[e]].push(h[e]);let x=[],ee=Int32Array.from(b,e=>e.length);for(let e=0;e<n;e++)ee[e]||x.push(e);for(let e=0;e<x.length;e++)for(let t of y[x[e]])--ee[t]===0&&x.push(t);let S=new Int32Array(n);for(let e of x)for(let t of b[e])S[e]=Math.max(S[e],S[t]+1);let C=0;for(let e=0;e<n;e++)C=Math.max(C,S[e]);let w=new Int32Array(C+1);for(let e=0;e<n;e++)w[S[e]]++;for(let e=x.length-1;e>=0;e--){let t=x[e],n=0;for(let e of b[t])n=Math.max(n,S[e]+1);let r=C;for(let e of y[t])r=Math.min(r,S[e]-1);if(y[t].length||(r=S[t]),r<=n)continue;let i=b[t].length,a=y[t].length,o=S[t];if(a>i)o=r;else if(i>a)o=n;else for(let e=n;e<=r;e++)w[e]<w[o]-1&&(o=e);o!==S[t]&&(w[S[t]]--,w[o]++,S[t]=o)}let T=Array.from(S),E=Array.from({length:n},()=>[]),D=Array.from({length:n},()=>[]),O=Array.from({length:n},()=>[]),te=[],ne=(e,t,n)=>{D[e].push(t),E[t].push(e),O[t].push(n)};for(let e=0;e<v;e++){let t=h[e],r=g[e],i=[t],a=t;for(let e=S[t]+1;e<S[r];e++){let t=T.length;T.push(e),E.push([]),D.push([]),O.push([]),ne(a,t,a>=n?8:2),i.push(t),a=t}ne(a,r,a>=n?2:1),i.push(r),te.push(i)}let k=T.length,A=C+1,j=Array.from({length:A},()=>[]),M=new Uint8Array(k),N=e=>{M[e]||(M[e]=1,j[T[e]].push(e))},P=[],F=new Uint8Array(k),re=x.filter(e=>!E[e].length);for(let e of re.length?re:[0]){if(e>=k||F[e])continue;let t=[e];for(;t.length;){let e=t.pop();if(!F[e]){F[e]=1,P.push(e);for(let n=D[e].length-1;n>=0;n--)t.push(D[e][n])}}}for(let e of P)N(e);for(let e=0;e<k;e++)N(e);let I=new Float64Array(k),L=e=>e.forEach((e,t)=>I[e]=t);j.forEach(L);let R=()=>{let e=0;for(let n=0;n+1<A;n++){let r=[];for(let e of j[n])for(let t of D[e])r.push([I[e],I[t]]);e+=t(r,j[n+1].length)}return e},ie=R(),z=ie,B=j.map(e=>e.slice()),V=new Float64Array(k),H=(e,t,n)=>{let r=j[e];for(let e of r){let r=n?D[e]:E[e];if(!r.length){V[e]=-1;continue}if(t){let t=r.map(e=>I[e]).sort((e,t)=>e-t),n=t.length>>1;V[e]=t.length%2?t[n]:(t[n-1]+t[n])/2}else{let t=0;for(let e of r)t+=I[e];V[e]=t/r.length}}let i=r.map(e=>V[e]<0),a=r.filter(e=>V[e]>=0).sort((e,t)=>V[e]-V[t]||I[e]-I[t]),o=0;for(let e=0;e<r.length;e++)i[e]||(r[e]=a[o++]);L(r)},ae=Math.max(0,Math.floor(e.sweeps));for(let e=0;e<ae&&z>0;e++){let t=e%4>=2;if(e%2==0)for(let e=1;e<A;e++)H(e,t,!1);else for(let e=A-2;e>=0;e--)H(e,t,!0);let n=R();n<z&&(z=n,B=j.map(e=>e.slice()))}if(B.forEach((e,t)=>{j[t]=e,L(e)}),k<=3e3&&z>0){let e=(e,t)=>{let n=0;for(let r of[E,D])for(let i of r[e])for(let e of r[t])I[i]>I[e]&&n++;return n};for(let t=0,n=!0;n&&t<8;t++){n=!1;for(let t of j)for(let r=0;r+1<t.length;r++){let i=t[r],a=t[r+1];e(a,i)<e(i,a)&&(t[r]=a,t[r+1]=i,I[i]=r+1,I[a]=r,n=!0)}}z=R()}let U=e=>e<n?o[e]:0,W=(t,r)=>t<n&&r<n?e.nodeGap:e.nodeGap*.5,G=new Float64Array(k);for(let e of j){let t=0;e.forEach((n,r)=>{r&&(t+=(U(e[r-1])+U(n))/2+W(e[r-1],n)),G[n]=t});let n=t/2;for(let t of e)G[t]-=n}let K=new Float64Array(k),q=new Float64Array(k),J=new Float64Array(k),oe=Array.from({length:k},()=>[]);for(let e=0;e<k;e++)E[e].forEach((t,n)=>{oe[t][D[t].indexOf(e)]=O[e][n]});let Y=(e,t)=>{let n=e.length;if(n){for(let r=0;r<n;r++){let n=e[r],i=0,a=0;t!==`up`&&E[n].forEach((e,t)=>{i+=O[n][t],a+=O[n][t]*G[e]}),t!==`down`&&D[n].forEach((e,t)=>{let r=oe[n][t]??1;i+=r,a+=r*G[e]}),J[r]=r?J[r-1]+(U(e[r-1])+U(n))/2+W(e[r-1],n):0,K[r]=(i?a/i:G[n])-J[r],q[r]=i||.05}r(K,q,n);for(let t=0;t<n;t++)G[e[t]]=K[t]+J[t]}};for(let e=0;e<10;e++)if(e%2==0)for(let e=1;e<A;e++)Y(j[e],`down`);else for(let e=A-2;e>=0;e--)Y(j[e],`up`);for(let e=0;e<A;e++)Y(j[e],`both`);let X=new Float64Array(A);for(let e=0;e<n;e++)X[S[e]]=Math.max(X[S[e]],s[e]);let Z=new Float64Array(A);for(let t=1;t<A;t++)Z[t]=Z[t-1]+X[t-1]/2+e.layerGap+X[t]/2;let se=(e,t)=>{switch(i){case`BT`:return[e,-t];case`LR`:return[t,e];case`RL`:return[-t,e];default:return[e,t]}},ce=new Float64Array(n),le=new Float64Array(n);for(let e=0;e<n;e++){let[t,n]=se(G[e],Z[S[e]]);ce[e]=t,le[e]=n}let Q=[],$=[];for(let e=0;e<c;e++){let t=_[e];if(t<0){Q.push([]);continue}d[e]&&$.push(e);let n=te[t],r=[];if(n.forEach((e,t)=>{let i=Z[T[e]],a=i;t===0?a=i+s[e]/2:t===n.length-1&&(a=i-s[e]/2);let[o,c]=se(G[e],a);r.push(o,c)}),d[e]){let e=[];for(let t=r.length-2;t>=0;t-=2)e.push(r[t],r[t+1]);Q.push(e)}else Q.push(r)}return{x:ce,y:le,layer:S,order:j.map(e=>e.map(e=>e<n?e:-1-(e-n))),routes:Q,reversed:$,crossings:{initial:ie,final:z}}},a=(t,n,r={})=>{let{source:a,target:o,edge:s}=e.indexGraph(t,n),c=new Float64Array(t.length),l=new Float64Array(t.length);t.forEach((e,t)=>{let[n,i]=r.size?.(e,t)??[24,24];c[t]=n,l[t]=i});let u=i({n:t.length,source:a,target:o,width:c,height:l,direction:r.direction??`TB`,layerGap:r.layerGap??56,nodeGap:r.nodeGap??24,sweeps:r.sweeps??8}),d=n.map(()=>[]);return s.forEach((e,t)=>d[e]=u.routes[t]),{...u,routes:d,reversed:u.reversed.map(e=>s[e])}},o=(e,t,n,r)=>{let i=t.length,a=Array.from({length:e},()=>[]),o=new Int32Array(e);for(let e=0;e<i;e++)t[e]!==n[e]&&(a[t[e]].push(e),o[n[e]]++);let s=[];for(let t=0;t<e;t++)o[t]||s.push(t);for(let e=0;e<s.length;e++)for(let t of a[s[e]])--o[n[t]]===0&&s.push(n[t]);let c=new Float64Array(e),l=new Int32Array(e).fill(-1),u=new Uint8Array(e);for(let e of s){u[e]=1,c[e]+=r(e);for(let t of a[e]){let r=n[t];c[e]>c[r]&&(c[r]=c[e],l[r]=t)}}let d=-1;for(let e of s)(d<0||c[e]>c[d])&&(d=e);if(d<0)return{nodes:[],edges:[],length:0};let f=[d],p=[];for(let e=d;l[e]>=0&&u[t[l[e]]];)p.push(l[e]),e=t[l[e]],f.push(e);return{nodes:f.reverse(),edges:p.reverse(),length:c[d]}},s=(t,n)=>{let{source:r,target:i,edge:a}=e.indexGraph(t,n),s=o(t.length,r,i,e=>{let n=t[e].value;return Number.isFinite(n)&&n>=0?n:1});return{nodes:s.nodes.map(e=>t[e].id),edges:s.edges.map(e=>a[e]),length:s.length}};exports.countCrossings=n,exports.criticalPath=s,exports.dagLayout=a,exports.layeredLayout=i,exports.longestPath=o;
+//# sourceMappingURL=dag.cjs.map

package/dist/charts/engine/graph/dag.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag.cjs","names":["indexGraph","require_force","bilayerCrossings","edges","a","b","tree","lowerSize","crossings","seen","q","le","i","countCrossings","layerOf","pos","order","layer","v","l","between","la","lb","total","list","isotonic","blockW","count","blockV","blockN","top","weight","target","w","k","layeredLayout","input","horizontal","direction","breadth","depth","E","out","indeg","e","s","t","reversedEdge","color","visit","stack","start","pairKey","accA","accB","chainOf","key","id","A","succ","pred","topo","remaining","p","u","maxLayer","layerCount","lo","hi","ins","outs","best","vLayer","vPred","vSucc","vWeight","chains","link","chain","prev","d","N","L","layers","placed","place","firstOrder","roots","r","updatePos","totalCrossings","pairs","initial","bestLayers","reorder","nb","up","useMedian","mid","fixedSlots","movable","sweeps","median","c","pairCrossings","pass","improved","size","gapOf","bx","cursor","shift","offset","succWeight","align","sw","sx","mode","iter","layerDepth","layerPos","toOut","x","y","px","py","routes","reversed","pts","dd","flipped","dagLayout","nodes","width","height","h","options","node","result","edge","longestPath","source","n","dist","via","inOrder","duration","end","criticalPath"],"sources":["../../../../../charts/src/engine/graph/dag.ts"],"sourcesContent":["// Layered (Sugiyama) layout of directed graphs: cycle breaking (DFS),\n// longest-path layering with a balancing pass, dummy nodes on long edges,\n// barycenter / median crossing reduction with transposition, and\n// coordinate assignment by weighted isotonic regression (long edges stay\n// straight). Index-based core + id-based public wrappers, no DOM.\n\nimport { indexGraph } from \"./force\";\nimport type {\n  GraphDagLayoutOptions,\n  GraphDagLayoutResult,\n  GraphCriticalPath,\n  GraphDirection,\n  GraphEdge,\n  GraphNode,\n} from \"./types\";\n\nexport interface LayeredInput {\n  n: number;\n  source: ArrayLike<number>;\n  target: ArrayLike<number>;\n  /** Width / height of each node */\n  width: ArrayLike<number>;\n  height: ArrayLike<number>;\n  direction: GraphDirection;\n  layerGap: number;\n  nodeGap: number;\n  sweeps: number;\n}\n\n/** Crossings between two consecutive layers (Fenwick tree, O(E log V)) */\nconst bilayerCrossings = (\n  edges: [number, number][],\n  lowerSize: number,\n): number => {\n  if (edges.length < 2) return 0;\n  edges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n  const tree = new Int32Array(lowerSize + 1);\n  let crossings = 0;\n  let seen = 0;\n  for (const [, q] of edges) {\n    // edges already inserted that end to the right of q\n    let le = 0;\n    for (let i = q + 1; i > 0; i -= i & -i) le += tree[i];\n    crossings += seen - le;\n    for (let i = q + 1; i <= lowerSize; i += i & -i) tree[i]++;\n    seen++;\n  }\n  return crossings;\n};\n\n/**\n * Edge crossings of a layered drawing: `order[l]` lists the nodes of layer\n * `l` from left to right, `edges` are `[a, b]` pairs between consecutive\n * layers (other pairs are ignored)\n */\nexport const countCrossings = (\n  order: readonly (readonly number[])[],\n  edges: readonly (readonly [number, number])[],\n): number => {\n  const layerOf = new Map<number, number>();\n  const pos = new Map<number, number>();\n  order.forEach((layer, l) =>\n    layer.forEach((v, i) => {\n      layerOf.set(v, l);\n      pos.set(v, i);\n    }),\n  );\n  const between: [number, number][][] = order.map(() => []);\n  for (const [a, b] of edges) {\n    const la = layerOf.get(a);\n    const lb = layerOf.get(b);\n    if (la === undefined || lb === undefined) continue;\n    if (lb === la + 1) between[la].push([pos.get(a)!, pos.get(b)!]);\n    else if (la === lb + 1) between[lb].push([pos.get(b)!, pos.get(a)!]);\n  }\n  let total = 0;\n  between.forEach((list, l) => {\n    if (l + 1 < order.length)\n      total += bilayerCrossings(list, order[l + 1].length);\n  });\n  return total;\n};\n\n/** Weighted isotonic regression (pool adjacent violators), in place */\nconst isotonic = (\n  target: Float64Array,\n  weight: Float64Array,\n  count: number,\n): void => {\n  const blockW = new Float64Array(count);\n  const blockV = new Float64Array(count);\n  const blockN = new Int32Array(count);\n  let top = 0;\n  for (let i = 0; i < count; i++) {\n    blockW[top] = weight[i];\n    blockV[top] = target[i];\n    blockN[top] = 1;\n    top++;\n    while (top > 1 && blockV[top - 2] > blockV[top - 1]) {\n      const w = blockW[top - 2] + blockW[top - 1];\n      blockV[top - 2] =\n        (blockV[top - 2] * blockW[top - 2] +\n          blockV[top - 1] * blockW[top - 1]) /\n        w;\n      blockW[top - 2] = w;\n      blockN[top - 2] += blockN[top - 1];\n      top--;\n    }\n  }\n  let i = 0;\n  for (let b = 0; b < top; b++) {\n    for (let k = 0; k < blockN[b]; k++) target[i++] = blockV[b];\n  }\n};\n\n/** The layered layout on index data */\nexport const layeredLayout = (input: LayeredInput): GraphDagLayoutResult => {\n  const { n, direction } = input;\n  const horizontal = direction === \"LR\" || direction === \"RL\";\n  const breadth = horizontal ? input.height : input.width;\n  const depth = horizontal ? input.width : input.height;\n  const E = input.source.length;\n\n  // ---------------------------------------------------- 1. cycles\n  const out: number[][] = Array.from({ length: n }, () => []);\n  const indeg = new Int32Array(n);\n  for (let e = 0; e < E; e++) {\n    const s = input.source[e];\n    const t = input.target[e];\n    if (s === t || s < 0 || t < 0 || s >= n || t >= n) continue;\n    out[s].push(e);\n    indeg[t]++;\n  }\n  const reversedEdge = new Uint8Array(E);\n  const color = new Uint8Array(n);\n  const visit = (start: number) => {\n    const stack: [number, number][] = [[start, 0]];\n    color[start] = 1;\n    while (stack.length) {\n      const top = stack[stack.length - 1];\n      const [v, k] = top;\n      if (k >= out[v].length) {\n        color[v] = 2;\n        stack.pop();\n        continue;\n      }\n      top[1]++;\n      const e = out[v][k];\n      const w = input.target[e];\n      if (color[w] === 1) reversedEdge[e] = 1;\n      else if (color[w] === 0) {\n        color[w] = 1;\n        stack.push([w, 0]);\n      }\n    }\n  };\n  for (let v = 0; v < n; v++) if (!indeg[v] && !color[v]) visit(v);\n  for (let v = 0; v < n; v++) if (!color[v]) visit(v);\n\n  // acyclic, deduplicated edges\n  const pairKey = new Map<number, number>();\n  const accA: number[] = [];\n  const accB: number[] = [];\n  const chainOf = new Int32Array(E).fill(-1);\n  for (let e = 0; e < E; e++) {\n    const s = input.source[e];\n    const t = input.target[e];\n    if (s === t || s < 0 || t < 0 || s >= n || t >= n) continue;\n    const a = reversedEdge[e] ? t : s;\n    const b = reversedEdge[e] ? s : t;\n    const key = a * n + b;\n    let id = pairKey.get(key);\n    if (id === undefined) {\n      id = accA.length;\n      pairKey.set(key, id);\n      accA.push(a);\n      accB.push(b);\n    }\n    chainOf[e] = id;\n  }\n  const A = accA.length;\n\n  // ---------------------------------------------------- 2. layers\n  const succ: number[][] = Array.from({ length: n }, () => []);\n  const pred: number[][] = Array.from({ length: n }, () => []);\n  for (let k = 0; k < A; k++) {\n    succ[accA[k]].push(accB[k]);\n    pred[accB[k]].push(accA[k]);\n  }\n  const topo: number[] = [];\n  const remaining = Int32Array.from(pred, (p) => p.length);\n  for (let v = 0; v < n; v++) if (!remaining[v]) topo.push(v);\n  for (let i = 0; i < topo.length; i++) {\n    for (const w of succ[topo[i]]) if (--remaining[w] === 0) topo.push(w);\n  }\n  const layer = new Int32Array(n);\n  for (const v of topo) {\n    for (const u of pred[v]) layer[v] = Math.max(layer[v], layer[u] + 1);\n  }\n  let maxLayer = 0;\n  for (let v = 0; v < n; v++) maxLayer = Math.max(maxLayer, layer[v]);\n  const layerCount = new Int32Array(maxLayer + 1);\n  for (let v = 0; v < n; v++) layerCount[layer[v]]++;\n  // balancing: move nodes within their feasible range (shorter edges, then emptier layers)\n  for (let i = topo.length - 1; i >= 0; i--) {\n    const v = topo[i];\n    let lo = 0;\n    for (const u of pred[v]) lo = Math.max(lo, layer[u] + 1);\n    let hi = maxLayer;\n    for (const w of succ[v]) hi = Math.min(hi, layer[w] - 1);\n    if (!succ[v].length) hi = layer[v];\n    if (hi <= lo) continue;\n    const ins = pred[v].length;\n    const outs = succ[v].length;\n    let best = layer[v];\n    if (outs > ins) best = hi;\n    else if (ins > outs) best = lo;\n    else {\n      for (let l = lo; l <= hi; l++) {\n        if (layerCount[l] < layerCount[best] - 1) best = l;\n      }\n    }\n    if (best !== layer[v]) {\n      layerCount[layer[v]]--;\n      layerCount[best]++;\n      layer[v] = best;\n    }\n  }\n\n  // ---------------------------------------------------- 3. dummies\n  // virtual nodes: 0..n-1 real, n.. dummies\n  const vLayer: number[] = Array.from(layer);\n  const vPred: number[][] = Array.from({ length: n }, () => []);\n  const vSucc: number[][] = Array.from({ length: n }, () => []);\n  const vWeight: number[][] = Array.from({ length: n }, () => []);\n  const chains: number[][] = [];\n  const link = (p: number, q: number, w: number) => {\n    vSucc[p].push(q);\n    vPred[q].push(p);\n    vWeight[q].push(w);\n  };\n  for (let k = 0; k < A; k++) {\n    const a = accA[k];\n    const b = accB[k];\n    const chain: number[] = [a];\n    let prev = a;\n    for (let l = layer[a] + 1; l < layer[b]; l++) {\n      const d = vLayer.length;\n      vLayer.push(l);\n      vPred.push([]);\n      vSucc.push([]);\n      vWeight.push([]);\n      link(prev, d, prev >= n ? 8 : 2);\n      chain.push(d);\n      prev = d;\n    }\n    link(prev, b, prev >= n ? 2 : 1);\n    chain.push(b);\n    chains.push(chain);\n  }\n  const N = vLayer.length;\n  const L = maxLayer + 1;\n\n  // ---------------------------------------------------- 4. ordering\n  const layers: number[][] = Array.from({ length: L }, () => []);\n  const placed = new Uint8Array(N);\n  const place = (v: number) => {\n    if (placed[v]) return;\n    placed[v] = 1;\n    layers[vLayer[v]].push(v);\n  };\n  // depth-first from the sources keeps related nodes together\n  const firstOrder: number[] = [];\n  const seen = new Uint8Array(N);\n  const roots = topo.filter((v) => !vPred[v].length);\n  for (const r of roots.length ? roots : [0]) {\n    if (r >= N || seen[r]) continue;\n    const stack = [r];\n    while (stack.length) {\n      const v = stack.pop()!;\n      if (seen[v]) continue;\n      seen[v] = 1;\n      firstOrder.push(v);\n      for (let k = vSucc[v].length - 1; k >= 0; k--) stack.push(vSucc[v][k]);\n    }\n  }\n  for (const v of firstOrder) place(v);\n  for (let v = 0; v < N; v++) place(v);\n\n  const pos = new Float64Array(N);\n  const updatePos = (list: number[]) => list.forEach((v, i) => (pos[v] = i));\n  layers.forEach(updatePos);\n\n  const totalCrossings = () => {\n    let total = 0;\n    for (let l = 0; l + 1 < L; l++) {\n      const pairs: [number, number][] = [];\n      for (const v of layers[l])\n        for (const w of vSucc[v]) pairs.push([pos[v], pos[w]]);\n      total += bilayerCrossings(pairs, layers[l + 1].length);\n    }\n    return total;\n  };\n\n  const initial = totalCrossings();\n  let best = initial;\n  let bestLayers = layers.map((l) => l.slice());\n  const key = new Float64Array(N);\n  const reorder = (l: number, useMedian: boolean, up: boolean) => {\n    const list = layers[l];\n    for (const v of list) {\n      const nb = up ? vSucc[v] : vPred[v];\n      if (!nb.length) {\n        key[v] = -1;\n        continue;\n      }\n      if (useMedian) {\n        const p = nb.map((w) => pos[w]).sort((a, b) => a - b);\n        const mid = p.length >> 1;\n        key[v] = p.length % 2 ? p[mid] : (p[mid - 1] + p[mid]) / 2;\n      } else {\n        let s = 0;\n        for (const w of nb) s += pos[w];\n        key[v] = s / nb.length;\n      }\n    }\n    // nodes without neighbors keep their slot\n    const fixedSlots = list.map((v) => key[v] < 0);\n    const movable = list\n      .filter((v) => key[v] >= 0)\n      .sort((a, b) => key[a] - key[b] || pos[a] - pos[b]);\n    let k = 0;\n    for (let i = 0; i < list.length; i++) {\n      if (!fixedSlots[i]) list[i] = movable[k++];\n    }\n    updatePos(list);\n  };\n\n  const sweeps = Math.max(0, Math.floor(input.sweeps));\n  for (let s = 0; s < sweeps && best > 0; s++) {\n    const median = s % 4 >= 2;\n    if (s % 2 === 0) for (let l = 1; l < L; l++) reorder(l, median, false);\n    else for (let l = L - 2; l >= 0; l--) reorder(l, median, true);\n    const c = totalCrossings();\n    if (c < best) {\n      best = c;\n      bestLayers = layers.map((l) => l.slice());\n    }\n  }\n  bestLayers.forEach((list, l) => {\n    layers[l] = list;\n    updatePos(list);\n  });\n\n  // transposition of neighbors while it helps (small graphs)\n  if (N <= 3000 && best > 0) {\n    const pairCrossings = (u: number, v: number) => {\n      let c = 0;\n      for (const nb of [vPred, vSucc]) {\n        for (const a of nb[u]) for (const b of nb[v]) if (pos[a] > pos[b]) c++;\n      }\n      return c;\n    };\n    for (let pass = 0, improved = true; improved && pass < 8; pass++) {\n      improved = false;\n      for (const list of layers) {\n        for (let i = 0; i + 1 < list.length; i++) {\n          const u = list[i];\n          const v = list[i + 1];\n          if (pairCrossings(v, u) < pairCrossings(u, v)) {\n            list[i] = v;\n            list[i + 1] = u;\n            pos[u] = i + 1;\n            pos[v] = i;\n            improved = true;\n          }\n        }\n      }\n    }\n    best = totalCrossings();\n  }\n\n  // ---------------------------------------------------- 5. coordinates\n  const size = (v: number) => (v < n ? breadth[v] : 0);\n  const gapOf = (a: number, b: number) =>\n    a < n && b < n ? input.nodeGap : input.nodeGap * 0.5;\n  const bx = new Float64Array(N);\n  for (const list of layers) {\n    let cursor = 0;\n    list.forEach((v, i) => {\n      if (i)\n        cursor += (size(list[i - 1]) + size(v)) / 2 + gapOf(list[i - 1], v);\n      bx[v] = cursor;\n    });\n    const shift = cursor / 2;\n    for (const v of list) bx[v] -= shift;\n  }\n  const target = new Float64Array(N);\n  const weight = new Float64Array(N);\n  const offset = new Float64Array(N);\n  // weights of the edges seen from both ends\n  const succWeight: number[][] = Array.from({ length: N }, () => []);\n  for (let q = 0; q < N; q++) {\n    vPred[q].forEach((p, k) => {\n      succWeight[p][vSucc[p].indexOf(q)] = vWeight[q][k];\n    });\n  }\n  const align = (list: number[], mode: \"down\" | \"up\" | \"both\") => {\n    const count = list.length;\n    if (!count) return;\n    for (let i = 0; i < count; i++) {\n      const v = list[i];\n      let sw = 0;\n      let sx = 0;\n      if (mode !== \"up\") {\n        vPred[v].forEach((p, k) => {\n          sw += vWeight[v][k];\n          sx += vWeight[v][k] * bx[p];\n        });\n      }\n      if (mode !== \"down\") {\n        vSucc[v].forEach((q, k) => {\n          const w = succWeight[v][k] ?? 1;\n          sw += w;\n          sx += w * bx[q];\n        });\n      }\n      offset[i] = i\n        ? offset[i - 1] +\n          (size(list[i - 1]) + size(v)) / 2 +\n          gapOf(list[i - 1], v)\n        : 0;\n      target[i] = (sw ? sx / sw : bx[v]) - offset[i];\n      weight[i] = sw || 0.05;\n    }\n    isotonic(target, weight, count);\n    for (let i = 0; i < count; i++) bx[list[i]] = target[i] + offset[i];\n  };\n  for (let iter = 0; iter < 10; iter++) {\n    if (iter % 2 === 0) for (let l = 1; l < L; l++) align(layers[l], \"down\");\n    else for (let l = L - 2; l >= 0; l--) align(layers[l], \"up\");\n  }\n  for (let l = 0; l < L; l++) align(layers[l], \"both\");\n\n  // layer depths\n  const layerDepth = new Float64Array(L);\n  for (let v = 0; v < n; v++)\n    layerDepth[layer[v]] = Math.max(layerDepth[layer[v]], depth[v]);\n  const layerPos = new Float64Array(L);\n  for (let l = 1; l < L; l++) {\n    layerPos[l] =\n      layerPos[l - 1] +\n      layerDepth[l - 1] / 2 +\n      input.layerGap +\n      layerDepth[l] / 2;\n  }\n\n  // ---------------------------------------------------- 6. output\n  const toOut = (b: number, d: number): [number, number] => {\n    switch (direction) {\n      case \"BT\":\n        return [b, -d];\n      case \"LR\":\n        return [d, b];\n      case \"RL\":\n        return [-d, b];\n      default:\n        return [b, d];\n    }\n  };\n  const x = new Float64Array(n);\n  const y = new Float64Array(n);\n  for (let v = 0; v < n; v++) {\n    const [px, py] = toOut(bx[v], layerPos[layer[v]]);\n    x[v] = px;\n    y[v] = py;\n  }\n  const routes: number[][] = [];\n  const reversed: number[] = [];\n  for (let e = 0; e < E; e++) {\n    const id = chainOf[e];\n    if (id < 0) {\n      routes.push([]);\n      continue;\n    }\n    if (reversedEdge[e]) reversed.push(e);\n    const chain = chains[id];\n    const pts: number[] = [];\n    chain.forEach((v, i) => {\n      const d = layerPos[vLayer[v]];\n      let dd = d;\n      if (i === 0) dd = d + depth[v] / 2;\n      else if (i === chain.length - 1) dd = d - depth[v] / 2;\n      const [px, py] = toOut(bx[v], dd);\n      pts.push(px, py);\n    });\n    if (reversedEdge[e]) {\n      const flipped: number[] = [];\n      for (let i = pts.length - 2; i >= 0; i -= 2)\n        flipped.push(pts[i], pts[i + 1]);\n      routes.push(flipped);\n    } else {\n      routes.push(pts);\n    }\n  }\n  const order = layers.map((list) =>\n    list.map((v) => (v < n ? v : -1 - (v - n))),\n  );\n  return {\n    x,\n    y,\n    layer,\n    order,\n    routes,\n    reversed,\n    crossings: { initial, final: best },\n  };\n};\n\n/** Layered (Sugiyama) layout of a directed graph */\nexport const dagLayout = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options: GraphDagLayoutOptions = {},\n): GraphDagLayoutResult => {\n  const { source, target, edge } = indexGraph(nodes, edges);\n  const width = new Float64Array(nodes.length);\n  const height = new Float64Array(nodes.length);\n  nodes.forEach((node, i) => {\n    const [w, h] = options.size?.(node, i) ?? [24, 24];\n    width[i] = w;\n    height[i] = h;\n  });\n  const result = layeredLayout({\n    n: nodes.length,\n    source,\n    target,\n    width,\n    height,\n    direction: options.direction ?? \"TB\",\n    layerGap: options.layerGap ?? 56,\n    nodeGap: options.nodeGap ?? 24,\n    sweeps: options.sweeps ?? 8,\n  });\n  // routes / reversed indices of the input edges\n  const routes: number[][] = edges.map(() => []);\n  edge.forEach((k, i) => (routes[k] = result.routes[i]));\n  return {\n    ...result,\n    routes,\n    reversed: result.reversed.map((i) => edge[i]),\n  };\n};\n\n/** Index version of `criticalPath` */\nexport const longestPath = (\n  n: number,\n  source: ArrayLike<number>,\n  target: ArrayLike<number>,\n  duration: (i: number) => number,\n): { nodes: number[]; edges: number[]; length: number } => {\n  const E = source.length;\n  const out: number[][] = Array.from({ length: n }, () => []);\n  const indeg = new Int32Array(n);\n  for (let e = 0; e < E; e++) {\n    if (source[e] === target[e]) continue;\n    out[source[e]].push(e);\n    indeg[target[e]]++;\n  }\n  const order: number[] = [];\n  for (let v = 0; v < n; v++) if (!indeg[v]) order.push(v);\n  for (let i = 0; i < order.length; i++) {\n    for (const e of out[order[i]])\n      if (--indeg[target[e]] === 0) order.push(target[e]);\n  }\n  const dist = new Float64Array(n);\n  const via = new Int32Array(n).fill(-1);\n  const inOrder = new Uint8Array(n);\n  for (const v of order) {\n    inOrder[v] = 1;\n    dist[v] += duration(v);\n    for (const e of out[v]) {\n      const w = target[e];\n      if (dist[v] > dist[w]) {\n        dist[w] = dist[v];\n        via[w] = e;\n      }\n    }\n  }\n  let end = -1;\n  for (const v of order) if (end < 0 || dist[v] > dist[end]) end = v;\n  if (end < 0) return { nodes: [], edges: [], length: 0 };\n  const nodes: number[] = [end];\n  const edges: number[] = [];\n  for (let v = end; via[v] >= 0 && inOrder[source[via[v]]];) {\n    edges.push(via[v]);\n    v = source[via[v]];\n    nodes.push(v);\n  }\n  return { nodes: nodes.reverse(), edges: edges.reverse(), length: dist[end] };\n};\n\n/**\n * Critical path of a DAG: the chain of tasks with the largest total\n * duration (node `value`, 1 when omitted). Nodes on cycles are ignored.\n */\nexport const criticalPath = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n): GraphCriticalPath => {\n  const { source, target, edge } = indexGraph(nodes, edges);\n  const result = longestPath(nodes.length, source, target, (i) => {\n    const v = nodes[i].value;\n    return Number.isFinite(v) && v! >= 0 ? v! : 1;\n  });\n  return {\n    nodes: result.nodes.map((i) => nodes[i].id),\n    edges: result.edges.map((i) => edge[i]),\n    length: result.length,\n  };\n};\n"],"mappings":"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"}

package/dist/charts/engine/graph/dag.d.cts

@@ -0,0 +1,34 @@
+import { GraphDagLayoutOptions, GraphDagLayoutResult, GraphCriticalPath, GraphDirection, GraphEdge, GraphNode } from './types.cjs';
+export interface LayeredInput {
+    n: number;
+    source: ArrayLike<number>;
+    target: ArrayLike<number>;
+    /** Width / height of each node */
+    width: ArrayLike<number>;
+    height: ArrayLike<number>;
+    direction: GraphDirection;
+    layerGap: number;
+    nodeGap: number;
+    sweeps: number;
+}
+/**
+ * Edge crossings of a layered drawing: `order[l]` lists the nodes of layer
+ * `l` from left to right, `edges` are `[a, b]` pairs between consecutive
+ * layers (other pairs are ignored)
+ */
+export declare const countCrossings: (order: readonly (readonly number[])[], edges: readonly (readonly [number, number])[]) => number;
+/** The layered layout on index data */
+export declare const layeredLayout: (input: LayeredInput) => GraphDagLayoutResult;
+/** Layered (Sugiyama) layout of a directed graph */
+export declare const dagLayout: (nodes: readonly GraphNode[], edges: readonly GraphEdge[], options?: GraphDagLayoutOptions) => GraphDagLayoutResult;
+/** Index version of `criticalPath` */
+export declare const longestPath: (n: number, source: ArrayLike<number>, target: ArrayLike<number>, duration: (i: number) => number) => {
+    nodes: number[];
+    edges: number[];
+    length: number;
+};
+/**
+ * Critical path of a DAG: the chain of tasks with the largest total
+ * duration (node `value`, 1 when omitted). Nodes on cycles are ignored.
+ */
+export declare const criticalPath: (nodes: readonly GraphNode[], edges: readonly GraphEdge[]) => GraphCriticalPath;

package/dist/charts/engine/graph/dag.d.ts

@@ -0,0 +1,34 @@
+import { GraphDagLayoutOptions, GraphDagLayoutResult, GraphCriticalPath, GraphDirection, GraphEdge, GraphNode } from './types.js';
+export interface LayeredInput {
+    n: number;
+    source: ArrayLike<number>;
+    target: ArrayLike<number>;
+    /** Width / height of each node */
+    width: ArrayLike<number>;
+    height: ArrayLike<number>;
+    direction: GraphDirection;
+    layerGap: number;
+    nodeGap: number;
+    sweeps: number;
+}
+/**
+ * Edge crossings of a layered drawing: `order[l]` lists the nodes of layer
+ * `l` from left to right, `edges` are `[a, b]` pairs between consecutive
+ * layers (other pairs are ignored)
+ */
+export declare const countCrossings: (order: readonly (readonly number[])[], edges: readonly (readonly [number, number])[]) => number;
+/** The layered layout on index data */
+export declare const layeredLayout: (input: LayeredInput) => GraphDagLayoutResult;
+/** Layered (Sugiyama) layout of a directed graph */
+export declare const dagLayout: (nodes: readonly GraphNode[], edges: readonly GraphEdge[], options?: GraphDagLayoutOptions) => GraphDagLayoutResult;
+/** Index version of `criticalPath` */
+export declare const longestPath: (n: number, source: ArrayLike<number>, target: ArrayLike<number>, duration: (i: number) => number) => {
+    nodes: number[];
+    edges: number[];
+    length: number;
+};
+/**
+ * Critical path of a DAG: the chain of tasks with the largest total
+ * duration (node `value`, 1 when omitted). Nodes on cycles are ignored.
+ */
+export declare const criticalPath: (nodes: readonly GraphNode[], edges: readonly GraphEdge[]) => GraphCriticalPath;

package/dist/charts/engine/graph/dag.js

@@ -0,0 +1,314 @@
+import { indexGraph as e } from "./force.js";
+//#region src/engine/graph/dag.ts
+var t = (e, t) => {
+	if (e.length < 2) return 0;
+	e.sort((e, t) => e[0] - t[0] || e[1] - t[1]);
+	let n = new Int32Array(t + 1), r = 0, i = 0;
+	for (let [, a] of e) {
+		let e = 0;
+		for (let t = a + 1; t > 0; t -= t & -t) e += n[t];
+		r += i - e;
+		for (let e = a + 1; e <= t; e += e & -e) n[e]++;
+		i++;
+	}
+	return r;
+}, n = (e, n) => {
+	let r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+	e.forEach((e, t) => e.forEach((e, n) => {
+		r.set(e, t), i.set(e, n);
+	}));
+	let a = e.map(() => []);
+	for (let [e, t] of n) {
+		let n = r.get(e), o = r.get(t);
+		n !== void 0 && o !== void 0 && (o === n + 1 ? a[n].push([i.get(e), i.get(t)]) : n === o + 1 && a[o].push([i.get(t), i.get(e)]));
+	}
+	let o = 0;
+	return a.forEach((n, r) => {
+		r + 1 < e.length && (o += t(n, e[r + 1].length));
+	}), o;
+}, r = (e, t, n) => {
+	let r = new Float64Array(n), i = new Float64Array(n), a = new Int32Array(n), o = 0;
+	for (let s = 0; s < n; s++) for (r[o] = t[s], i[o] = e[s], a[o] = 1, o++; o > 1 && i[o - 2] > i[o - 1];) {
+		let e = r[o - 2] + r[o - 1];
+		i[o - 2] = (i[o - 2] * r[o - 2] + i[o - 1] * r[o - 1]) / e, r[o - 2] = e, a[o - 2] += a[o - 1], o--;
+	}
+	let s = 0;
+	for (let t = 0; t < o; t++) for (let n = 0; n < a[t]; n++) e[s++] = i[t];
+}, i = (e) => {
+	let { n, direction: i } = e, a = i === "LR" || i === "RL", o = a ? e.height : e.width, s = a ? e.width : e.height, c = e.source.length, l = Array.from({ length: n }, () => []), u = new Int32Array(n);
+	for (let t = 0; t < c; t++) {
+		let r = e.source[t], i = e.target[t];
+		r === i || r < 0 || i < 0 || r >= n || i >= n || (l[r].push(t), u[i]++);
+	}
+	let d = new Uint8Array(c), f = new Uint8Array(n), p = (t) => {
+		let n = [[t, 0]];
+		for (f[t] = 1; n.length;) {
+			let t = n[n.length - 1], [r, i] = t;
+			if (i >= l[r].length) {
+				f[r] = 2, n.pop();
+				continue;
+			}
+			t[1]++;
+			let a = l[r][i], o = e.target[a];
+			f[o] === 1 ? d[a] = 1 : f[o] === 0 && (f[o] = 1, n.push([o, 0]));
+		}
+	};
+	for (let e = 0; e < n; e++) !u[e] && !f[e] && p(e);
+	for (let e = 0; e < n; e++) f[e] || p(e);
+	let m = /* @__PURE__ */ new Map(), h = [], g = [], _ = new Int32Array(c).fill(-1);
+	for (let t = 0; t < c; t++) {
+		let r = e.source[t], i = e.target[t];
+		if (r === i || r < 0 || i < 0 || r >= n || i >= n) continue;
+		let a = d[t] ? i : r, o = d[t] ? r : i, s = a * n + o, c = m.get(s);
+		c === void 0 && (c = h.length, m.set(s, c), h.push(a), g.push(o)), _[t] = c;
+	}
+	let v = h.length, y = Array.from({ length: n }, () => []), b = Array.from({ length: n }, () => []);
+	for (let e = 0; e < v; e++) y[h[e]].push(g[e]), b[g[e]].push(h[e]);
+	let x = [], ee = Int32Array.from(b, (e) => e.length);
+	for (let e = 0; e < n; e++) ee[e] || x.push(e);
+	for (let e = 0; e < x.length; e++) for (let t of y[x[e]]) --ee[t] === 0 && x.push(t);
+	let S = new Int32Array(n);
+	for (let e of x) for (let t of b[e]) S[e] = Math.max(S[e], S[t] + 1);
+	let C = 0;
+	for (let e = 0; e < n; e++) C = Math.max(C, S[e]);
+	let w = new Int32Array(C + 1);
+	for (let e = 0; e < n; e++) w[S[e]]++;
+	for (let e = x.length - 1; e >= 0; e--) {
+		let t = x[e], n = 0;
+		for (let e of b[t]) n = Math.max(n, S[e] + 1);
+		let r = C;
+		for (let e of y[t]) r = Math.min(r, S[e] - 1);
+		if (y[t].length || (r = S[t]), r <= n) continue;
+		let i = b[t].length, a = y[t].length, o = S[t];
+		if (a > i) o = r;
+		else if (i > a) o = n;
+		else for (let e = n; e <= r; e++) w[e] < w[o] - 1 && (o = e);
+		o !== S[t] && (w[S[t]]--, w[o]++, S[t] = o);
+	}
+	let T = Array.from(S), E = Array.from({ length: n }, () => []), D = Array.from({ length: n }, () => []), O = Array.from({ length: n }, () => []), te = [], ne = (e, t, n) => {
+		D[e].push(t), E[t].push(e), O[t].push(n);
+	};
+	for (let e = 0; e < v; e++) {
+		let t = h[e], r = g[e], i = [t], a = t;
+		for (let e = S[t] + 1; e < S[r]; e++) {
+			let t = T.length;
+			T.push(e), E.push([]), D.push([]), O.push([]), ne(a, t, a >= n ? 8 : 2), i.push(t), a = t;
+		}
+		ne(a, r, a >= n ? 2 : 1), i.push(r), te.push(i);
+	}
+	let k = T.length, A = C + 1, j = Array.from({ length: A }, () => []), M = new Uint8Array(k), N = (e) => {
+		M[e] || (M[e] = 1, j[T[e]].push(e));
+	}, P = [], F = new Uint8Array(k), re = x.filter((e) => !E[e].length);
+	for (let e of re.length ? re : [0]) {
+		if (e >= k || F[e]) continue;
+		let t = [e];
+		for (; t.length;) {
+			let e = t.pop();
+			if (!F[e]) {
+				F[e] = 1, P.push(e);
+				for (let n = D[e].length - 1; n >= 0; n--) t.push(D[e][n]);
+			}
+		}
+	}
+	for (let e of P) N(e);
+	for (let e = 0; e < k; e++) N(e);
+	let I = new Float64Array(k), L = (e) => e.forEach((e, t) => I[e] = t);
+	j.forEach(L);
+	let R = () => {
+		let e = 0;
+		for (let n = 0; n + 1 < A; n++) {
+			let r = [];
+			for (let e of j[n]) for (let t of D[e]) r.push([I[e], I[t]]);
+			e += t(r, j[n + 1].length);
+		}
+		return e;
+	}, ie = R(), z = ie, B = j.map((e) => e.slice()), V = new Float64Array(k), H = (e, t, n) => {
+		let r = j[e];
+		for (let e of r) {
+			let r = n ? D[e] : E[e];
+			if (!r.length) {
+				V[e] = -1;
+				continue;
+			}
+			if (t) {
+				let t = r.map((e) => I[e]).sort((e, t) => e - t), n = t.length >> 1;
+				V[e] = t.length % 2 ? t[n] : (t[n - 1] + t[n]) / 2;
+			} else {
+				let t = 0;
+				for (let e of r) t += I[e];
+				V[e] = t / r.length;
+			}
+		}
+		let i = r.map((e) => V[e] < 0), a = r.filter((e) => V[e] >= 0).sort((e, t) => V[e] - V[t] || I[e] - I[t]), o = 0;
+		for (let e = 0; e < r.length; e++) i[e] || (r[e] = a[o++]);
+		L(r);
+	}, ae = Math.max(0, Math.floor(e.sweeps));
+	for (let e = 0; e < ae && z > 0; e++) {
+		let t = e % 4 >= 2;
+		if (e % 2 == 0) for (let e = 1; e < A; e++) H(e, t, !1);
+		else for (let e = A - 2; e >= 0; e--) H(e, t, !0);
+		let n = R();
+		n < z && (z = n, B = j.map((e) => e.slice()));
+	}
+	if (B.forEach((e, t) => {
+		j[t] = e, L(e);
+	}), k <= 3e3 && z > 0) {
+		let e = (e, t) => {
+			let n = 0;
+			for (let r of [E, D]) for (let i of r[e]) for (let e of r[t]) I[i] > I[e] && n++;
+			return n;
+		};
+		for (let t = 0, n = !0; n && t < 8; t++) {
+			n = !1;
+			for (let t of j) for (let r = 0; r + 1 < t.length; r++) {
+				let i = t[r], a = t[r + 1];
+				e(a, i) < e(i, a) && (t[r] = a, t[r + 1] = i, I[i] = r + 1, I[a] = r, n = !0);
+			}
+		}
+		z = R();
+	}
+	let U = (e) => e < n ? o[e] : 0, W = (t, r) => t < n && r < n ? e.nodeGap : e.nodeGap * .5, G = new Float64Array(k);
+	for (let e of j) {
+		let t = 0;
+		e.forEach((n, r) => {
+			r && (t += (U(e[r - 1]) + U(n)) / 2 + W(e[r - 1], n)), G[n] = t;
+		});
+		let n = t / 2;
+		for (let t of e) G[t] -= n;
+	}
+	let K = new Float64Array(k), q = new Float64Array(k), J = new Float64Array(k), oe = Array.from({ length: k }, () => []);
+	for (let e = 0; e < k; e++) E[e].forEach((t, n) => {
+		oe[t][D[t].indexOf(e)] = O[e][n];
+	});
+	let Y = (e, t) => {
+		let n = e.length;
+		if (n) {
+			for (let r = 0; r < n; r++) {
+				let n = e[r], i = 0, a = 0;
+				t !== "up" && E[n].forEach((e, t) => {
+					i += O[n][t], a += O[n][t] * G[e];
+				}), t !== "down" && D[n].forEach((e, t) => {
+					let r = oe[n][t] ?? 1;
+					i += r, a += r * G[e];
+				}), J[r] = r ? J[r - 1] + (U(e[r - 1]) + U(n)) / 2 + W(e[r - 1], n) : 0, K[r] = (i ? a / i : G[n]) - J[r], q[r] = i || .05;
+			}
+			r(K, q, n);
+			for (let t = 0; t < n; t++) G[e[t]] = K[t] + J[t];
+		}
+	};
+	for (let e = 0; e < 10; e++) if (e % 2 == 0) for (let e = 1; e < A; e++) Y(j[e], "down");
+	else for (let e = A - 2; e >= 0; e--) Y(j[e], "up");
+	for (let e = 0; e < A; e++) Y(j[e], "both");
+	let X = new Float64Array(A);
+	for (let e = 0; e < n; e++) X[S[e]] = Math.max(X[S[e]], s[e]);
+	let Z = new Float64Array(A);
+	for (let t = 1; t < A; t++) Z[t] = Z[t - 1] + X[t - 1] / 2 + e.layerGap + X[t] / 2;
+	let se = (e, t) => {
+		switch (i) {
+			case "BT": return [e, -t];
+			case "LR": return [t, e];
+			case "RL": return [-t, e];
+			default: return [e, t];
+		}
+	}, ce = new Float64Array(n), le = new Float64Array(n);
+	for (let e = 0; e < n; e++) {
+		let [t, n] = se(G[e], Z[S[e]]);
+		ce[e] = t, le[e] = n;
+	}
+	let Q = [], $ = [];
+	for (let e = 0; e < c; e++) {
+		let t = _[e];
+		if (t < 0) {
+			Q.push([]);
+			continue;
+		}
+		d[e] && $.push(e);
+		let n = te[t], r = [];
+		if (n.forEach((e, t) => {
+			let i = Z[T[e]], a = i;
+			t === 0 ? a = i + s[e] / 2 : t === n.length - 1 && (a = i - s[e] / 2);
+			let [o, c] = se(G[e], a);
+			r.push(o, c);
+		}), d[e]) {
+			let e = [];
+			for (let t = r.length - 2; t >= 0; t -= 2) e.push(r[t], r[t + 1]);
+			Q.push(e);
+		} else Q.push(r);
+	}
+	return {
+		x: ce,
+		y: le,
+		layer: S,
+		order: j.map((e) => e.map((e) => e < n ? e : -1 - (e - n))),
+		routes: Q,
+		reversed: $,
+		crossings: {
+			initial: ie,
+			final: z
+		}
+	};
+}, a = (t, n, r = {}) => {
+	let { source: a, target: o, edge: s } = e(t, n), c = new Float64Array(t.length), l = new Float64Array(t.length);
+	t.forEach((e, t) => {
+		let [n, i] = r.size?.(e, t) ?? [24, 24];
+		c[t] = n, l[t] = i;
+	});
+	let u = i({
+		n: t.length,
+		source: a,
+		target: o,
+		width: c,
+		height: l,
+		direction: r.direction ?? "TB",
+		layerGap: r.layerGap ?? 56,
+		nodeGap: r.nodeGap ?? 24,
+		sweeps: r.sweeps ?? 8
+	}), d = n.map(() => []);
+	return s.forEach((e, t) => d[e] = u.routes[t]), {
+		...u,
+		routes: d,
+		reversed: u.reversed.map((e) => s[e])
+	};
+}, o = (e, t, n, r) => {
+	let i = t.length, a = Array.from({ length: e }, () => []), o = new Int32Array(e);
+	for (let e = 0; e < i; e++) t[e] !== n[e] && (a[t[e]].push(e), o[n[e]]++);
+	let s = [];
+	for (let t = 0; t < e; t++) o[t] || s.push(t);
+	for (let e = 0; e < s.length; e++) for (let t of a[s[e]]) --o[n[t]] === 0 && s.push(n[t]);
+	let c = new Float64Array(e), l = new Int32Array(e).fill(-1), u = new Uint8Array(e);
+	for (let e of s) {
+		u[e] = 1, c[e] += r(e);
+		for (let t of a[e]) {
+			let r = n[t];
+			c[e] > c[r] && (c[r] = c[e], l[r] = t);
+		}
+	}
+	let d = -1;
+	for (let e of s) (d < 0 || c[e] > c[d]) && (d = e);
+	if (d < 0) return {
+		nodes: [],
+		edges: [],
+		length: 0
+	};
+	let f = [d], p = [];
+	for (let e = d; l[e] >= 0 && u[t[l[e]]];) p.push(l[e]), e = t[l[e]], f.push(e);
+	return {
+		nodes: f.reverse(),
+		edges: p.reverse(),
+		length: c[d]
+	};
+}, s = (t, n) => {
+	let { source: r, target: i, edge: a } = e(t, n), s = o(t.length, r, i, (e) => {
+		let n = t[e].value;
+		return Number.isFinite(n) && n >= 0 ? n : 1;
+	});
+	return {
+		nodes: s.nodes.map((e) => t[e].id),
+		edges: s.edges.map((e) => a[e]),
+		length: s.length
+	};
+};
+//#endregion
+export { n as countCrossings, s as criticalPath, a as dagLayout, i as layeredLayout, o as longestPath };
+
+//# sourceMappingURL=dag.js.map

package/dist/charts/engine/graph/dag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag.js","names":["bilayerCrossings","edges","a","b","tree","lowerSize","crossings","seen","q","le","i","countCrossings","layerOf","pos","layer","v","l","between","order","la","lb","total","list","isotonic","blockW","count","blockV","blockN","top","weight","target","w","k","layeredLayout","input","horizontal","direction","breadth","depth","E","out","indeg","e","s","t","reversedEdge","color","visit","stack","start","pairKey","accA","accB","chainOf","key","id","A","succ","pred","topo","remaining","p","u","maxLayer","layerCount","lo","hi","ins","outs","best","vLayer","vPred","vSucc","vWeight","chains","link","chain","prev","d","N","L","layers","placed","place","firstOrder","roots","r","updatePos","totalCrossings","pairs","initial","bestLayers","reorder","nb","up","useMedian","mid","fixedSlots","movable","sweeps","median","c","pairCrossings","pass","improved","size","gapOf","bx","cursor","shift","offset","succWeight","align","sw","sx","mode","iter","layerDepth","layerPos","toOut","x","y","px","py","routes","reversed","pts","dd","flipped","dagLayout","indexGraph","nodes","width","height","h","options","node","result","edge","longestPath","source","n","dist","via","inOrder","duration","end","criticalPath"],"sources":["../../../../../charts/src/engine/graph/dag.ts"],"sourcesContent":["// Layered (Sugiyama) layout of directed graphs: cycle breaking (DFS),\n// longest-path layering with a balancing pass, dummy nodes on long edges,\n// barycenter / median crossing reduction with transposition, and\n// coordinate assignment by weighted isotonic regression (long edges stay\n// straight). Index-based core + id-based public wrappers, no DOM.\n\nimport { indexGraph } from \"./force\";\nimport type {\n  GraphDagLayoutOptions,\n  GraphDagLayoutResult,\n  GraphCriticalPath,\n  GraphDirection,\n  GraphEdge,\n  GraphNode,\n} from \"./types\";\n\nexport interface LayeredInput {\n  n: number;\n  source: ArrayLike<number>;\n  target: ArrayLike<number>;\n  /** Width / height of each node */\n  width: ArrayLike<number>;\n  height: ArrayLike<number>;\n  direction: GraphDirection;\n  layerGap: number;\n  nodeGap: number;\n  sweeps: number;\n}\n\n/** Crossings between two consecutive layers (Fenwick tree, O(E log V)) */\nconst bilayerCrossings = (\n  edges: [number, number][],\n  lowerSize: number,\n): number => {\n  if (edges.length < 2) return 0;\n  edges.sort((a, b) => a[0] - b[0] || a[1] - b[1]);\n  const tree = new Int32Array(lowerSize + 1);\n  let crossings = 0;\n  let seen = 0;\n  for (const [, q] of edges) {\n    // edges already inserted that end to the right of q\n    let le = 0;\n    for (let i = q + 1; i > 0; i -= i & -i) le += tree[i];\n    crossings += seen - le;\n    for (let i = q + 1; i <= lowerSize; i += i & -i) tree[i]++;\n    seen++;\n  }\n  return crossings;\n};\n\n/**\n * Edge crossings of a layered drawing: `order[l]` lists the nodes of layer\n * `l` from left to right, `edges` are `[a, b]` pairs between consecutive\n * layers (other pairs are ignored)\n */\nexport const countCrossings = (\n  order: readonly (readonly number[])[],\n  edges: readonly (readonly [number, number])[],\n): number => {\n  const layerOf = new Map<number, number>();\n  const pos = new Map<number, number>();\n  order.forEach((layer, l) =>\n    layer.forEach((v, i) => {\n      layerOf.set(v, l);\n      pos.set(v, i);\n    }),\n  );\n  const between: [number, number][][] = order.map(() => []);\n  for (const [a, b] of edges) {\n    const la = layerOf.get(a);\n    const lb = layerOf.get(b);\n    if (la === undefined || lb === undefined) continue;\n    if (lb === la + 1) between[la].push([pos.get(a)!, pos.get(b)!]);\n    else if (la === lb + 1) between[lb].push([pos.get(b)!, pos.get(a)!]);\n  }\n  let total = 0;\n  between.forEach((list, l) => {\n    if (l + 1 < order.length)\n      total += bilayerCrossings(list, order[l + 1].length);\n  });\n  return total;\n};\n\n/** Weighted isotonic regression (pool adjacent violators), in place */\nconst isotonic = (\n  target: Float64Array,\n  weight: Float64Array,\n  count: number,\n): void => {\n  const blockW = new Float64Array(count);\n  const blockV = new Float64Array(count);\n  const blockN = new Int32Array(count);\n  let top = 0;\n  for (let i = 0; i < count; i++) {\n    blockW[top] = weight[i];\n    blockV[top] = target[i];\n    blockN[top] = 1;\n    top++;\n    while (top > 1 && blockV[top - 2] > blockV[top - 1]) {\n      const w = blockW[top - 2] + blockW[top - 1];\n      blockV[top - 2] =\n        (blockV[top - 2] * blockW[top - 2] +\n          blockV[top - 1] * blockW[top - 1]) /\n        w;\n      blockW[top - 2] = w;\n      blockN[top - 2] += blockN[top - 1];\n      top--;\n    }\n  }\n  let i = 0;\n  for (let b = 0; b < top; b++) {\n    for (let k = 0; k < blockN[b]; k++) target[i++] = blockV[b];\n  }\n};\n\n/** The layered layout on index data */\nexport const layeredLayout = (input: LayeredInput): GraphDagLayoutResult => {\n  const { n, direction } = input;\n  const horizontal = direction === \"LR\" || direction === \"RL\";\n  const breadth = horizontal ? input.height : input.width;\n  const depth = horizontal ? input.width : input.height;\n  const E = input.source.length;\n\n  // ---------------------------------------------------- 1. cycles\n  const out: number[][] = Array.from({ length: n }, () => []);\n  const indeg = new Int32Array(n);\n  for (let e = 0; e < E; e++) {\n    const s = input.source[e];\n    const t = input.target[e];\n    if (s === t || s < 0 || t < 0 || s >= n || t >= n) continue;\n    out[s].push(e);\n    indeg[t]++;\n  }\n  const reversedEdge = new Uint8Array(E);\n  const color = new Uint8Array(n);\n  const visit = (start: number) => {\n    const stack: [number, number][] = [[start, 0]];\n    color[start] = 1;\n    while (stack.length) {\n      const top = stack[stack.length - 1];\n      const [v, k] = top;\n      if (k >= out[v].length) {\n        color[v] = 2;\n        stack.pop();\n        continue;\n      }\n      top[1]++;\n      const e = out[v][k];\n      const w = input.target[e];\n      if (color[w] === 1) reversedEdge[e] = 1;\n      else if (color[w] === 0) {\n        color[w] = 1;\n        stack.push([w, 0]);\n      }\n    }\n  };\n  for (let v = 0; v < n; v++) if (!indeg[v] && !color[v]) visit(v);\n  for (let v = 0; v < n; v++) if (!color[v]) visit(v);\n\n  // acyclic, deduplicated edges\n  const pairKey = new Map<number, number>();\n  const accA: number[] = [];\n  const accB: number[] = [];\n  const chainOf = new Int32Array(E).fill(-1);\n  for (let e = 0; e < E; e++) {\n    const s = input.source[e];\n    const t = input.target[e];\n    if (s === t || s < 0 || t < 0 || s >= n || t >= n) continue;\n    const a = reversedEdge[e] ? t : s;\n    const b = reversedEdge[e] ? s : t;\n    const key = a * n + b;\n    let id = pairKey.get(key);\n    if (id === undefined) {\n      id = accA.length;\n      pairKey.set(key, id);\n      accA.push(a);\n      accB.push(b);\n    }\n    chainOf[e] = id;\n  }\n  const A = accA.length;\n\n  // ---------------------------------------------------- 2. layers\n  const succ: number[][] = Array.from({ length: n }, () => []);\n  const pred: number[][] = Array.from({ length: n }, () => []);\n  for (let k = 0; k < A; k++) {\n    succ[accA[k]].push(accB[k]);\n    pred[accB[k]].push(accA[k]);\n  }\n  const topo: number[] = [];\n  const remaining = Int32Array.from(pred, (p) => p.length);\n  for (let v = 0; v < n; v++) if (!remaining[v]) topo.push(v);\n  for (let i = 0; i < topo.length; i++) {\n    for (const w of succ[topo[i]]) if (--remaining[w] === 0) topo.push(w);\n  }\n  const layer = new Int32Array(n);\n  for (const v of topo) {\n    for (const u of pred[v]) layer[v] = Math.max(layer[v], layer[u] + 1);\n  }\n  let maxLayer = 0;\n  for (let v = 0; v < n; v++) maxLayer = Math.max(maxLayer, layer[v]);\n  const layerCount = new Int32Array(maxLayer + 1);\n  for (let v = 0; v < n; v++) layerCount[layer[v]]++;\n  // balancing: move nodes within their feasible range (shorter edges, then emptier layers)\n  for (let i = topo.length - 1; i >= 0; i--) {\n    const v = topo[i];\n    let lo = 0;\n    for (const u of pred[v]) lo = Math.max(lo, layer[u] + 1);\n    let hi = maxLayer;\n    for (const w of succ[v]) hi = Math.min(hi, layer[w] - 1);\n    if (!succ[v].length) hi = layer[v];\n    if (hi <= lo) continue;\n    const ins = pred[v].length;\n    const outs = succ[v].length;\n    let best = layer[v];\n    if (outs > ins) best = hi;\n    else if (ins > outs) best = lo;\n    else {\n      for (let l = lo; l <= hi; l++) {\n        if (layerCount[l] < layerCount[best] - 1) best = l;\n      }\n    }\n    if (best !== layer[v]) {\n      layerCount[layer[v]]--;\n      layerCount[best]++;\n      layer[v] = best;\n    }\n  }\n\n  // ---------------------------------------------------- 3. dummies\n  // virtual nodes: 0..n-1 real, n.. dummies\n  const vLayer: number[] = Array.from(layer);\n  const vPred: number[][] = Array.from({ length: n }, () => []);\n  const vSucc: number[][] = Array.from({ length: n }, () => []);\n  const vWeight: number[][] = Array.from({ length: n }, () => []);\n  const chains: number[][] = [];\n  const link = (p: number, q: number, w: number) => {\n    vSucc[p].push(q);\n    vPred[q].push(p);\n    vWeight[q].push(w);\n  };\n  for (let k = 0; k < A; k++) {\n    const a = accA[k];\n    const b = accB[k];\n    const chain: number[] = [a];\n    let prev = a;\n    for (let l = layer[a] + 1; l < layer[b]; l++) {\n      const d = vLayer.length;\n      vLayer.push(l);\n      vPred.push([]);\n      vSucc.push([]);\n      vWeight.push([]);\n      link(prev, d, prev >= n ? 8 : 2);\n      chain.push(d);\n      prev = d;\n    }\n    link(prev, b, prev >= n ? 2 : 1);\n    chain.push(b);\n    chains.push(chain);\n  }\n  const N = vLayer.length;\n  const L = maxLayer + 1;\n\n  // ---------------------------------------------------- 4. ordering\n  const layers: number[][] = Array.from({ length: L }, () => []);\n  const placed = new Uint8Array(N);\n  const place = (v: number) => {\n    if (placed[v]) return;\n    placed[v] = 1;\n    layers[vLayer[v]].push(v);\n  };\n  // depth-first from the sources keeps related nodes together\n  const firstOrder: number[] = [];\n  const seen = new Uint8Array(N);\n  const roots = topo.filter((v) => !vPred[v].length);\n  for (const r of roots.length ? roots : [0]) {\n    if (r >= N || seen[r]) continue;\n    const stack = [r];\n    while (stack.length) {\n      const v = stack.pop()!;\n      if (seen[v]) continue;\n      seen[v] = 1;\n      firstOrder.push(v);\n      for (let k = vSucc[v].length - 1; k >= 0; k--) stack.push(vSucc[v][k]);\n    }\n  }\n  for (const v of firstOrder) place(v);\n  for (let v = 0; v < N; v++) place(v);\n\n  const pos = new Float64Array(N);\n  const updatePos = (list: number[]) => list.forEach((v, i) => (pos[v] = i));\n  layers.forEach(updatePos);\n\n  const totalCrossings = () => {\n    let total = 0;\n    for (let l = 0; l + 1 < L; l++) {\n      const pairs: [number, number][] = [];\n      for (const v of layers[l])\n        for (const w of vSucc[v]) pairs.push([pos[v], pos[w]]);\n      total += bilayerCrossings(pairs, layers[l + 1].length);\n    }\n    return total;\n  };\n\n  const initial = totalCrossings();\n  let best = initial;\n  let bestLayers = layers.map((l) => l.slice());\n  const key = new Float64Array(N);\n  const reorder = (l: number, useMedian: boolean, up: boolean) => {\n    const list = layers[l];\n    for (const v of list) {\n      const nb = up ? vSucc[v] : vPred[v];\n      if (!nb.length) {\n        key[v] = -1;\n        continue;\n      }\n      if (useMedian) {\n        const p = nb.map((w) => pos[w]).sort((a, b) => a - b);\n        const mid = p.length >> 1;\n        key[v] = p.length % 2 ? p[mid] : (p[mid - 1] + p[mid]) / 2;\n      } else {\n        let s = 0;\n        for (const w of nb) s += pos[w];\n        key[v] = s / nb.length;\n      }\n    }\n    // nodes without neighbors keep their slot\n    const fixedSlots = list.map((v) => key[v] < 0);\n    const movable = list\n      .filter((v) => key[v] >= 0)\n      .sort((a, b) => key[a] - key[b] || pos[a] - pos[b]);\n    let k = 0;\n    for (let i = 0; i < list.length; i++) {\n      if (!fixedSlots[i]) list[i] = movable[k++];\n    }\n    updatePos(list);\n  };\n\n  const sweeps = Math.max(0, Math.floor(input.sweeps));\n  for (let s = 0; s < sweeps && best > 0; s++) {\n    const median = s % 4 >= 2;\n    if (s % 2 === 0) for (let l = 1; l < L; l++) reorder(l, median, false);\n    else for (let l = L - 2; l >= 0; l--) reorder(l, median, true);\n    const c = totalCrossings();\n    if (c < best) {\n      best = c;\n      bestLayers = layers.map((l) => l.slice());\n    }\n  }\n  bestLayers.forEach((list, l) => {\n    layers[l] = list;\n    updatePos(list);\n  });\n\n  // transposition of neighbors while it helps (small graphs)\n  if (N <= 3000 && best > 0) {\n    const pairCrossings = (u: number, v: number) => {\n      let c = 0;\n      for (const nb of [vPred, vSucc]) {\n        for (const a of nb[u]) for (const b of nb[v]) if (pos[a] > pos[b]) c++;\n      }\n      return c;\n    };\n    for (let pass = 0, improved = true; improved && pass < 8; pass++) {\n      improved = false;\n      for (const list of layers) {\n        for (let i = 0; i + 1 < list.length; i++) {\n          const u = list[i];\n          const v = list[i + 1];\n          if (pairCrossings(v, u) < pairCrossings(u, v)) {\n            list[i] = v;\n            list[i + 1] = u;\n            pos[u] = i + 1;\n            pos[v] = i;\n            improved = true;\n          }\n        }\n      }\n    }\n    best = totalCrossings();\n  }\n\n  // ---------------------------------------------------- 5. coordinates\n  const size = (v: number) => (v < n ? breadth[v] : 0);\n  const gapOf = (a: number, b: number) =>\n    a < n && b < n ? input.nodeGap : input.nodeGap * 0.5;\n  const bx = new Float64Array(N);\n  for (const list of layers) {\n    let cursor = 0;\n    list.forEach((v, i) => {\n      if (i)\n        cursor += (size(list[i - 1]) + size(v)) / 2 + gapOf(list[i - 1], v);\n      bx[v] = cursor;\n    });\n    const shift = cursor / 2;\n    for (const v of list) bx[v] -= shift;\n  }\n  const target = new Float64Array(N);\n  const weight = new Float64Array(N);\n  const offset = new Float64Array(N);\n  // weights of the edges seen from both ends\n  const succWeight: number[][] = Array.from({ length: N }, () => []);\n  for (let q = 0; q < N; q++) {\n    vPred[q].forEach((p, k) => {\n      succWeight[p][vSucc[p].indexOf(q)] = vWeight[q][k];\n    });\n  }\n  const align = (list: number[], mode: \"down\" | \"up\" | \"both\") => {\n    const count = list.length;\n    if (!count) return;\n    for (let i = 0; i < count; i++) {\n      const v = list[i];\n      let sw = 0;\n      let sx = 0;\n      if (mode !== \"up\") {\n        vPred[v].forEach((p, k) => {\n          sw += vWeight[v][k];\n          sx += vWeight[v][k] * bx[p];\n        });\n      }\n      if (mode !== \"down\") {\n        vSucc[v].forEach((q, k) => {\n          const w = succWeight[v][k] ?? 1;\n          sw += w;\n          sx += w * bx[q];\n        });\n      }\n      offset[i] = i\n        ? offset[i - 1] +\n          (size(list[i - 1]) + size(v)) / 2 +\n          gapOf(list[i - 1], v)\n        : 0;\n      target[i] = (sw ? sx / sw : bx[v]) - offset[i];\n      weight[i] = sw || 0.05;\n    }\n    isotonic(target, weight, count);\n    for (let i = 0; i < count; i++) bx[list[i]] = target[i] + offset[i];\n  };\n  for (let iter = 0; iter < 10; iter++) {\n    if (iter % 2 === 0) for (let l = 1; l < L; l++) align(layers[l], \"down\");\n    else for (let l = L - 2; l >= 0; l--) align(layers[l], \"up\");\n  }\n  for (let l = 0; l < L; l++) align(layers[l], \"both\");\n\n  // layer depths\n  const layerDepth = new Float64Array(L);\n  for (let v = 0; v < n; v++)\n    layerDepth[layer[v]] = Math.max(layerDepth[layer[v]], depth[v]);\n  const layerPos = new Float64Array(L);\n  for (let l = 1; l < L; l++) {\n    layerPos[l] =\n      layerPos[l - 1] +\n      layerDepth[l - 1] / 2 +\n      input.layerGap +\n      layerDepth[l] / 2;\n  }\n\n  // ---------------------------------------------------- 6. output\n  const toOut = (b: number, d: number): [number, number] => {\n    switch (direction) {\n      case \"BT\":\n        return [b, -d];\n      case \"LR\":\n        return [d, b];\n      case \"RL\":\n        return [-d, b];\n      default:\n        return [b, d];\n    }\n  };\n  const x = new Float64Array(n);\n  const y = new Float64Array(n);\n  for (let v = 0; v < n; v++) {\n    const [px, py] = toOut(bx[v], layerPos[layer[v]]);\n    x[v] = px;\n    y[v] = py;\n  }\n  const routes: number[][] = [];\n  const reversed: number[] = [];\n  for (let e = 0; e < E; e++) {\n    const id = chainOf[e];\n    if (id < 0) {\n      routes.push([]);\n      continue;\n    }\n    if (reversedEdge[e]) reversed.push(e);\n    const chain = chains[id];\n    const pts: number[] = [];\n    chain.forEach((v, i) => {\n      const d = layerPos[vLayer[v]];\n      let dd = d;\n      if (i === 0) dd = d + depth[v] / 2;\n      else if (i === chain.length - 1) dd = d - depth[v] / 2;\n      const [px, py] = toOut(bx[v], dd);\n      pts.push(px, py);\n    });\n    if (reversedEdge[e]) {\n      const flipped: number[] = [];\n      for (let i = pts.length - 2; i >= 0; i -= 2)\n        flipped.push(pts[i], pts[i + 1]);\n      routes.push(flipped);\n    } else {\n      routes.push(pts);\n    }\n  }\n  const order = layers.map((list) =>\n    list.map((v) => (v < n ? v : -1 - (v - n))),\n  );\n  return {\n    x,\n    y,\n    layer,\n    order,\n    routes,\n    reversed,\n    crossings: { initial, final: best },\n  };\n};\n\n/** Layered (Sugiyama) layout of a directed graph */\nexport const dagLayout = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options: GraphDagLayoutOptions = {},\n): GraphDagLayoutResult => {\n  const { source, target, edge } = indexGraph(nodes, edges);\n  const width = new Float64Array(nodes.length);\n  const height = new Float64Array(nodes.length);\n  nodes.forEach((node, i) => {\n    const [w, h] = options.size?.(node, i) ?? [24, 24];\n    width[i] = w;\n    height[i] = h;\n  });\n  const result = layeredLayout({\n    n: nodes.length,\n    source,\n    target,\n    width,\n    height,\n    direction: options.direction ?? \"TB\",\n    layerGap: options.layerGap ?? 56,\n    nodeGap: options.nodeGap ?? 24,\n    sweeps: options.sweeps ?? 8,\n  });\n  // routes / reversed indices of the input edges\n  const routes: number[][] = edges.map(() => []);\n  edge.forEach((k, i) => (routes[k] = result.routes[i]));\n  return {\n    ...result,\n    routes,\n    reversed: result.reversed.map((i) => edge[i]),\n  };\n};\n\n/** Index version of `criticalPath` */\nexport const longestPath = (\n  n: number,\n  source: ArrayLike<number>,\n  target: ArrayLike<number>,\n  duration: (i: number) => number,\n): { nodes: number[]; edges: number[]; length: number } => {\n  const E = source.length;\n  const out: number[][] = Array.from({ length: n }, () => []);\n  const indeg = new Int32Array(n);\n  for (let e = 0; e < E; e++) {\n    if (source[e] === target[e]) continue;\n    out[source[e]].push(e);\n    indeg[target[e]]++;\n  }\n  const order: number[] = [];\n  for (let v = 0; v < n; v++) if (!indeg[v]) order.push(v);\n  for (let i = 0; i < order.length; i++) {\n    for (const e of out[order[i]])\n      if (--indeg[target[e]] === 0) order.push(target[e]);\n  }\n  const dist = new Float64Array(n);\n  const via = new Int32Array(n).fill(-1);\n  const inOrder = new Uint8Array(n);\n  for (const v of order) {\n    inOrder[v] = 1;\n    dist[v] += duration(v);\n    for (const e of out[v]) {\n      const w = target[e];\n      if (dist[v] > dist[w]) {\n        dist[w] = dist[v];\n        via[w] = e;\n      }\n    }\n  }\n  let end = -1;\n  for (const v of order) if (end < 0 || dist[v] > dist[end]) end = v;\n  if (end < 0) return { nodes: [], edges: [], length: 0 };\n  const nodes: number[] = [end];\n  const edges: number[] = [];\n  for (let v = end; via[v] >= 0 && inOrder[source[via[v]]];) {\n    edges.push(via[v]);\n    v = source[via[v]];\n    nodes.push(v);\n  }\n  return { nodes: nodes.reverse(), edges: edges.reverse(), length: dist[end] };\n};\n\n/**\n * Critical path of a DAG: the chain of tasks with the largest total\n * duration (node `value`, 1 when omitted). Nodes on cycles are ignored.\n */\nexport const criticalPath = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n): GraphCriticalPath => {\n  const { source, target, edge } = indexGraph(nodes, edges);\n  const result = longestPath(nodes.length, source, target, (i) => {\n    const v = nodes[i].value;\n    return Number.isFinite(v) && v! >= 0 ? v! : 1;\n  });\n  return {\n    nodes: result.nodes.map((i) => nodes[i].id),\n    edges: result.edges.map((i) => edge[i]),\n    length: result.length,\n  };\n};\n"],"mappings":"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"}

package/dist/charts/engine/graph/dom.cjs

@@ -0,0 +1,2 @@
+var e=(e,t)=>(Object.assign(e.style,t),e),t={position:`absolute`,width:`1px`,height:`1px`,overflow:`hidden`,clip:`rect(0 0 0 0)`,clipPath:`inset(50%)`,whiteSpace:`nowrap`},n=0,r=t=>{let n=e(t.createElement(`canvas`),{position:`absolute`,left:`0`,top:`0`,pointerEvents:`none`});return n.setAttribute(`aria-hidden`,`true`),n},i={zoomIn:`<path d="M8 3.5v9M3.5 8h9"/>`,zoomOut:`<path d="M3.5 8h9"/>`,fit:`<path d="M2.5 6V2.5H6M10 2.5h3.5V6M13.5 10v3.5H10M6 13.5H2.5V10"/>`},a=(t,n)=>{let r=e(t.createElement(`button`),{display:`inline-flex`,alignItems:`center`,justifyContent:`center`,width:`28px`,height:`28px`,padding:`0`,margin:`0`,border:`0`,borderRadius:`6px`,background:`transparent`,color:`var(--text-secondary-color, #6b7280)`,cursor:`pointer`});return r.type=`button`,r.innerHTML=`<svg width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${i[n]}</svg>`,r},o=i=>{let o=i.ownerDocument,s=e(o.createElement(`div`),{position:`relative`,display:`flex`,flexDirection:`column`,width:`100%`,height:`100%`,minHeight:`0`,fontFamily:`var(--font-family-sans, system-ui, sans-serif)`,color:`var(--text-color, #1f2937)`});s.className=`minerva-chart minerva-chart-graph`;let c=e(o.createElement(`div`),{display:`none`,flexWrap:`wrap`,alignItems:`center`,gap:`4px 12px`,padding:`0 4px 8px`,fontSize:`12px`,lineHeight:`18px`});c.className=`minerva-chart-legend`;let l=e(o.createElement(`div`),{position:`relative`,flex:`1 1 auto`,minHeight:`0`,overflow:`hidden`,outline:`none`,touchAction:`none`,userSelect:`none`,borderRadius:`6px`,cursor:`grab`});l.className=`minerva-chart-stage`,l.setAttribute(`role`,`figure`);let u=r(o);u.className=`minerva-chart-labels`;let d=e(o.createElement(`div`),{position:`absolute`,right:`8px`,bottom:`8px`,zIndex:`1`,display:`flex`,flexDirection:`column`,gap:`2px`,padding:`2px`,borderRadius:`8px`,border:`1px solid color-mix(in srgb, var(--border-color, #e5e7eb) 80%, transparent)`,background:`color-mix(in srgb, var(--surface-elevated-color, var(--background-color, #fff)) 92%, transparent)`,boxShadow:`0 2px 8px -2px rgba(15, 23, 42, 0.12)`});d.className=`minerva-chart-controls`;let f=a(o,`zoomIn`),p=a(o,`zoomOut`),m=a(o,`fit`);d.append(f,p,m);let h=e(o.createElement(`div`),{position:`absolute`,inset:`0`,zIndex:`2`,display:`flex`,alignItems:`center`,justifyContent:`center`,pointerEvents:`none`,opacity:`0`,transition:`opacity 160ms ease-out`,background:`color-mix(in srgb, var(--text-color, #1f2937) 32%, transparent)`,color:`#fff`,fontSize:`14px`,fontWeight:`500`});h.className=`minerva-chart-hint`,h.setAttribute(`aria-hidden`,`true`);let g=e(o.createElement(`div`),{position:`absolute`,left:`0`,top:`0`,zIndex:`3`,display:`none`,pointerEvents:`none`,minWidth:`120px`,maxWidth:`320px`,padding:`8px 12px`,borderRadius:`10px`,border:`1px solid color-mix(in srgb, var(--border-color, #e5e7eb) 60%, transparent)`,background:`var(--surface-elevated-color, var(--background-color, #fff))`,color:`var(--text-color, #1f2937)`,boxShadow:`0 12px 32px -8px rgba(15, 23, 42, 0.16), 0 4px 10px -4px rgba(15, 23, 42, 0.08)`,fontSize:`12px`,lineHeight:`20px`,whiteSpace:`nowrap`});g.className=`minerva-chart-tooltip`,g.setAttribute(`role`,`tooltip`);let _=e(o.createElement(`div`),t);_.id=`minerva-chart-graph-summary-${++n}`,l.setAttribute(`aria-describedby`,_.id);let v=e(o.createElement(`div`),t);return v.setAttribute(`aria-live`,`polite`),l.append(u,d,h,g,_,v),s.append(c,l),i.appendChild(s),{root:s,legend:c,stage:l,foreground:u,controls:d,zoomIn:f,zoomOut:p,fit:m,hint:h,tooltip:g,summary:_,live:v}},s=(t,n)=>e(t.createElement(`span`),{display:`inline-block`,flex:`none`,width:`9px`,height:`9px`,borderRadius:`50%`,background:n}),c=(e,t,n,r)=>{let i=Math.max(1,Math.round(t*r)),a=Math.max(1,Math.round(n*r));e.width!==i&&(e.width=i),e.height!==a&&(e.height=a),e.style.width=`${t}px`,e.style.height=`${n}px`};exports.createGraphDom=o,exports.layerCanvas=r,exports.sizeCanvas=c,exports.style=e,exports.swatch=s;
+//# sourceMappingURL=dom.cjs.map

package/dist/charts/engine/graph/dom.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.cjs","names":["style","el","css","VISUALLY_HIDDEN","nextId","layerCanvas","canvas","doc","ICONS","controlButton","button","icon","createGraphDom","container","root","legend","stage","foreground","controls","zoomIn","zoomOut","fit","hint","tooltip","summary","live","swatch","color","sizeCanvas","w","width","dpr","h","height"],"sources":["../../../../../charts/src/engine/graph/dom.ts"],"sourcesContent":["// DOM of a graph chart: legend, focusable stage with the data canvas (added\n// by the renderer) and the label canvas, zoom buttons, wheel hint,\n// tooltip, a visually hidden summary and a live region. Styled inline with\n// the Minerva CSS variables.\n\nexport interface GraphDom {\n  root: HTMLDivElement;\n  legend: HTMLDivElement;\n  stage: HTMLDivElement;\n  /** Labels, badges, focus ring (above the data) */\n  foreground: HTMLCanvasElement;\n  controls: HTMLDivElement;\n  zoomIn: HTMLButtonElement;\n  zoomOut: HTMLButtonElement;\n  fit: HTMLButtonElement;\n  hint: HTMLDivElement;\n  tooltip: HTMLDivElement;\n  summary: HTMLDivElement;\n  live: HTMLDivElement;\n}\n\nexport const style = <T extends HTMLElement>(\n  el: T,\n  css: Partial<CSSStyleDeclaration>,\n): T => {\n  Object.assign(el.style, css);\n  return el;\n};\n\nconst VISUALLY_HIDDEN: Partial<CSSStyleDeclaration> = {\n  position: \"absolute\",\n  width: \"1px\",\n  height: \"1px\",\n  overflow: \"hidden\",\n  clip: \"rect(0 0 0 0)\",\n  clipPath: \"inset(50%)\",\n  whiteSpace: \"nowrap\",\n};\n\nlet nextId = 0;\n\n/** Canvas layer covering the stage */\nexport const layerCanvas = (doc: Document): HTMLCanvasElement => {\n  const canvas = style(doc.createElement(\"canvas\"), {\n    position: \"absolute\",\n    left: \"0\",\n    top: \"0\",\n    pointerEvents: \"none\",\n  });\n  canvas.setAttribute(\"aria-hidden\", \"true\");\n  return canvas;\n};\n\nconst ICONS = {\n  zoomIn: '<path d=\"M8 3.5v9M3.5 8h9\"/>',\n  zoomOut: '<path d=\"M3.5 8h9\"/>',\n  fit: '<path d=\"M2.5 6V2.5H6M10 2.5h3.5V6M13.5 10v3.5H10M6 13.5H2.5V10\"/>',\n};\n\nconst controlButton = (doc: Document, icon: keyof typeof ICONS) => {\n  const button = style(doc.createElement(\"button\"), {\n    display: \"inline-flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    width: \"28px\",\n    height: \"28px\",\n    padding: \"0\",\n    margin: \"0\",\n    border: \"0\",\n    borderRadius: \"6px\",\n    background: \"transparent\",\n    color: \"var(--text-secondary-color, #6b7280)\",\n    cursor: \"pointer\",\n  });\n  button.type = \"button\";\n  button.innerHTML = `<svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\" stroke-linejoin=\"round\" aria-hidden=\"true\">${ICONS[icon]}</svg>`;\n  return button;\n};\n\nexport const createGraphDom = (container: HTMLElement): GraphDom => {\n  const doc = container.ownerDocument;\n  const root = style(doc.createElement(\"div\"), {\n    position: \"relative\",\n    display: \"flex\",\n    flexDirection: \"column\",\n    width: \"100%\",\n    height: \"100%\",\n    minHeight: \"0\",\n    fontFamily: \"var(--font-family-sans, system-ui, sans-serif)\",\n    color: \"var(--text-color, #1f2937)\",\n  });\n  root.className = \"minerva-chart minerva-chart-graph\";\n\n  const legend = style(doc.createElement(\"div\"), {\n    display: \"none\",\n    flexWrap: \"wrap\",\n    alignItems: \"center\",\n    gap: \"4px 12px\",\n    padding: \"0 4px 8px\",\n    fontSize: \"12px\",\n    lineHeight: \"18px\",\n  });\n  legend.className = \"minerva-chart-legend\";\n\n  const stage = style(doc.createElement(\"div\"), {\n    position: \"relative\",\n    flex: \"1 1 auto\",\n    minHeight: \"0\",\n    overflow: \"hidden\",\n    outline: \"none\",\n    touchAction: \"none\",\n    userSelect: \"none\",\n    borderRadius: \"6px\",\n    cursor: \"grab\",\n  });\n  stage.className = \"minerva-chart-stage\";\n  stage.setAttribute(\"role\", \"figure\");\n\n  const foreground = layerCanvas(doc);\n  foreground.className = \"minerva-chart-labels\";\n\n  const controls = style(doc.createElement(\"div\"), {\n    position: \"absolute\",\n    right: \"8px\",\n    bottom: \"8px\",\n    zIndex: \"1\",\n    display: \"flex\",\n    flexDirection: \"column\",\n    gap: \"2px\",\n    padding: \"2px\",\n    borderRadius: \"8px\",\n    border:\n      \"1px solid color-mix(in srgb, var(--border-color, #e5e7eb) 80%, transparent)\",\n    background:\n      \"color-mix(in srgb, var(--surface-elevated-color, var(--background-color, #fff)) 92%, transparent)\",\n    boxShadow: \"0 2px 8px -2px rgba(15, 23, 42, 0.12)\",\n  });\n  controls.className = \"minerva-chart-controls\";\n  const zoomIn = controlButton(doc, \"zoomIn\");\n  const zoomOut = controlButton(doc, \"zoomOut\");\n  const fit = controlButton(doc, \"fit\");\n  controls.append(zoomIn, zoomOut, fit);\n\n  const hint = style(doc.createElement(\"div\"), {\n    position: \"absolute\",\n    inset: \"0\",\n    zIndex: \"2\",\n    display: \"flex\",\n    alignItems: \"center\",\n    justifyContent: \"center\",\n    pointerEvents: \"none\",\n    opacity: \"0\",\n    transition: \"opacity 160ms ease-out\",\n    background:\n      \"color-mix(in srgb, var(--text-color, #1f2937) 32%, transparent)\",\n    color: \"#fff\",\n    fontSize: \"14px\",\n    fontWeight: \"500\",\n  });\n  hint.className = \"minerva-chart-hint\";\n  hint.setAttribute(\"aria-hidden\", \"true\");\n\n  const tooltip = style(doc.createElement(\"div\"), {\n    position: \"absolute\",\n    left: \"0\",\n    top: \"0\",\n    zIndex: \"3\",\n    display: \"none\",\n    pointerEvents: \"none\",\n    minWidth: \"120px\",\n    maxWidth: \"320px\",\n    padding: \"8px 12px\",\n    borderRadius: \"10px\",\n    border:\n      \"1px solid color-mix(in srgb, var(--border-color, #e5e7eb) 60%, transparent)\",\n    background: \"var(--surface-elevated-color, var(--background-color, #fff))\",\n    color: \"var(--text-color, #1f2937)\",\n    boxShadow:\n      \"0 12px 32px -8px rgba(15, 23, 42, 0.16), 0 4px 10px -4px rgba(15, 23, 42, 0.08)\",\n    fontSize: \"12px\",\n    lineHeight: \"20px\",\n    whiteSpace: \"nowrap\",\n  });\n  tooltip.className = \"minerva-chart-tooltip\";\n  tooltip.setAttribute(\"role\", \"tooltip\");\n\n  const summary = style(doc.createElement(\"div\"), VISUALLY_HIDDEN);\n  summary.id = `minerva-chart-graph-summary-${++nextId}`;\n  stage.setAttribute(\"aria-describedby\", summary.id);\n\n  const live = style(doc.createElement(\"div\"), VISUALLY_HIDDEN);\n  live.setAttribute(\"aria-live\", \"polite\");\n\n  stage.append(foreground, controls, hint, tooltip, summary, live);\n  root.append(legend, stage);\n  container.appendChild(root);\n  return {\n    root,\n    legend,\n    stage,\n    foreground,\n    controls,\n    zoomIn,\n    zoomOut,\n    fit,\n    hint,\n    tooltip,\n    summary,\n    live,\n  };\n};\n\n/** Color dot of the legend and the tooltip */\nexport const swatch = (doc: Document, color: string) =>\n  style(doc.createElement(\"span\"), {\n    display: \"inline-block\",\n    flex: \"none\",\n    width: \"9px\",\n    height: \"9px\",\n    borderRadius: \"50%\",\n    background: color,\n  });\n\n/** Sizes a canvas to the stage (CSS pixels × device pixel ratio) */\nexport const sizeCanvas = (\n  canvas: HTMLCanvasElement,\n  width: number,\n  height: number,\n  dpr: number,\n): void => {\n  const w = Math.max(1, Math.round(width * dpr));\n  const h = Math.max(1, Math.round(height * dpr));\n  if (canvas.width !== w) canvas.width = w;\n  if (canvas.height !== h) canvas.height = h;\n  canvas.style.width = `${width}px`;\n  canvas.style.height = `${height}px`;\n};\n"],"mappings":"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"}