minerva-design 1.4.0 → 1.6.0

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

@@ -0,0 +1,62 @@
+import { indexGraph as e } from "./force.js";
+//#region src/engine/graph/circular.ts
+var t = (e) => {
+	let { n: t } = e, n = new Int32Array(t);
+	for (let r = 0; r < e.source.length; r++) {
+		let i = e.source[r], a = e.target[r];
+		i < 0 || a < 0 || i >= t || a >= t || (n[i]++, n[a]++);
+	}
+	let r = Array.from({ length: t }, (e, t) => t);
+	if (e.order === "none") return r;
+	let i = (t) => {
+		let n = e.group[t];
+		return n < 0 ? 2 ** 53 - 1 : n;
+	};
+	return r.sort((t, r) => e.order === "group" ? i(t) - i(r) || t - r : n[r] - n[t] || t - r);
+}, n = (e) => {
+	let n = t(e), { n: r } = e, i = Math.max(40, r * e.spacing / (2 * Math.PI)), a = new Float64Array(r), o = new Float64Array(r), s = new Float64Array(r), c = [];
+	n.forEach((t, r) => {
+		r && e.group[t] !== e.group[n[r - 1]] && c.push(r);
+	});
+	let l = e.order === "group" && c.length > 0, u = r + (l ? c.length + 1 : 0), d = 0;
+	return n.forEach((e, t) => {
+		l && c.includes(t) && d++;
+		let n = d / Math.max(1, u) * Math.PI * 2 - Math.PI / 2;
+		s[e] = n, a[e] = r > 1 ? i * Math.cos(n) : 0, o[e] = r > 1 ? i * Math.sin(n) : 0, d++;
+	}), {
+		x: a,
+		y: o,
+		angle: s,
+		order: n,
+		radius: r > 1 ? i : 0
+	};
+}, r = (e) => {
+	let n = t(e), { n: r } = e, i = new Float64Array(r), a = new Float64Array(r), o = (r - 1) * e.spacing;
+	return n.forEach((t, n) => {
+		i[t] = n * e.spacing - o / 2;
+	}), {
+		x: i,
+		y: a,
+		angle: new Float64Array(r),
+		order: n,
+		radius: 0
+	};
+}, i = (t, n, r) => {
+	let { source: i, target: a } = e(t, n), o = /* @__PURE__ */ new Map(), s = t.map((e) => {
+		if (e.group === void 0) return -1;
+		let t = o.get(e.group);
+		return t === void 0 && o.set(e.group, t = o.size), t;
+	});
+	return {
+		n: t.length,
+		source: i,
+		target: a,
+		group: s,
+		order: r.order ?? "group",
+		spacing: r.spacing ?? 18
+	};
+}, a = (e, t, r = {}) => n(i(e, t, r)), o = (e, t, n = {}) => r(i(e, t, n));
+//#endregion
+export { o as arcLayout, r as arcPositions, a as circularLayout, n as circularPositions };
+
+//# sourceMappingURL=circular.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"circular.js","names":["placementOrder","input","degree","n","e","s","t","order","i","groupKey","g","a","b","circularPositions","radius","x","y","angle","groupBreaks","k","v","useBreaks","slots","slot","arcPositions","width","inputOf","indexGraph","nodes","edges","groups","group","node","options","circularLayout","arcLayout"],"sources":["../../../../../charts/src/engine/graph/circular.ts"],"sourcesContent":["// Circular layout (nodes on a circle, grouped) and arc diagram (nodes on a\n// line, edges as arcs). No DOM.\n\nimport { indexGraph } from \"./force\";\nimport type {\n  GraphCircularLayoutOptions,\n  GraphCircularLayoutResult,\n  GraphEdge,\n  GraphNode,\n} from \"./types\";\n\nexport interface CircularInput {\n  n: number;\n  source: ArrayLike<number>;\n  target: ArrayLike<number>;\n  /** Group index of each node (-1 = none) */\n  group: ArrayLike<number>;\n  order: \"group\" | \"degree\" | \"none\";\n  spacing: number;\n}\n\n/** Placement order of the nodes */\nconst placementOrder = (input: CircularInput): number[] => {\n  const { n } = input;\n  const degree = new Int32Array(n);\n  for (let e = 0; e < input.source.length; e++) {\n    const s = input.source[e];\n    const t = input.target[e];\n    if (s < 0 || t < 0 || s >= n || t >= n) continue;\n    degree[s]++;\n    degree[t]++;\n  }\n  const order = Array.from({ length: n }, (_, i) => i);\n  if (input.order === \"none\") return order;\n  const groupKey = (i: number) => {\n    const g = input.group[i];\n    return g < 0 ? Number.MAX_SAFE_INTEGER : g;\n  };\n  return order.sort((a, b) =>\n    input.order === \"group\"\n      ? groupKey(a) - groupKey(b) || a - b\n      : degree[b] - degree[a] || a - b,\n  );\n};\n\nexport const circularPositions = (\n  input: CircularInput,\n): GraphCircularLayoutResult => {\n  const order = placementOrder(input);\n  const { n } = input;\n  const radius = Math.max(40, (n * input.spacing) / (2 * Math.PI));\n  const x = new Float64Array(n);\n  const y = new Float64Array(n);\n  const angle = new Float64Array(n);\n  // a small gap between groups makes them readable\n  const groupBreaks: number[] = [];\n  order.forEach((v, k) => {\n    if (k && input.group[v] !== input.group[order[k - 1]]) groupBreaks.push(k);\n  });\n  const useBreaks = input.order === \"group\" && groupBreaks.length > 0;\n  const slots = n + (useBreaks ? groupBreaks.length + 1 : 0);\n  let slot = 0;\n  order.forEach((v, k) => {\n    if (useBreaks && groupBreaks.includes(k)) slot++;\n    const a = (slot / Math.max(1, slots)) * Math.PI * 2 - Math.PI / 2;\n    angle[v] = a;\n    x[v] = n > 1 ? radius * Math.cos(a) : 0;\n    y[v] = n > 1 ? radius * Math.sin(a) : 0;\n    slot++;\n  });\n  return { x, y, angle, order, radius: n > 1 ? radius : 0 };\n};\n\nexport const arcPositions = (\n  input: CircularInput,\n): GraphCircularLayoutResult => {\n  const order = placementOrder(input);\n  const { n } = input;\n  const x = new Float64Array(n);\n  const y = new Float64Array(n);\n  const width = (n - 1) * input.spacing;\n  order.forEach((v, k) => {\n    x[v] = k * input.spacing - width / 2;\n  });\n  return { x, y, angle: new Float64Array(n), order, radius: 0 };\n};\n\nconst inputOf = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options: GraphCircularLayoutOptions,\n): CircularInput => {\n  const { source, target } = indexGraph(nodes, edges);\n  const groups = new Map<string, number>();\n  const group = nodes.map((node) => {\n    if (node.group === undefined) return -1;\n    let g = groups.get(node.group);\n    if (g === undefined) groups.set(node.group, (g = groups.size));\n    return g;\n  });\n  return {\n    n: nodes.length,\n    source,\n    target,\n    group,\n    order: options.order ?? \"group\",\n    spacing: options.spacing ?? 18,\n  };\n};\n\n/** Nodes on a circle, ordered by group (or degree) */\nexport const circularLayout = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options: GraphCircularLayoutOptions = {},\n): GraphCircularLayoutResult =>\n  circularPositions(inputOf(nodes, edges, options));\n\n/** Nodes on a horizontal line (arc diagram), ordered by group (or degree) */\nexport const arcLayout = (\n  nodes: readonly GraphNode[],\n  edges: readonly GraphEdge[],\n  options: GraphCircularLayoutOptions = {},\n): GraphCircularLayoutResult => arcPositions(inputOf(nodes, edges, options));\n"],"mappings":"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"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"dag.cjs","names":["indexGraph","require_force","TRANSPOSE_PASSES","TRANSPOSE_BUDGET","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","n","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","predStart","succStart","predPos","succPos","work","prepare","sideGain","a0","a1","b0","b1","cross","ties","j","arr","dirty","pass","changed","any","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","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/** Most passes of the neighbor transposition */\nconst TRANSPOSE_PASSES = 24;\n/**\n * Work budget of the transposition (neighbor positions compared): about\n * 50-100 ms on large graphs, unbounded in practice below some 10k nodes\n */\nconst TRANSPOSE_BUDGET = 2e7;\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, any size: crossings of a\n  // pair come from sorted neighbor positions (two pointers, O(deg u +\n  // deg v), so hubs stay cheap), only layers next to a change are revisited,\n  // and a work budget (deterministic, unlike a clock) bounds huge graphs\n  if (best > 0) {\n    const predStart = new Int32Array(N + 1);\n    const succStart = new Int32Array(N + 1);\n    for (let v = 0; v < N; v++) {\n      predStart[v + 1] = predStart[v] + vPred[v].length;\n      succStart[v + 1] = succStart[v] + vSucc[v].length;\n    }\n    const predPos = new Float64Array(predStart[N]);\n    const succPos = new Float64Array(succStart[N]);\n    let work = 0;\n    const prepare = (list: number[]) => {\n      for (const v of list) {\n        const p = vPred[v];\n        const s = vSucc[v];\n        for (let k = 0; k < p.length; k++)\n          predPos[predStart[v] + k] = pos[p[k]];\n        for (let k = 0; k < s.length; k++)\n          succPos[succStart[v] + k] = pos[s[k]];\n        if (p.length > 1)\n          predPos.subarray(predStart[v], predStart[v + 1]).sort();\n        if (s.length > 1)\n          succPos.subarray(succStart[v], succStart[v + 1]).sort();\n        work += p.length + s.length + 1;\n      }\n    };\n    // crossings with u left of v minus crossings with v left of u, on one side\n    const sideGain = (\n      arr: Float64Array,\n      start: Int32Array,\n      u: number,\n      v: number,\n    ) => {\n      const a0 = start[u];\n      const a1 = start[u + 1];\n      const b0 = start[v];\n      const b1 = start[v + 1];\n      if (a0 === a1 || b0 === b1) return 0;\n      let cross = 0;\n      let ties = 0;\n      let j = b0;\n      for (let i = a0; i < a1; i++) {\n        const a = arr[i];\n        while (j < b1 && arr[j] < a) j++;\n        cross += j - b0;\n        if (j < b1 && arr[j] === a) ties++;\n      }\n      work += a1 - a0 + b1 - b0;\n      const pairs = (a1 - a0) * (b1 - b0);\n      return cross - (pairs - cross - ties);\n    };\n    let dirty = new Uint8Array(L).fill(1);\n    for (let pass = 0; pass < TRANSPOSE_PASSES; pass++) {\n      const changed = new Uint8Array(L);\n      let any = false;\n      for (let l = 0; l < L && work < TRANSPOSE_BUDGET; l++) {\n        if (!dirty[l]) continue;\n        const list = layers[l];\n        prepare(list);\n        for (let i = 0; i + 1 < list.length; i++) {\n          const u = list[i];\n          const v = list[i + 1];\n          const gain =\n            sideGain(predPos, predStart, u, v) +\n            sideGain(succPos, succStart, u, v);\n          if (gain > 0) {\n            list[i] = v;\n            list[i + 1] = u;\n            pos[u] = i + 1;\n            pos[v] = i;\n            changed[l] = 1;\n            any = true;\n          }\n        }\n      }\n      if (!any || work >= TRANSPOSE_BUDGET) break;\n      dirty = new Uint8Array(L);\n      for (let l = 0; l < L; l++) {\n        if (!changed[l]) continue;\n        if (l > 0) dirty[l - 1] = 1;\n        dirty[l] = 1;\n        if (l + 1 < L) dirty[l + 1] = 1;\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,339 @@
+import { indexGraph as e } from "./force.js";
+//#region src/engine/graph/dag.ts
+var t = 24, n = 2e7, r = (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;
+}, i = (e, t) => {
+	let n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+	e.forEach((e, t) => e.forEach((e, r) => {
+		n.set(e, t), i.set(e, r);
+	}));
+	let a = e.map(() => []);
+	for (let [e, r] of t) {
+		let t = n.get(e), o = n.get(r);
+		t !== void 0 && o !== void 0 && (o === t + 1 ? a[t].push([i.get(e), i.get(r)]) : t === o + 1 && a[o].push([i.get(r), i.get(e)]));
+	}
+	let o = 0;
+	return a.forEach((t, n) => {
+		n + 1 < e.length && (o += r(t, e[n + 1].length));
+	}), o;
+}, a = (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];
+}, o = (e) => {
+	let { n: i, direction: o } = e, s = o === "LR" || o === "RL", c = s ? e.height : e.width, l = s ? e.width : e.height, u = e.source.length, d = Array.from({ length: i }, () => []), f = new Int32Array(i);
+	for (let t = 0; t < u; t++) {
+		let n = e.source[t], r = e.target[t];
+		n === r || n < 0 || r < 0 || n >= i || r >= i || (d[n].push(t), f[r]++);
+	}
+	let p = new Uint8Array(u), m = new Uint8Array(i), h = (t) => {
+		let n = [[t, 0]];
+		for (m[t] = 1; n.length;) {
+			let t = n[n.length - 1], [r, i] = t;
+			if (i >= d[r].length) {
+				m[r] = 2, n.pop();
+				continue;
+			}
+			t[1]++;
+			let a = d[r][i], o = e.target[a];
+			m[o] === 1 ? p[a] = 1 : m[o] === 0 && (m[o] = 1, n.push([o, 0]));
+		}
+	};
+	for (let e = 0; e < i; e++) !f[e] && !m[e] && h(e);
+	for (let e = 0; e < i; e++) m[e] || h(e);
+	let g = /* @__PURE__ */ new Map(), _ = [], v = [], ee = new Int32Array(u).fill(-1);
+	for (let t = 0; t < u; t++) {
+		let n = e.source[t], r = e.target[t];
+		if (n === r || n < 0 || r < 0 || n >= i || r >= i) continue;
+		let a = p[t] ? r : n, o = p[t] ? n : r, s = a * i + o, c = g.get(s);
+		c === void 0 && (c = _.length, g.set(s, c), _.push(a), v.push(o)), ee[t] = c;
+	}
+	let y = _.length, b = Array.from({ length: i }, () => []), x = Array.from({ length: i }, () => []);
+	for (let e = 0; e < y; e++) b[_[e]].push(v[e]), x[v[e]].push(_[e]);
+	let S = [], C = Int32Array.from(x, (e) => e.length);
+	for (let e = 0; e < i; e++) C[e] || S.push(e);
+	for (let e = 0; e < S.length; e++) for (let t of b[S[e]]) --C[t] === 0 && S.push(t);
+	let w = new Int32Array(i);
+	for (let e of S) for (let t of x[e]) w[e] = Math.max(w[e], w[t] + 1);
+	let T = 0;
+	for (let e = 0; e < i; e++) T = Math.max(T, w[e]);
+	let E = new Int32Array(T + 1);
+	for (let e = 0; e < i; e++) E[w[e]]++;
+	for (let e = S.length - 1; e >= 0; e--) {
+		let t = S[e], n = 0;
+		for (let e of x[t]) n = Math.max(n, w[e] + 1);
+		let r = T;
+		for (let e of b[t]) r = Math.min(r, w[e] - 1);
+		if (b[t].length || (r = w[t]), r <= n) continue;
+		let i = x[t].length, a = b[t].length, o = w[t];
+		if (a > i) o = r;
+		else if (i > a) o = n;
+		else for (let e = n; e <= r; e++) E[e] < E[o] - 1 && (o = e);
+		o !== w[t] && (E[w[t]]--, E[o]++, w[t] = o);
+	}
+	let D = Array.from(w), O = Array.from({ length: i }, () => []), k = Array.from({ length: i }, () => []), A = Array.from({ length: i }, () => []), te = [], ne = (e, t, n) => {
+		k[e].push(t), O[t].push(e), A[t].push(n);
+	};
+	for (let e = 0; e < y; e++) {
+		let t = _[e], n = v[e], r = [t], a = t;
+		for (let e = w[t] + 1; e < w[n]; e++) {
+			let t = D.length;
+			D.push(e), O.push([]), k.push([]), A.push([]), ne(a, t, a >= i ? 8 : 2), r.push(t), a = t;
+		}
+		ne(a, n, a >= i ? 2 : 1), r.push(n), te.push(r);
+	}
+	let j = D.length, M = T + 1, N = Array.from({ length: M }, () => []), P = new Uint8Array(j), F = (e) => {
+		P[e] || (P[e] = 1, N[D[e]].push(e));
+	}, I = [], L = new Uint8Array(j), R = S.filter((e) => !O[e].length);
+	for (let e of R.length ? R : [0]) {
+		if (e >= j || L[e]) continue;
+		let t = [e];
+		for (; t.length;) {
+			let e = t.pop();
+			if (!L[e]) {
+				L[e] = 1, I.push(e);
+				for (let n = k[e].length - 1; n >= 0; n--) t.push(k[e][n]);
+			}
+		}
+	}
+	for (let e of I) F(e);
+	for (let e = 0; e < j; e++) F(e);
+	let z = new Float64Array(j), B = (e) => e.forEach((e, t) => z[e] = t);
+	N.forEach(B);
+	let V = () => {
+		let e = 0;
+		for (let t = 0; t + 1 < M; t++) {
+			let n = [];
+			for (let e of N[t]) for (let t of k[e]) n.push([z[e], z[t]]);
+			e += r(n, N[t + 1].length);
+		}
+		return e;
+	}, H = V(), U = H, W = N.map((e) => e.slice()), G = new Float64Array(j), re = (e, t, n) => {
+		let r = N[e];
+		for (let e of r) {
+			let r = n ? k[e] : O[e];
+			if (!r.length) {
+				G[e] = -1;
+				continue;
+			}
+			if (t) {
+				let t = r.map((e) => z[e]).sort((e, t) => e - t), n = t.length >> 1;
+				G[e] = t.length % 2 ? t[n] : (t[n - 1] + t[n]) / 2;
+			} else {
+				let t = 0;
+				for (let e of r) t += z[e];
+				G[e] = t / r.length;
+			}
+		}
+		let i = r.map((e) => G[e] < 0), a = r.filter((e) => G[e] >= 0).sort((e, t) => G[e] - G[t] || z[e] - z[t]), o = 0;
+		for (let e = 0; e < r.length; e++) i[e] || (r[e] = a[o++]);
+		B(r);
+	}, ie = Math.max(0, Math.floor(e.sweeps));
+	for (let e = 0; e < ie && U > 0; e++) {
+		let t = e % 4 >= 2;
+		if (e % 2 == 0) for (let e = 1; e < M; e++) re(e, t, !1);
+		else for (let e = M - 2; e >= 0; e--) re(e, t, !0);
+		let n = V();
+		n < U && (U = n, W = N.map((e) => e.slice()));
+	}
+	if (W.forEach((e, t) => {
+		N[t] = e, B(e);
+	}), U > 0) {
+		let e = new Int32Array(j + 1), r = new Int32Array(j + 1);
+		for (let t = 0; t < j; t++) e[t + 1] = e[t] + O[t].length, r[t + 1] = r[t] + k[t].length;
+		let i = new Float64Array(e[j]), a = new Float64Array(r[j]), o = 0, s = (t) => {
+			for (let n of t) {
+				let t = O[n], s = k[n];
+				for (let r = 0; r < t.length; r++) i[e[n] + r] = z[t[r]];
+				for (let e = 0; e < s.length; e++) a[r[n] + e] = z[s[e]];
+				t.length > 1 && i.subarray(e[n], e[n + 1]).sort(), s.length > 1 && a.subarray(r[n], r[n + 1]).sort(), o += t.length + s.length + 1;
+			}
+		}, c = (e, t, n, r) => {
+			let i = t[n], a = t[n + 1], s = t[r], c = t[r + 1];
+			if (i === a || s === c) return 0;
+			let l = 0, u = 0, d = s;
+			for (let t = i; t < a; t++) {
+				let n = e[t];
+				for (; d < c && e[d] < n;) d++;
+				l += d - s, d < c && e[d] === n && u++;
+			}
+			o += a - i + c - s;
+			let f = (a - i) * (c - s);
+			return l - (f - l - u);
+		}, l = new Uint8Array(M).fill(1);
+		for (let u = 0; u < t; u++) {
+			let t = new Uint8Array(M), u = !1;
+			for (let d = 0; d < M && o < n; d++) {
+				if (!l[d]) continue;
+				let n = N[d];
+				s(n);
+				for (let o = 0; o + 1 < n.length; o++) {
+					let s = n[o], l = n[o + 1];
+					c(i, e, s, l) + c(a, r, s, l) > 0 && (n[o] = l, n[o + 1] = s, z[s] = o + 1, z[l] = o, t[d] = 1, u = !0);
+				}
+			}
+			if (!u || o >= n) break;
+			l = new Uint8Array(M);
+			for (let e = 0; e < M; e++) t[e] && (e > 0 && (l[e - 1] = 1), l[e] = 1, e + 1 < M && (l[e + 1] = 1));
+		}
+		U = V();
+	}
+	let K = (e) => e < i ? c[e] : 0, ae = (t, n) => t < i && n < i ? e.nodeGap : e.nodeGap * .5, q = new Float64Array(j);
+	for (let e of N) {
+		let t = 0;
+		e.forEach((n, r) => {
+			r && (t += (K(e[r - 1]) + K(n)) / 2 + ae(e[r - 1], n)), q[n] = t;
+		});
+		let n = t / 2;
+		for (let t of e) q[t] -= n;
+	}
+	let J = new Float64Array(j), oe = new Float64Array(j), Y = new Float64Array(j), se = Array.from({ length: j }, () => []);
+	for (let e = 0; e < j; e++) O[e].forEach((t, n) => {
+		se[t][k[t].indexOf(e)] = A[e][n];
+	});
+	let X = (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" && O[n].forEach((e, t) => {
+					i += A[n][t], a += A[n][t] * q[e];
+				}), t !== "down" && k[n].forEach((e, t) => {
+					let r = se[n][t] ?? 1;
+					i += r, a += r * q[e];
+				}), Y[r] = r ? Y[r - 1] + (K(e[r - 1]) + K(n)) / 2 + ae(e[r - 1], n) : 0, J[r] = (i ? a / i : q[n]) - Y[r], oe[r] = i || .05;
+			}
+			a(J, oe, n);
+			for (let t = 0; t < n; t++) q[e[t]] = J[t] + Y[t];
+		}
+	};
+	for (let e = 0; e < 10; e++) if (e % 2 == 0) for (let e = 1; e < M; e++) X(N[e], "down");
+	else for (let e = M - 2; e >= 0; e--) X(N[e], "up");
+	for (let e = 0; e < M; e++) X(N[e], "both");
+	let Z = new Float64Array(M);
+	for (let e = 0; e < i; e++) Z[w[e]] = Math.max(Z[w[e]], l[e]);
+	let Q = new Float64Array(M);
+	for (let t = 1; t < M; t++) Q[t] = Q[t - 1] + Z[t - 1] / 2 + e.layerGap + Z[t] / 2;
+	let ce = (e, t) => {
+		switch (o) {
+			case "BT": return [e, -t];
+			case "LR": return [t, e];
+			case "RL": return [-t, e];
+			default: return [e, t];
+		}
+	}, le = new Float64Array(i), ue = new Float64Array(i);
+	for (let e = 0; e < i; e++) {
+		let [t, n] = ce(q[e], Q[w[e]]);
+		le[e] = t, ue[e] = n;
+	}
+	let $ = [], de = [];
+	for (let e = 0; e < u; e++) {
+		let t = ee[e];
+		if (t < 0) {
+			$.push([]);
+			continue;
+		}
+		p[e] && de.push(e);
+		let n = te[t], r = [];
+		if (n.forEach((e, t) => {
+			let i = Q[D[e]], a = i;
+			t === 0 ? a = i + l[e] / 2 : t === n.length - 1 && (a = i - l[e] / 2);
+			let [o, s] = ce(q[e], a);
+			r.push(o, s);
+		}), p[e]) {
+			let e = [];
+			for (let t = r.length - 2; t >= 0; t -= 2) e.push(r[t], r[t + 1]);
+			$.push(e);
+		} else $.push(r);
+	}
+	return {
+		x: le,
+		y: ue,
+		layer: w,
+		order: N.map((e) => e.map((e) => e < i ? e : -1 - (e - i))),
+		routes: $,
+		reversed: de,
+		crossings: {
+			initial: H,
+			final: U
+		}
+	};
+}, s = (t, n, r = {}) => {
+	let { source: i, target: a, 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 = o({
+		n: t.length,
+		source: i,
+		target: a,
+		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])
+	};
+}, c = (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]
+	};
+}, l = (t, n) => {
+	let { source: r, target: i, edge: a } = e(t, n), o = c(t.length, r, i, (e) => {
+		let n = t[e].value;
+		return Number.isFinite(n) && n >= 0 ? n : 1;
+	});
+	return {
+		nodes: o.nodes.map((e) => t[e].id),
+		edges: o.edges.map((e) => a[e]),
+		length: o.length
+	};
+};
+//#endregion
+export { i as countCrossings, l as criticalPath, s as dagLayout, o as layeredLayout, c as longestPath };
+
+//# sourceMappingURL=dag.js.map