@carlonicora/nextjs-jsonapi 1.98.0 → 1.100.0

package/dist/{chunk-TLTENUI6.mjs → chunk-S34H33HJ.mjs}

@@ -6454,6 +6454,137 @@ import * as d3 from "d3";
 import { Loader2 as Loader22 } from "lucide-react";
 import { useCallback as useCallback9, useEffect as useEffect8, useMemo as useMemo8, useRef as useRef8 } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
+
+// src/hooks/computeLayeredLayout.ts
+import * as dagre from "dagre";
+var DEFAULT_RANKDIR = "LR";
+var DEFAULT_NODESEP = 50;
+var DEFAULT_RANKSEP = 120;
+var MIN_NODESEP = 20;
+var MAX_NODESEP = 400;
+var MIN_RANKSEP = 40;
+var MAX_RANKSEP = 600;
+var MIN_FACTOR = 0.25;
+var MAX_FACTOR = 4;
+var DEFAULT_TOLERANCE = 0.05;
+var DEFAULT_MAX_ITERATIONS = 4;
+var TITLE_PX_PER_CHAR_16 = 8;
+var NAME_PX_PER_CHAR_12 = 6.5;
+var NAME_PX_PER_CHAR_16_BOLD = 8;
+var SUBTITLE_PX_PER_CHAR_11 = 6;
+var LABEL_PADDING_PX = 16;
+function estimateLabelWidth(node) {
+  if (node.subtitle) {
+    const titleWidth = (node.name?.length ?? 0) * TITLE_PX_PER_CHAR_16;
+    const subtitleWidth = node.subtitle.length * SUBTITLE_PX_PER_CHAR_11;
+    return Math.max(titleWidth, subtitleWidth) + LABEL_PADDING_PX;
+  }
+  const perChar = node.bold ? NAME_PX_PER_CHAR_16_BOLD : NAME_PX_PER_CHAR_12;
+  return (node.name?.length ?? 0) * perChar + LABEL_PADDING_PX;
+}
+__name(estimateLabelWidth, "estimateLabelWidth");
+function linkEndpointId(end) {
+  return typeof end === "string" ? end : end.id;
+}
+__name(linkEndpointId, "linkEndpointId");
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+__name(clamp, "clamp");
+function runDagreOnce(nodes, links, opts) {
+  const rankdir = opts.rankdir ?? DEFAULT_RANKDIR;
+  const nodesep = opts.nodesep ?? DEFAULT_NODESEP;
+  const ranksep = opts.ranksep ?? DEFAULT_RANKSEP;
+  const g = new dagre.graphlib.Graph({ directed: true });
+  g.setGraph({ rankdir, nodesep, ranksep, marginx: 20, marginy: 20 });
+  g.setDefaultEdgeLabel(() => ({}));
+  for (const node of nodes) {
+    const width = Math.max(opts.minNodeWidth, estimateLabelWidth(node));
+    const height = opts.minNodeHeight;
+    g.setNode(node.id, { width, height });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const link of links) {
+    const sourceId = linkEndpointId(link.source);
+    const targetId = linkEndpointId(link.target);
+    if (!g.hasNode(sourceId) || !g.hasNode(targetId)) continue;
+    const key = `${sourceId}->${targetId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    g.setEdge(sourceId, targetId);
+  }
+  try {
+    dagre.layout(g);
+  } catch {
+    return null;
+  }
+  const positions = /* @__PURE__ */ new Map();
+  let xMin = Infinity;
+  let xMax = -Infinity;
+  let yMin = Infinity;
+  let yMax = -Infinity;
+  for (const node of nodes) {
+    const laid = g.node(node.id);
+    if (laid && Number.isFinite(laid.x) && Number.isFinite(laid.y)) {
+      positions.set(node.id, { x: laid.x, y: laid.y });
+      const halfW = (laid.width ?? opts.minNodeWidth) / 2;
+      const halfH = (laid.height ?? opts.minNodeHeight) / 2;
+      xMin = Math.min(xMin, laid.x - halfW);
+      xMax = Math.max(xMax, laid.x + halfW);
+      yMin = Math.min(yMin, laid.y - halfH);
+      yMax = Math.max(yMax, laid.y + halfH);
+    }
+  }
+  const bbox = positions.size === 0 ? { width: 0, height: 0 } : { width: Math.max(0, xMax - xMin), height: Math.max(0, yMax - yMin) };
+  return { positions, bbox };
+}
+__name(runDagreOnce, "runDagreOnce");
+function computeLayeredLayout(nodes, links, opts) {
+  if (nodes.length === 0) return /* @__PURE__ */ new Map();
+  const result = runDagreOnce(nodes, links, opts);
+  return result ? result.positions : null;
+}
+__name(computeLayeredLayout, "computeLayeredLayout");
+function fitLayeredLayoutToAspectRatio(nodes, links, opts) {
+  if (nodes.length === 0) return /* @__PURE__ */ new Map();
+  if (!Number.isFinite(opts.targetAspectRatio) || opts.targetAspectRatio <= 0) {
+    return computeLayeredLayout(nodes, links, opts);
+  }
+  const maxIterations = opts.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const tolerance = opts.tolerance ?? DEFAULT_TOLERANCE;
+  const rankdir = opts.rankdir ?? DEFAULT_RANKDIR;
+  const isHorizontalFlow = rankdir === "LR" || rankdir === "RL";
+  let nodesep = opts.nodesep ?? DEFAULT_NODESEP;
+  let ranksep = opts.ranksep ?? DEFAULT_RANKSEP;
+  let best = null;
+  for (let i = 0; i < maxIterations; i++) {
+    const result = runDagreOnce(nodes, links, {
+      ...opts,
+      nodesep,
+      ranksep
+    });
+    if (!result) return best ? best.positions : null;
+    best = result;
+    if (result.positions.size <= 1) return result.positions;
+    const { width, height } = result.bbox;
+    if (width === 0 || height === 0) return result.positions;
+    const currentAspect = width / height;
+    const ratio = opts.targetAspectRatio / currentAspect;
+    if (Math.abs(ratio - 1) < tolerance) return result.positions;
+    const factor = clamp(Math.sqrt(ratio), MIN_FACTOR, MAX_FACTOR);
+    if (isHorizontalFlow) {
+      ranksep = clamp(ranksep * factor, MIN_RANKSEP, MAX_RANKSEP);
+      nodesep = clamp(nodesep / factor, MIN_NODESEP, MAX_NODESEP);
+    } else {
+      ranksep = clamp(ranksep / factor, MIN_RANKSEP, MAX_RANKSEP);
+      nodesep = clamp(nodesep * factor, MIN_NODESEP, MAX_NODESEP);
+    }
+  }
+  return best ? best.positions : null;
+}
+__name(fitLayeredLayoutToAspectRatio, "fitLayeredLayoutToAspectRatio");
+
+// src/hooks/useCustomD3Graph.tsx
 import { jsx as jsx49 } from "react/jsx-runtime";
 function useCustomD3Graph(nodes, links, onNodeClick, visibleNodeIds, options, loadingNodeIds, containerKey) {
   const svgRef = useRef8(null);
@@ -6584,117 +6715,175 @@ function useCustomD3Graph(nodes, links, onNodeClick, visibleNodeIds, options, lo
     });
     zoomBehaviorRef.current = zoom2;
     svg.call(zoom2).on("wheel.zoom", null).on("dblclick.zoom", null);
-    const childDistanceFromRoot = Math.min(width, height) * 0.4;
-    const grandchildDistanceFromChild = nodeRadius * 10;
-    const centralNodeId = nodes[0].id;
-    const nodeHierarchy = /* @__PURE__ */ new Map();
-    nodeHierarchy.set(centralNodeId, {
-      depth: 0,
-      parent: null,
-      children: []
-    });
-    visibleLinks.forEach((link2) => {
-      const sourceId = typeof link2.source === "string" ? link2.source : link2.source.id;
-      const targetId = typeof link2.target === "string" ? link2.target : link2.target.id;
-      if (sourceId === centralNodeId) {
-        nodeHierarchy.set(targetId, { depth: 1, parent: centralNodeId, children: [] });
-        const rootNode = nodeHierarchy.get(centralNodeId);
-        if (rootNode) {
-          rootNode.children.push(targetId);
-        }
-      }
-    });
-    visibleLinks.forEach((link2) => {
-      const sourceId = typeof link2.source === "string" ? link2.source : link2.source.id;
-      const targetId = typeof link2.target === "string" ? link2.target : link2.target.id;
-      const sourceNode = nodeHierarchy.get(sourceId);
-      if (sourceNode && sourceNode.depth === 1 && !nodeHierarchy.has(targetId)) {
-        nodeHierarchy.set(targetId, { depth: 2, parent: sourceId, children: [] });
-        sourceNode.children.push(targetId);
-      }
-    });
-    const rootChildren = nodeHierarchy.get(centralNodeId)?.children || [];
-    const childAngleStep = 2 * Math.PI / Math.max(rootChildren.length, 1);
-    rootChildren.forEach((childId, index) => {
-      const childNode = nodeHierarchy.get(childId);
-      if (childNode) {
-        const angle = index * childAngleStep;
-        childNode.angle = angle;
-        childNode.x = width / 2 + childDistanceFromRoot * Math.cos(angle);
-        childNode.y = height / 2 + childDistanceFromRoot * Math.sin(angle);
+    const layoutMode = options?.layout ?? "radial";
+    let layeredPositionsApplied = false;
+    if (layoutMode === "layered") {
+      const layeredOpts = options?.layered ?? {};
+      const useFit = layeredOpts.fitContainer === true && width > 0 && height > 0;
+      const positions = useFit ? fitLayeredLayoutToAspectRatio(visibleNodes, visibleLinks, {
+        rankdir: layeredOpts.rankdir ?? "LR",
+        nodesep: layeredOpts.nodesep,
+        ranksep: layeredOpts.ranksep,
+        minNodeWidth: nodeRadius * 2,
+        minNodeHeight: nodeRadius * 2,
+        targetAspectRatio: width / height
+      }) : computeLayeredLayout(visibleNodes, visibleLinks, {
+        rankdir: layeredOpts.rankdir ?? "LR",
+        nodesep: layeredOpts.nodesep,
+        ranksep: layeredOpts.ranksep,
+        minNodeWidth: nodeRadius * 2,
+        minNodeHeight: nodeRadius * 2
+      });
+      if (positions) {
+        visibleNodes.forEach((node2) => {
+          const saved = nodePositionsRef.current.get(node2.id);
+          if (saved) {
+            node2.fx = saved.x;
+            node2.fy = saved.y;
+            node2.x = saved.x;
+            node2.y = saved.y;
+            return;
+          }
+          const pos = positions.get(node2.id);
+          if (pos) {
+            node2.fx = pos.x;
+            node2.fy = pos.y;
+            node2.x = pos.x;
+            node2.y = pos.y;
+            nodePositionsRef.current.set(node2.id, { x: pos.x, y: pos.y });
+          }
+        });
+        const nodeById = /* @__PURE__ */ new Map();
+        visibleNodes.forEach((n) => nodeById.set(n.id, n));
+        visibleLinks.forEach((link2) => {
+          if (typeof link2.source === "string") {
+            const src = nodeById.get(link2.source);
+            if (src) link2.source = src;
+          }
+          if (typeof link2.target === "string") {
+            const tgt = nodeById.get(link2.target);
+            if (tgt) link2.target = tgt;
+          }
+        });
+        layeredPositionsApplied = true;
+      } else {
+        console.warn("[useCustomD3Graph] Layered layout failed; falling back to radial.");
       }
-    });
-    for (const [_nodeId, node2] of nodeHierarchy.entries()) {
-      if (node2.depth === 1 && node2.angle !== void 0 && node2.x !== void 0 && node2.y !== void 0) {
-        const childAngle = node2.angle;
-        const childX = node2.x;
-        const childY = node2.y;
-        const grandchildren = node2.children;
-        if (grandchildren.length === 0) continue;
-        const dirX = childX - width / 2;
-        const dirY = childY - height / 2;
-        const dirLength = Math.sqrt(dirX * dirX + dirY * dirY);
-        const normDirX = dirX / dirLength;
-        const normDirY = dirY / dirLength;
-        if (grandchildren.length === 1) {
-          const grandchildId = grandchildren[0];
-          const grandchildNode = nodeHierarchy.get(grandchildId);
-          if (grandchildNode) {
-            grandchildNode.x = childX + normDirX * grandchildDistanceFromChild;
-            grandchildNode.y = childY + normDirY * grandchildDistanceFromChild;
-            grandchildNode.angle = childAngle;
+    }
+    let simulation = null;
+    if (!layeredPositionsApplied) {
+      const childDistanceFromRoot = Math.min(width, height) * 0.4;
+      const grandchildDistanceFromChild = nodeRadius * 10;
+      const centralNodeId = nodes[0].id;
+      const nodeHierarchy = /* @__PURE__ */ new Map();
+      nodeHierarchy.set(centralNodeId, {
+        depth: 0,
+        parent: null,
+        children: []
+      });
+      visibleLinks.forEach((link2) => {
+        const sourceId = typeof link2.source === "string" ? link2.source : link2.source.id;
+        const targetId = typeof link2.target === "string" ? link2.target : link2.target.id;
+        if (sourceId === centralNodeId) {
+          nodeHierarchy.set(targetId, { depth: 1, parent: centralNodeId, children: [] });
+          const rootNode = nodeHierarchy.get(centralNodeId);
+          if (rootNode) {
+            rootNode.children.push(targetId);
           }
-        } else {
-          const numChildren = grandchildren.length;
-          const minArc = Math.PI / 3;
-          const maxArc = Math.PI;
-          const arcProgress = Math.min(1, (numChildren - 2) / 5);
-          const arcSpan = minArc + arcProgress * (maxArc - minArc);
-          const startAngle = childAngle - arcSpan / 2;
-          grandchildren.forEach((grandchildId, index) => {
+        }
+      });
+      visibleLinks.forEach((link2) => {
+        const sourceId = typeof link2.source === "string" ? link2.source : link2.source.id;
+        const targetId = typeof link2.target === "string" ? link2.target : link2.target.id;
+        const sourceNode = nodeHierarchy.get(sourceId);
+        if (sourceNode && sourceNode.depth === 1 && !nodeHierarchy.has(targetId)) {
+          nodeHierarchy.set(targetId, { depth: 2, parent: sourceId, children: [] });
+          sourceNode.children.push(targetId);
+        }
+      });
+      const rootChildren = nodeHierarchy.get(centralNodeId)?.children || [];
+      const childAngleStep = 2 * Math.PI / Math.max(rootChildren.length, 1);
+      rootChildren.forEach((childId, index) => {
+        const childNode = nodeHierarchy.get(childId);
+        if (childNode) {
+          const angle = index * childAngleStep;
+          childNode.angle = angle;
+          childNode.x = width / 2 + childDistanceFromRoot * Math.cos(angle);
+          childNode.y = height / 2 + childDistanceFromRoot * Math.sin(angle);
+        }
+      });
+      for (const [_nodeId, node2] of nodeHierarchy.entries()) {
+        if (node2.depth === 1 && node2.angle !== void 0 && node2.x !== void 0 && node2.y !== void 0) {
+          const childAngle = node2.angle;
+          const childX = node2.x;
+          const childY = node2.y;
+          const grandchildren = node2.children;
+          if (grandchildren.length === 0) continue;
+          const dirX = childX - width / 2;
+          const dirY = childY - height / 2;
+          const dirLength = Math.sqrt(dirX * dirX + dirY * dirY);
+          const normDirX = dirX / dirLength;
+          const normDirY = dirY / dirLength;
+          if (grandchildren.length === 1) {
+            const grandchildId = grandchildren[0];
             const grandchildNode = nodeHierarchy.get(grandchildId);
-            if (!grandchildNode) return;
-            const angleOffset = numChildren > 1 ? index / (numChildren - 1) * arcSpan : 0;
-            const angle = startAngle + angleOffset;
-            grandchildNode.x = childX + grandchildDistanceFromChild * Math.cos(angle);
-            grandchildNode.y = childY + grandchildDistanceFromChild * Math.sin(angle);
-            grandchildNode.angle = angle;
-          });
+            if (grandchildNode) {
+              grandchildNode.x = childX + normDirX * grandchildDistanceFromChild;
+              grandchildNode.y = childY + normDirY * grandchildDistanceFromChild;
+              grandchildNode.angle = childAngle;
+            }
+          } else {
+            const numChildren = grandchildren.length;
+            const minArc = Math.PI / 3;
+            const maxArc = Math.PI;
+            const arcProgress = Math.min(1, (numChildren - 2) / 5);
+            const arcSpan = minArc + arcProgress * (maxArc - minArc);
+            const startAngle = childAngle - arcSpan / 2;
+            grandchildren.forEach((grandchildId, index) => {
+              const grandchildNode = nodeHierarchy.get(grandchildId);
+              if (!grandchildNode) return;
+              const angleOffset = numChildren > 1 ? index / (numChildren - 1) * arcSpan : 0;
+              const angle = startAngle + angleOffset;
+              grandchildNode.x = childX + grandchildDistanceFromChild * Math.cos(angle);
+              grandchildNode.y = childY + grandchildDistanceFromChild * Math.sin(angle);
+              grandchildNode.angle = angle;
+            });
+          }
         }
       }
-    }
-    visibleNodes.forEach((node2) => {
-      const savedPosition = nodePositionsRef.current.get(node2.id);
-      if (savedPosition) {
-        node2.fx = savedPosition.x;
-        node2.fy = savedPosition.y;
-      } else {
-        const hierarchyNode = nodeHierarchy.get(node2.id);
-        if (hierarchyNode && hierarchyNode.x !== void 0 && hierarchyNode.y !== void 0) {
-          node2.fx = hierarchyNode.x;
-          node2.fy = hierarchyNode.y;
-          nodePositionsRef.current.set(node2.id, { x: hierarchyNode.x, y: hierarchyNode.y });
-        } else if (node2.id === centralNodeId) {
-          node2.fx = width / 2;
-          node2.fy = height / 2;
-          nodePositionsRef.current.set(node2.id, { x: width / 2, y: height / 2 });
+      visibleNodes.forEach((node2) => {
+        const savedPosition = nodePositionsRef.current.get(node2.id);
+        if (savedPosition) {
+          node2.fx = savedPosition.x;
+          node2.fy = savedPosition.y;
+        } else {
+          const hierarchyNode = nodeHierarchy.get(node2.id);
+          if (hierarchyNode && hierarchyNode.x !== void 0 && hierarchyNode.y !== void 0) {
+            node2.fx = hierarchyNode.x;
+            node2.fy = hierarchyNode.y;
+            nodePositionsRef.current.set(node2.id, { x: hierarchyNode.x, y: hierarchyNode.y });
+          } else if (node2.id === centralNodeId) {
+            node2.fx = width / 2;
+            node2.fy = height / 2;
+            nodePositionsRef.current.set(node2.id, { x: width / 2, y: height / 2 });
+          }
         }
+      });
+      simulation = d3.forceSimulation(visibleNodes).force(
+        "link",
+        d3.forceLink(visibleLinks).id((d) => d.id).distance(nodeRadius * 3).strength(0.1)
+      ).force("charge", d3.forceManyBody().strength(-500).distanceMax(300)).force("collision", d3.forceCollide().radius(nodeRadius * 1.2)).force("center", d3.forceCenter(width / 2, height / 2).strength(0.1));
+      simulation.stop();
+      for (let i = 0; i < 100; i++) {
+        simulation.tick();
       }
-    });
-    const simulation = d3.forceSimulation(visibleNodes).force(
-      "link",
-      d3.forceLink(visibleLinks).id((d) => d.id).distance(nodeRadius * 3).strength(0.1)
-    ).force("charge", d3.forceManyBody().strength(-500).distanceMax(300)).force("collision", d3.forceCollide().radius(nodeRadius * 1.2)).force("center", d3.forceCenter(width / 2, height / 2).strength(0.1));
-    simulation.stop();
-    for (let i = 0; i < 100; i++) {
-      simulation.tick();
-    }
-    visibleNodes.forEach((node2) => {
-      if (node2.fx === void 0) {
-        node2.fx = node2.x;
-        node2.fy = node2.y;
-      }
-    });
+      visibleNodes.forEach((node2) => {
+        if (node2.fx === void 0) {
+          node2.fx = node2.x;
+          node2.fy = node2.y;
+        }
+      });
+    }
     const linkX2 = /* @__PURE__ */ __name((sx, sy, tx, ty) => {
       if (!directed) return tx;
       const dx = tx - sx;
@@ -6836,9 +7025,22 @@ function useCustomD3Graph(nodes, links, onNodeClick, visibleNodeIds, options, lo
       }
     });
     return () => {
-      simulation.stop();
+      simulation?.stop();
     };
-  }, [nodes, links, colorScale, visibleNodeIds, options?.directed, loadingNodeIds, onNodeClick]);
+  }, [
+    nodes,
+    links,
+    colorScale,
+    visibleNodeIds,
+    options?.directed,
+    options?.layout,
+    options?.layered?.rankdir,
+    options?.layered?.nodesep,
+    options?.layered?.ranksep,
+    options?.layered?.fitContainer,
+    loadingNodeIds,
+    onNodeClick
+  ]);
   const zoomIn = useCallback9(() => {
     if (!svgRef.current || !zoomBehaviorRef.current) return;
     const svg = d3.select(svgRef.current);
@@ -9273,7 +9475,7 @@ import { useRef as useRef15 } from "react";
 import dynamic from "next/dynamic";
 import React14 from "react";
 import { jsx as jsx73 } from "react/jsx-runtime";
-var BlockNoteEditor = dynamic(() => import("./BlockNoteEditor-HWQHTLEB.mjs"), {
+var BlockNoteEditor = dynamic(() => import("./BlockNoteEditor-QH3NPFYN.mjs"), {
   ssr: false
 });
 var BlockNoteEditorContainer = React14.memo(/* @__PURE__ */ __name(function EditorContainer(props) {
@@ -21687,6 +21889,8 @@ export {
   useDebounce2 as useDebounce,
   registerTableGenerator,
   useTableGenerator,
+  computeLayeredLayout,
+  fitLayeredLayoutToAspectRatio,
   useCustomD3Graph,
   SocketContext,
   SocketProvider,
@@ -22186,4 +22390,4 @@ export {
   useOAuthClients,
   useOAuthClient
 };
-//# sourceMappingURL=chunk-TLTENUI6.mjs.map
+//# sourceMappingURL=chunk-S34H33HJ.mjs.map