@carlonicora/nextjs-jsonapi 0.0.1

package/dist/chunk-WWWMJZEF.mjs

@@ -0,0 +1,806 @@
+import {
+  AbstractService
+} from "./chunk-L6EQEAXU.mjs";
+import {
+  __name
+} from "./chunk-PAWJFY3S.mjs";
+
+// src/hooks/TableGeneratorRegistry.ts
+var TableGeneratorRegistry = class _TableGeneratorRegistry {
+  static {
+    __name(this, "TableGeneratorRegistry");
+  }
+  static instance;
+  registry = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!_TableGeneratorRegistry.instance) {
+      _TableGeneratorRegistry.instance = new _TableGeneratorRegistry();
+    }
+    return _TableGeneratorRegistry.instance;
+  }
+  register(type, hook) {
+    if (!this.registry.has(type)) this.registry.set(type, hook);
+  }
+  get(type, params) {
+    const hook = this.registry.get(type);
+    if (!hook) {
+      throw new Error(
+        `Table generator for type "${type}" is not registered. Available types: ${Array.from(this.registry.keys()).join(
+          ", "
+        )}`
+      );
+    }
+    return hook(params);
+  }
+  isRegistered(type) {
+    return this.registry.has(type);
+  }
+  getRegisteredTypes() {
+    return Array.from(this.registry.keys());
+  }
+  unregister(type) {
+    return this.registry.delete(type);
+  }
+  clear() {
+    this.registry.clear();
+  }
+};
+var tableGeneratorRegistry = TableGeneratorRegistry.getInstance();
+
+// src/hooks/url.rewriter.ts
+import { useLocale } from "next-intl";
+import { useCallback } from "react";
+
+// src/hooks/usePageUrlGenerator.ts
+function usePageUrlGenerator() {
+  const generateUrl = /* @__PURE__ */ __name((params) => {
+    if (!params.page) return "/";
+    const pathParams = [
+      `${params.language ? `/${params.language}` : ""}${typeof params.page === "string" ? params.page : params.page.pageUrl}`
+    ];
+    if (params.id) {
+      pathParams.push(params.id);
+      if (params.childPage) {
+        pathParams.push(typeof params.childPage === "string" ? params.childPage : params.childPage.pageUrl ?? "");
+        if (params.childId) {
+          pathParams.push(params.childId);
+        }
+      }
+    }
+    const response = pathParams.join(`/`);
+    if (params.additionalParameters) {
+      const searchParams = new URLSearchParams();
+      for (const key in params.additionalParameters) {
+        if (params.additionalParameters[key]) {
+          searchParams.append(key, params.additionalParameters[key]);
+        }
+      }
+      return `${response}?${searchParams.toString()}`;
+    }
+    return response;
+  }, "generateUrl");
+  return generateUrl;
+}
+__name(usePageUrlGenerator, "usePageUrlGenerator");
+
+// src/hooks/url.rewriter.ts
+function useUrlRewriter() {
+  const locale = useLocale();
+  const generateUrl = usePageUrlGenerator();
+  return useCallback(
+    (params) => {
+      window.history.replaceState(
+        null,
+        "",
+        generateUrl({ page: params.page, id: params.id, childPage: params.childPage, language: locale })
+      );
+    },
+    [locale, generateUrl]
+  );
+}
+__name(useUrlRewriter, "useUrlRewriter");
+
+// src/hooks/useDataListRetriever.ts
+import { useCallback as useCallback2, useEffect, useMemo, useRef, useState } from "react";
+function useDataListRetriever(params) {
+  const [data, setData] = useState(void 0);
+  const [nextPage, setNextPage] = useState(void 0);
+  const [previousPage, setPreviousPage] = useState(void 0);
+  const [isLoaded, setIsLoaded] = useState(false);
+  const [ready, setReady] = useState(params.ready ?? true);
+  const searchTermRef = useRef("");
+  const additionalParamsRef = useRef({});
+  const requestIdRef = useRef(0);
+  const abortControllerRef = useRef(null);
+  const isFetchingRef = useRef(false);
+  const resolvedType = params.module;
+  const resolvedService = AbstractService;
+  const parsePageParams = useCallback2((url) => {
+    if (!url) return null;
+    try {
+      const urlObj = new URL(url);
+      const offset = parseInt(urlObj.searchParams.get("page[offset]") || "0", 10);
+      const size = parseInt(urlObj.searchParams.get("page[size]") || "25", 10);
+      return { offset, size };
+    } catch {
+      return null;
+    }
+  }, []);
+  const adjustPaginationUrl = useCallback2((url, delta) => {
+    if (!url) return void 0;
+    try {
+      const urlObj = new URL(url);
+      const currentOffset = parseInt(urlObj.searchParams.get("page[offset]") || "0", 10);
+      const newOffset = Math.max(0, currentOffset + delta);
+      urlObj.searchParams.set("page[offset]", String(newOffset));
+      return urlObj.toString();
+    } catch {
+      return url;
+    }
+  }, []);
+  const pageInfo = useMemo(() => {
+    if (!data || data.length === 0) return void 0;
+    const nextParams = parsePageParams(nextPage);
+    const prevParams = parsePageParams(previousPage);
+    let currentOffset = 0;
+    let pageSize = 25;
+    if (nextParams) {
+      pageSize = nextParams.size;
+      currentOffset = Math.max(0, nextParams.offset - pageSize);
+    } else if (prevParams) {
+      pageSize = prevParams.size;
+      currentOffset = prevParams.offset + pageSize;
+    }
+    const startItem = currentOffset + 1;
+    const endItem = currentOffset + data.length;
+    return { startItem, endItem, pageSize };
+  }, [data, nextPage, previousPage, parsePageParams]);
+  const stableParams = useMemo(
+    () => ({
+      service: resolvedService,
+      type: resolvedType,
+      retriever: params.retriever,
+      retrieverParams: params.retrieverParams,
+      requiresSearch: params.requiresSearch
+    }),
+    [resolvedService, resolvedType, params.retriever, params.retrieverParams, params.requiresSearch]
+  );
+  const fetchData = useCallback2(
+    async (fetchParams) => {
+      if (ready === false) {
+        return;
+      }
+      if (isFetchingRef.current && !fetchParams?.callNext && !fetchParams?.callPrevious) {
+        return;
+      }
+      const thisRequestId = ++requestIdRef.current;
+      isFetchingRef.current = true;
+      if (stableParams.requiresSearch === true && fetchParams?.isRefine !== true && fetchParams?.isRefresh !== true)
+        return;
+      if (!nextPage && !previousPage && isLoaded && fetchParams?.callNext !== true && fetchParams?.callPrevious !== true && params.search === searchTermRef.current)
+        return;
+      const currentSearchTerm = searchTermRef.current;
+      setIsLoaded(false);
+      try {
+        let response;
+        const nextRef = { next: void 0 };
+        const previousRef = { previous: void 0 };
+        const selfRef = { self: void 0 };
+        if (nextPage && fetchParams?.callNext && fetchParams?.isRefine !== true) {
+          const ServiceClass = stableParams.service;
+          response = await ServiceClass.next({
+            type: stableParams.type,
+            endpoint: nextPage,
+            next: nextRef,
+            previous: previousRef,
+            self: selfRef
+          });
+        } else if (previousPage && fetchParams?.callPrevious && fetchParams?.isRefine !== true) {
+          const ServiceClass = stableParams.service;
+          response = await ServiceClass.previous({
+            type: stableParams.type,
+            endpoint: previousPage,
+            next: nextRef,
+            previous: previousRef,
+            self: selfRef
+          });
+        } else {
+          let retrieverParams = stableParams.retrieverParams ? { ...stableParams.retrieverParams } : {};
+          retrieverParams = {
+            ...retrieverParams,
+            ...additionalParamsRef.current
+          };
+          retrieverParams.search = currentSearchTerm;
+          retrieverParams.next = nextRef;
+          retrieverParams.previous = previousRef;
+          retrieverParams.self = selfRef;
+          response = await stableParams.retriever(retrieverParams);
+        }
+        if (thisRequestId === requestIdRef.current && !abortControllerRef.current?.signal.aborted) {
+          if (fetchParams?.isRefresh === true) {
+            setData(response);
+          } else {
+            setData((prevData) => [...prevData ? prevData : [], ...response]);
+          }
+          setIsLoaded(true);
+          setNextPage(nextRef.next ? nextRef.next : void 0);
+          setPreviousPage(previousRef.previous ? previousRef.previous : void 0);
+        }
+      } catch (error) {
+        if (thisRequestId === requestIdRef.current) {
+          setIsLoaded(true);
+          console.error("Error fetching data:", error);
+        }
+      } finally {
+        if (thisRequestId === requestIdRef.current) {
+          isFetchingRef.current = false;
+        }
+      }
+    },
+    [stableParams, ready, params.search]
+  );
+  const setRefreshedElement = useCallback2(
+    (element) => {
+      setData((prevData) => {
+        if (!prevData) return prevData;
+        const index = prevData.findIndex((data2) => data2.id === element.id);
+        if (index === -1) return prevData;
+        return prevData.map((item, i) => i === index ? element : item);
+      });
+    },
+    [setData]
+  );
+  const removeElement = useCallback2(
+    (element) => {
+      setData((prevData) => {
+        if (!prevData) return prevData;
+        const index = prevData.findIndex((data2) => data2.id === element.id);
+        if (index === -1) return prevData;
+        setNextPage((prev) => adjustPaginationUrl(prev, -1));
+        const newData = [...prevData];
+        newData.splice(index, 1);
+        return newData;
+      });
+    },
+    [adjustPaginationUrl]
+  );
+  useEffect(() => {
+    if (ready && !isLoaded) {
+      fetchData({ isRefresh: true });
+    }
+  }, [ready, fetchData]);
+  const loadNext = useCallback2(
+    async (onlyNewRecords) => {
+      if (nextPage) fetchData({ isRefresh: onlyNewRecords, callNext: true });
+    },
+    [fetchData, nextPage]
+  );
+  const loadPrevious = useCallback2(
+    async (onlyNewRecords) => {
+      if (previousPage) fetchData({ isRefresh: onlyNewRecords, callPrevious: true });
+    },
+    [fetchData, previousPage]
+  );
+  const addAdditionalParameter = useCallback2(
+    (key, value) => {
+      if (value === null) {
+        delete additionalParamsRef.current[key];
+      } else {
+        additionalParamsRef.current[key] = value;
+      }
+      setReady(true);
+      setNextPage(void 0);
+      setPreviousPage(void 0);
+      fetchData({ isRefine: true, isRefresh: true });
+    },
+    [fetchData]
+  );
+  const removeAdditionalParameter = useCallback2(
+    (key) => {
+      if (additionalParamsRef.current[key] !== void 0) {
+        delete additionalParamsRef.current[key];
+        setNextPage(void 0);
+        setPreviousPage(void 0);
+        fetchData({ isRefine: true, isRefresh: true });
+      }
+    },
+    [fetchData]
+  );
+  const search = useCallback2(
+    async (search2) => {
+      if (search2 === searchTermRef.current) return;
+      setNextPage(void 0);
+      setPreviousPage(void 0);
+      searchTermRef.current = search2;
+      fetchData({ isRefine: true, isRefresh: true });
+    },
+    [fetchData]
+  );
+  const isSearch = !!searchTermRef.current;
+  const refresh = useCallback2(async () => {
+    setNextPage(void 0);
+    setPreviousPage(void 0);
+    fetchData({ isRefresh: true });
+  }, [fetchData]);
+  useEffect(() => {
+    return () => {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+    };
+  }, []);
+  return {
+    ready,
+    setReady,
+    isLoaded,
+    data,
+    next: nextPage ? loadNext : void 0,
+    previous: previousPage ? loadPrevious : void 0,
+    search,
+    addAdditionalParameter,
+    removeAdditionalParameter,
+    refresh,
+    setRefreshedElement,
+    isSearch,
+    removeElement,
+    pageInfo
+  };
+}
+__name(useDataListRetriever, "useDataListRetriever");
+
+// src/hooks/useDebounce.ts
+import { useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2 } from "react";
+function useDebounce(callback, delay) {
+  const timeoutRef = useRef2(null);
+  const callbackRef = useRef2(callback);
+  useEffect2(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  const debouncedFunction = useCallback3(
+    (...args) => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        callbackRef.current(...args);
+      }, delay);
+    },
+    [delay]
+  );
+  const cancel = /* @__PURE__ */ __name(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+  }, "cancel");
+  return Object.assign(debouncedFunction, { cancel });
+}
+__name(useDebounce, "useDebounce");
+
+// src/hooks/useTableGenerator.ts
+function registerTableGenerator(type, hook) {
+  tableGeneratorRegistry.register(type.name, hook);
+}
+__name(registerTableGenerator, "registerTableGenerator");
+function useTableGenerator(type, params) {
+  return tableGeneratorRegistry.get(type.name, params);
+}
+__name(useTableGenerator, "useTableGenerator");
+
+// src/hooks/useCustomD3Graph.tsx
+import * as d3 from "d3";
+import { Loader2 } from "lucide-react";
+import { useCallback as useCallback4, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef3 } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { jsx } from "react/jsx-runtime";
+function useCustomD3Graph(nodes, links, onNodeClick, visibleNodeIds, loadingNodeIds, containerKey) {
+  const svgRef = useRef3(null);
+  const zoomRef = useRef3(null);
+  const zoomBehaviorRef = useRef3(null);
+  const nodePositionsRef = useRef3(/* @__PURE__ */ new Map());
+  const prevContainerKeyRef = useRef3(containerKey);
+  const zoomToNode = useCallback4(
+    (nodeId, childIds = []) => {
+      if (!svgRef.current || !zoomBehaviorRef.current) return;
+      const svg = d3.select(svgRef.current);
+      const zoom2 = zoomBehaviorRef.current;
+      const targetNode = nodes.find((n) => n.id === nodeId);
+      const childNodes = nodes.filter((n) => childIds.includes(n.id));
+      if (!targetNode) return;
+      const positions = [];
+      if (targetNode.fx !== void 0 && targetNode.fy !== void 0 && targetNode.fx !== null && targetNode.fy !== null) {
+        positions.push({ x: targetNode.fx, y: targetNode.fy });
+      } else if (targetNode.x !== void 0 && targetNode.y !== void 0 && targetNode.x !== null && targetNode.y !== null) {
+        positions.push({ x: targetNode.x, y: targetNode.y });
+      }
+      childNodes.forEach((child) => {
+        if (child.fx !== void 0 && child.fy !== void 0 && child.fx !== null && child.fy !== null) {
+          positions.push({ x: child.fx, y: child.fy });
+        } else if (child.x !== void 0 && child.y !== void 0 && child.x !== null && child.y !== null) {
+          positions.push({ x: child.x, y: child.y });
+        }
+      });
+      if (positions.length === 0) return;
+      const bounds = {
+        xMin: Math.min(...positions.map((p) => p.x)),
+        xMax: Math.max(...positions.map((p) => p.x)),
+        yMin: Math.min(...positions.map((p) => p.y)),
+        yMax: Math.max(...positions.map((p) => p.y))
+      };
+      const padding = 150;
+      bounds.xMin -= padding;
+      bounds.xMax += padding;
+      bounds.yMin -= padding;
+      bounds.yMax += padding;
+      const width = svgRef.current.clientWidth;
+      const height = svgRef.current.clientHeight;
+      const contentWidth = bounds.xMax - bounds.xMin;
+      const contentHeight = bounds.yMax - bounds.yMin;
+      const scaleX = width / contentWidth;
+      const scaleY = height / contentHeight;
+      let scale = Math.min(scaleX, scaleY);
+      scale = Math.min(Math.max(scale, 0.2), 1.5);
+      const centerX = (bounds.xMin + bounds.xMax) / 2;
+      const centerY = (bounds.yMin + bounds.yMax) / 2;
+      const translateX = width / 2 - centerX * scale;
+      const translateY = height / 2 - centerY * scale;
+      svg.transition().duration(750).call(zoom2.transform, d3.zoomIdentity.translate(translateX, translateY).scale(scale));
+    },
+    [nodes]
+  );
+  const colorScale = useMemo2(() => {
+    const accentColor = "var(--accent)";
+    const contentColor = "hsl(30, 80%, 55%)";
+    const groupTypes = /* @__PURE__ */ new Set();
+    nodes.forEach((node) => {
+      groupTypes.add(node.instanceType);
+    });
+    const typeColorMap = /* @__PURE__ */ new Map();
+    Array.from(groupTypes).forEach((type, index) => {
+      if (type === nodes[0]?.instanceType) {
+        typeColorMap.set(type, accentColor);
+      } else if (type === "documents" || type === "articles" || type === "hyperlinks") {
+        typeColorMap.set(type, contentColor);
+      } else {
+        const hueShift = index * 137.508 % 360;
+        typeColorMap.set(type, `hsl(${hueShift}, 32%, 52%)`);
+      }
+    });
+    return typeColorMap;
+  }, [nodes]);
+  const washOutColor = useCallback4((color) => {
+    const hslMatch = color.match(/hsl\((\d+\.?\d*),\s*(\d+\.?\d*)%,\s*(\d+\.?\d*)%\)/);
+    if (hslMatch) {
+      const hue = parseFloat(hslMatch[1]);
+      return `hsl(${hue}, 15%, 80%)`;
+    }
+    if (color.includes("var(--accent)")) {
+      return "hsl(0, 0%, 80%)";
+    }
+    return "hsl(0, 0%, 80%)";
+  }, []);
+  const getNodeColor = useCallback4(
+    (node) => {
+      const baseColor = colorScale.get(node.instanceType) || "gray";
+      if (node.washedOut) {
+        return washOutColor(baseColor);
+      }
+      return baseColor;
+    },
+    [colorScale, washOutColor]
+  );
+  useEffect3(() => {
+    if (!nodes.length || !svgRef.current) return;
+    const visibleNodes = visibleNodeIds ? nodes.filter((node2) => visibleNodeIds.has(node2.id)) : nodes.filter((node2) => node2.visible !== false);
+    const visibleNodeIdSet = new Set(visibleNodes.map((node2) => node2.id));
+    const visibleLinks = links.filter((link2) => {
+      const sourceId = typeof link2.source === "string" ? link2.source : link2.source.id;
+      const targetId = typeof link2.target === "string" ? link2.target : link2.target.id;
+      return visibleNodeIdSet.has(sourceId) && visibleNodeIdSet.has(targetId);
+    });
+    const svg = d3.select(svgRef.current);
+    svg.selectAll("*").remove();
+    const container = svgRef.current?.parentElement;
+    if (!container) return;
+    const width = container.clientWidth;
+    const height = container.clientHeight;
+    svg.attr("width", width).attr("height", height).attr("viewBox", `0 0 ${width} ${height}`);
+    const graphGroup = svg.append("g").attr("class", "graph-content");
+    const zoom2 = d3.zoom().scaleExtent([0.1, 4]).on("zoom", (event) => {
+      const transform = event.transform;
+      graphGroup.attr("transform", transform.toString());
+      zoomRef.current = transform;
+    });
+    zoomBehaviorRef.current = zoom2;
+    svg.call(zoom2).on("wheel.zoom", null).on("dblclick.zoom", null);
+    const nodeRadius = 40;
+    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);
+      }
+    });
+    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;
+          }
+        } 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 });
+        }
+      }
+    });
+    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;
+      }
+    });
+    const link = graphGroup.append("g").attr("stroke", "#999").attr("stroke-opacity", 0.6).selectAll("line").data(visibleLinks).join("line").attr("x1", (d) => d.source.x || 0).attr("y1", (d) => d.source.y || 0).attr("x2", (d) => d.target.x || 0).attr("y2", (d) => d.target.y || 0).attr("stroke-width", 1.5);
+    const node = graphGroup.append("g").selectAll("g").data(visibleNodes).join("g").attr("class", "node-group").attr("cursor", "pointer").attr("transform", (d) => `translate(${d.x || 0}, ${d.y || 0})`).call(
+      d3.drag().subject(function(d) {
+        return d;
+      }).on("start", function(event, d) {
+        d.fx = d.x;
+        d.fy = d.y;
+      }).on("drag", function(event, d) {
+        d.fx = event.x;
+        d.fy = event.y;
+        d3.select(this).attr("transform", `translate(${event.x}, ${event.y})`);
+        d3.select(this).attr("transform", `translate(${event.x}, ${event.y})`);
+        nodePositionsRef.current.set(d.id, { x: event.x, y: event.y });
+        link.attr("x1", (l) => {
+          const source = l.source;
+          return source.fx || source.x || 0;
+        }).attr("y1", (l) => {
+          const source = l.source;
+          return source.fy || source.y || 0;
+        }).attr("x2", (l) => {
+          const target = l.target;
+          return target.fx || target.x || 0;
+        }).attr("y2", (l) => {
+          const target = l.target;
+          return target.fy || target.y || 0;
+        });
+      }).on("end", function(event, d) {
+        d.fx = event.x;
+        d.fy = event.y;
+      })
+    ).on("mouseenter", function(_event, d) {
+      if (d.instanceType === "root") return;
+      const currentNode = d3.select(this);
+      currentNode.raise();
+      const currentZoom = zoomRef.current?.k || 1;
+      const targetScreenFontSize = 20;
+      const baseFontSize = 12;
+      const textScale = targetScreenFontSize / (baseFontSize * currentZoom);
+      const hoverTextOffset = nodeRadius * 1.4 + 5 / currentZoom;
+      currentNode.select("circle").transition().duration(250).ease(d3.easeExpOut).attr("r", nodeRadius * 1.4).attr("filter", "drop-shadow(0px 4px 12px rgba(0, 0, 0, 0.3))");
+      currentNode.select("text").transition().duration(250).ease(d3.easeExpOut).attr("dy", -hoverTextOffset).attr("transform", `translate(0, ${-hoverTextOffset}) scale(${textScale}) translate(0, ${hoverTextOffset})`);
+    }).on("mouseleave", function(_event, d) {
+      if (d.instanceType === "root") return;
+      const currentNode = d3.select(this);
+      currentNode.select("circle").transition().duration(250).ease(d3.easeExpOut).attr("r", nodeRadius).attr("filter", null);
+      const normalOffset = nodeRadius + 5;
+      currentNode.select("text").transition().duration(250).ease(d3.easeExpOut).attr("dy", -normalOffset).attr("transform", `translate(0, ${-normalOffset}) scale(1) translate(0, ${normalOffset})`);
+    });
+    node.append("circle").attr("r", nodeRadius).attr("fill", (d) => getNodeColor(d)).attr("stroke", "#fff").attr("stroke-width", 1.5).on("click", (event, d) => {
+      event.preventDefault();
+      event.stopPropagation();
+      if (zoomBehaviorRef.current) {
+        svg.on(".zoom", null);
+        setTimeout(() => {
+          if (zoomBehaviorRef.current) {
+            svg.call(zoomBehaviorRef.current).on("wheel.zoom", null).on("dblclick.zoom", null);
+          }
+        }, 100);
+      }
+      onNodeClick(d.id);
+    });
+    node.each(function(d) {
+      if (d.icon) {
+        const Icon = d.icon;
+        const iconSvg = renderToStaticMarkup(/* @__PURE__ */ jsx(Icon, { size: nodeRadius / 2, color: "white" }));
+        const iconGroup = d3.select(this).append("g").html(iconSvg).attr("transform", `translate(${-nodeRadius / 4}, ${-nodeRadius / 4})`).style("pointer-events", "all").on("click", (event) => {
+          event.stopPropagation();
+          onNodeClick(d.id);
+        });
+      }
+    });
+    node.each(function(d) {
+      if (loadingNodeIds && loadingNodeIds.has(d.id)) {
+        d3.select(this).selectAll("g").remove();
+        const spinnerSvg = renderToStaticMarkup(/* @__PURE__ */ jsx(Loader2, { size: nodeRadius / 2, color: "white" }));
+        d3.select(this).append("g").html(spinnerSvg).attr("class", "animate-spin").attr("transform", `translate(${-nodeRadius / 4}, ${-nodeRadius / 4})`).style("pointer-events", "none");
+      }
+    });
+    node.each(function(d) {
+      const textElement = d3.select(this).append("text").attr("text-anchor", "middle").attr("font-size", 12).attr("pointer-events", "none");
+      if (d.instanceType === "root") {
+        const words = d.name.split(" ");
+        const lineHeight = 1.2;
+        const numLines = words.length;
+        const startY = -((numLines - 1) * lineHeight) / 2;
+        textElement.attr("fill", "var(--accent-foreground)").attr("dominant-baseline", "middle");
+        words.forEach((word, index) => {
+          textElement.append("tspan").attr("x", 0).attr("dy", index === 0 ? `${startY}em` : `${lineHeight}em`).text(word);
+        });
+      } else {
+        textElement.attr("dy", -nodeRadius - 5).attr("fill", "currentColor").text(d.name);
+      }
+    });
+    return () => {
+      simulation.stop();
+    };
+  }, [nodes, links, colorScale, visibleNodeIds, loadingNodeIds, onNodeClick]);
+  const zoomIn = useCallback4(() => {
+    if (!svgRef.current || !zoomBehaviorRef.current) return;
+    const svg = d3.select(svgRef.current);
+    const zoom2 = zoomBehaviorRef.current;
+    const currentTransform = zoomRef.current || d3.zoomIdentity;
+    const newScale = Math.min(currentTransform.k * 1.3, 4);
+    svg.transition().duration(300).call(zoom2.transform, d3.zoomIdentity.translate(currentTransform.x, currentTransform.y).scale(newScale));
+  }, []);
+  const zoomOut = useCallback4(() => {
+    if (!svgRef.current || !zoomBehaviorRef.current) return;
+    const svg = d3.select(svgRef.current);
+    const zoom2 = zoomBehaviorRef.current;
+    const currentTransform = zoomRef.current || d3.zoomIdentity;
+    const newScale = Math.max(currentTransform.k * 0.7, 0.1);
+    svg.transition().duration(300).call(zoom2.transform, d3.zoomIdentity.translate(currentTransform.x, currentTransform.y).scale(newScale));
+  }, []);
+  const zoomToFitAll = useCallback4(() => {
+    if (!svgRef.current || !zoomBehaviorRef.current) return;
+    const svg = d3.select(svgRef.current);
+    const zoom2 = zoomBehaviorRef.current;
+    const visibleNodes = visibleNodeIds ? nodes.filter((node) => visibleNodeIds.has(node.id)) : nodes.filter((node) => node.visible !== false);
+    if (visibleNodes.length === 0) return;
+    const positions = [];
+    visibleNodes.forEach((node) => {
+      if (node.fx !== void 0 && node.fy !== void 0 && node.fx !== null && node.fy !== null) {
+        positions.push({ x: node.fx, y: node.fy });
+      } else if (node.x !== void 0 && node.y !== void 0 && node.x !== null && node.y !== null) {
+        positions.push({ x: node.x, y: node.y });
+      }
+    });
+    if (positions.length === 0) return;
+    const bounds = {
+      xMin: Math.min(...positions.map((p) => p.x)),
+      xMax: Math.max(...positions.map((p) => p.x)),
+      yMin: Math.min(...positions.map((p) => p.y)),
+      yMax: Math.max(...positions.map((p) => p.y))
+    };
+    const padding = 150;
+    bounds.xMin -= padding;
+    bounds.xMax += padding;
+    bounds.yMin -= padding;
+    bounds.yMax += padding;
+    const width = svgRef.current.clientWidth;
+    const height = svgRef.current.clientHeight;
+    const contentWidth = bounds.xMax - bounds.xMin;
+    const contentHeight = bounds.yMax - bounds.yMin;
+    const scaleX = width / contentWidth;
+    const scaleY = height / contentHeight;
+    let scale = Math.min(scaleX, scaleY);
+    scale = Math.min(Math.max(scale, 0.1), 2);
+    const centerX = (bounds.xMin + bounds.xMax) / 2;
+    const centerY = (bounds.yMin + bounds.yMax) / 2;
+    const translateX = width / 2 - centerX * scale;
+    const translateY = height / 2 - centerY * scale;
+    svg.transition().duration(750).call(zoom2.transform, d3.zoomIdentity.translate(translateX, translateY).scale(scale));
+  }, [nodes, visibleNodeIds]);
+  useEffect3(() => {
+    if (containerKey !== void 0 && containerKey !== prevContainerKeyRef.current) {
+      const timeoutId = setTimeout(() => {
+        zoomToFitAll();
+      }, 100);
+      prevContainerKeyRef.current = containerKey;
+      return () => clearTimeout(timeoutId);
+    }
+  }, [containerKey, zoomToFitAll]);
+  return { svgRef, zoomIn, zoomOut, zoomToNode, zoomToFitAll };
+}
+__name(useCustomD3Graph, "useCustomD3Graph");
+
+export {
+  TableGeneratorRegistry,
+  tableGeneratorRegistry,
+  usePageUrlGenerator,
+  useUrlRewriter,
+  useDataListRetriever,
+  useDebounce,
+  registerTableGenerator,
+  useTableGenerator,
+  useCustomD3Graph
+};
+//# sourceMappingURL=chunk-WWWMJZEF.mjs.map