@chartts/core 0.1.4 → 0.1.5

package/dist/{chunk-LRHMLNPW.js → chunk-XB5K7OYD.js}

@@ -1,5 +1,5 @@
-import { prepareNoAxes } from './chunk-T7SCCACB.js';
-import { group, line, PathBuilder, path, rect, text, circle } from './chunk-AEQXFDL7.js';
+import { prepareNoAxes } from './chunk-LKSKGQX7.js';
+import { line, circle, text, group, PathBuilder, path, rect } from './chunk-XIVC32HU.js';
 
 // src/charts/graph/parse.ts
 function parseGraphData(data, options) {
@@ -422,46 +422,32 @@ function renderEdges(nodes, edges, options, theme) {
 }
 
 // src/charts/graph/layout-force.ts
-var layoutCache = /* @__PURE__ */ new Map();
-function cacheKey(nodes, edges) {
-  const nk = nodes.map((n) => n.id).join(",");
-  const ek = edges.map((e) => `${e.source}-${e.target}`).join(",");
-  return nk + "|" + ek;
-}
 function forceLayout(nodes, edges, opts) {
   const { area, iterations } = opts;
   const n = nodes.length;
   if (n === 0) return;
   const cx = area.x + area.width / 2;
   const cy = area.y + area.height / 2;
-  const key = cacheKey(nodes, edges);
-  const cached = layoutCache.get(key);
-  if (cached && cached.length === n) {
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-      if (!node.pin) {
-        node.x = cached[i].x;
-        node.y = cached[i].y;
-      }
-    }
-  } else {
-    for (let i = 0; i < n; i++) {
-      const node = nodes[i];
-      if (node.pin) {
-        node.x = area.x + node.pin.x * area.width;
-        node.y = area.y + node.pin.y * area.height;
-      } else {
-        const angle = 2 * Math.PI * i / n;
-        const r = Math.min(area.width, area.height) * 0.3;
-        node.x = cx + r * Math.cos(angle);
-        node.y = cy + r * Math.sin(angle);
-      }
-      node.vx = 0;
-      node.vy = 0;
+  for (let i = 0; i < n; i++) {
+    const node = nodes[i];
+    if (node.pin) {
+      node.x = area.x + node.pin.x * area.width;
+      node.y = area.y + node.pin.y * area.height;
+    } else {
+      const angle = 2 * Math.PI * i / n;
+      const r = Math.min(area.width, area.height) * 0.4;
+      node.x = cx + r * Math.cos(angle);
+      node.y = cy + r * Math.sin(angle);
     }
+    node.vx = 0;
+    node.vy = 0;
   }
-  const k = Math.sqrt(area.width * area.height / Math.max(n, 1));
-  const repulsion = k * k;
+  const avgNodeSize = nodes.reduce((s, nd) => s + Math.max(nd.width, nd.height), 0) / n;
+  const k = Math.max(
+    Math.sqrt(area.width * area.height / Math.max(n, 1)),
+    avgNodeSize * 2
+  );
+  const repulsion = k * k * 1.5;
   for (let iter = 0; iter < iterations; iter++) {
     const temp = 0.1 * (1 - iter / iterations) * Math.min(area.width, area.height) * 0.5;
     for (const node of nodes) {
@@ -475,8 +461,10 @@ function forceLayout(nodes, edges, opts) {
         const dx = ni.x - nj.x;
         const dy = ni.y - nj.y;
         const dist = Math.max(Math.sqrt(dx * dx + dy * dy), 1);
-        const minDist = (Math.max(ni.width, ni.height) + Math.max(nj.width, nj.height)) / 2;
-        const effectiveDist = Math.max(dist - minDist * 0.6, 1);
+        const ri = Math.sqrt(ni.width * ni.width + ni.height * ni.height) / 2;
+        const rj = Math.sqrt(nj.width * nj.width + nj.height * nj.height) / 2;
+        const minDist = ri + rj + 12;
+        const effectiveDist = Math.max(dist - minDist * 0.5, 1);
         const force = repulsion / (effectiveDist * effectiveDist);
         const fx = dx / dist * force;
         const fy = dy / dist * force;
@@ -493,8 +481,8 @@ function forceLayout(nodes, edges, opts) {
       const dy = tgt.y - src.y;
       const dist = Math.max(Math.sqrt(dx * dx + dy * dy), 1);
       const force = dist * dist / k;
-      const fx = dx / dist * force * 0.1;
-      const fy = dy / dist * force * 0.1;
+      const fx = dx / dist * force * 0.08;
+      const fy = dy / dist * force * 0.08;
       src.vx += fx;
       src.vy += fy;
       tgt.vx -= fx;
@@ -522,7 +510,39 @@ function forceLayout(nodes, edges, opts) {
       node.y = Math.max(area.y + my, Math.min(area.y + area.height - my, node.y));
     }
   }
-  layoutCache.set(key, nodes.map((nd) => ({ x: nd.x, y: nd.y })));
+  for (let pass = 0; pass < 10; pass++) {
+    let moved = false;
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        const ni = nodes[i];
+        const nj = nodes[j];
+        if (ni.pin && nj.pin) continue;
+        const overlapX = (ni.width + nj.width) / 2 + 8 - Math.abs(ni.x - nj.x);
+        const overlapY = (ni.height + nj.height) / 2 + 8 - Math.abs(ni.y - nj.y);
+        if (overlapX <= 0 || overlapY <= 0) continue;
+        const pushX = overlapX < overlapY;
+        const push = (pushX ? overlapX : overlapY) / 2 + 1;
+        if (pushX) {
+          const dir = ni.x >= nj.x ? 1 : -1;
+          if (!ni.pin) ni.x += dir * push;
+          if (!nj.pin) nj.x -= dir * push;
+        } else {
+          const dir = ni.y >= nj.y ? 1 : -1;
+          if (!ni.pin) ni.y += dir * push;
+          if (!nj.pin) nj.y -= dir * push;
+        }
+        moved = true;
+      }
+    }
+    if (!moved) break;
+    for (const node of nodes) {
+      if (node.pin) continue;
+      const mx = Math.max(20, node.width / 2 + 5);
+      const my = Math.max(20, node.height / 2 + 5);
+      node.x = Math.max(area.x + mx, Math.min(area.x + area.width - mx, node.x));
+      node.y = Math.max(area.y + my, Math.min(area.y + area.height - my, node.y));
+    }
+  }
 }
 
 // src/charts/graph/layout-hierarchy.ts
@@ -541,46 +561,56 @@ function hierarchyLayout(nodes, edges, opts) {
   const layers = assignLayers(n, outgoing, incoming);
   const layerGroups = groupByLayer(layers, n);
   orderLayers(layerGroups, outgoing, incoming, 3);
-  const isHorizontal = direction === "LR" || direction === "RL";
   const maxLayer = Math.max(...layers, 0);
-  const availW = area.width;
-  const availH = area.height;
   const layerCount = maxLayer + 1;
-  const layerGap = isHorizontal ? availW / (layerCount + 1) : availH / (layerCount + 1);
+  const isVertical = direction === "TB" || direction === "BT";
+  const layerThickness = new Array(layerCount).fill(0);
+  for (let layer = 0; layer < layerCount; layer++) {
+    const grp = layerGroups[layer] ?? [];
+    for (const idx of grp) {
+      const nd = nodes[idx];
+      const thick = isVertical ? nd.height : nd.width;
+      if (thick > layerThickness[layer]) layerThickness[layer] = thick;
+    }
+  }
+  const gap = 24;
+  const totalThickness = layerThickness.reduce((s, t) => s + t, 0) + gap * (layerCount - 1);
+  const availableThickness = isVertical ? area.height : area.width;
+  const scale = totalThickness > availableThickness ? availableThickness / totalThickness : 1;
+  const layerCenter = new Array(layerCount).fill(0);
+  const usedThickness = totalThickness * scale;
+  const offset = (availableThickness - usedThickness) / 2;
+  let cursor = offset + layerThickness[0] * scale / 2;
+  layerCenter[0] = cursor;
+  for (let layer = 1; layer < layerCount; layer++) {
+    cursor += layerThickness[layer - 1] * scale / 2 + gap * scale + layerThickness[layer] * scale / 2;
+    layerCenter[layer] = cursor;
+  }
+  if (direction === "BT" || direction === "RL") {
+    layerCenter.reverse();
+  }
   for (let layer = 0; layer <= maxLayer; layer++) {
-    const group2 = layerGroups[layer] ?? [];
-    if (group2.length === 0) continue;
-    const nodeGap = isHorizontal ? availH / (group2.length + 1) : availW / (group2.length + 1);
-    for (let pos = 0; pos < group2.length; pos++) {
-      const node = nodes[group2[pos]];
+    const grp = layerGroups[layer] ?? [];
+    if (grp.length === 0) continue;
+    for (let pos = 0; pos < grp.length; pos++) {
+      const node = nodes[grp[pos]];
       if (node.pin) {
         node.x = area.x + node.pin.x * area.width;
         node.y = area.y + node.pin.y * area.height;
         continue;
       }
-      let layerCoord = area.x + layerGap * (layer + 1);
-      let posCoord = area.y + nodeGap * (pos + 1);
-      if (isHorizontal) ; else {
-        const tmp = layerCoord;
-        layerCoord = posCoord;
-        posCoord = tmp;
-      }
+      const posFrac = (pos + 1) / (grp.length + 1);
+      const layerPos = layerCenter[layer];
       switch (direction) {
         case "TB":
-          node.x = layerCoord;
-          node.y = posCoord;
-          break;
         case "BT":
-          node.x = layerCoord;
-          node.y = area.y + area.height - (posCoord - area.y);
+          node.x = area.x + posFrac * area.width;
+          node.y = area.y + layerPos;
           break;
         case "LR":
-          node.x = layerCoord;
-          node.y = posCoord;
-          break;
         case "RL":
-          node.x = area.x + area.width - (layerCoord - area.x);
-          node.y = posCoord;
+          node.x = area.x + layerPos;
+          node.y = area.y + posFrac * area.height;
           break;
       }
     }
@@ -707,23 +737,40 @@ function circularLayout(nodes, edges, opts) {
   const { area } = opts;
   const cx = area.x + area.width / 2;
   const cy = area.y + area.height / 2;
-  const maxNodeSize = Math.max(
-    ...nodes.map((nd) => Math.max(nd.width, nd.height)),
-    40
-  );
-  const radius = Math.min(area.width, area.height) / 2 - maxNodeSize / 2 - 10;
   const order = connectivityOrder(nodes, edges);
   const unpinned = [];
   for (const idx of order) {
     if (!nodes[idx].pin) unpinned.push(idx);
   }
-  const angleStep = 2 * Math.PI / Math.max(unpinned.length, 1);
+  const count = Math.max(unpinned.length, 1);
+  const angleStep = 2 * Math.PI / count;
+  const maxNodeW = Math.max(...nodes.map((nd) => nd.width), 40);
+  const maxNodeH = Math.max(...nodes.map((nd) => nd.height), 40);
+  const margin = 10;
+  let rx = area.width / 2 - maxNodeW / 2 - margin;
+  let ry = area.height / 2 - maxNodeH / 2 - margin;
+  if (count > 1) {
+    const maxDiag = Math.max(
+      ...nodes.map((nd) => Math.sqrt(nd.width * nd.width + nd.height * nd.height)),
+      40
+    );
+    const minSpacing = maxDiag + 16;
+    const perimApprox = Math.PI * (3 * (rx + ry) - Math.sqrt((3 * rx + ry) * (rx + 3 * ry)));
+    const spacingPerNode = perimApprox / count;
+    if (spacingPerNode < minSpacing) {
+      const scale = minSpacing / spacingPerNode;
+      rx *= scale;
+      ry *= scale;
+    }
+  }
+  rx = Math.max(20, Math.min(rx, area.width / 2 - margin));
+  ry = Math.max(20, Math.min(ry, area.height / 2 - margin));
   const startAngle = -Math.PI / 2;
   for (let i = 0; i < unpinned.length; i++) {
     const node = nodes[unpinned[i]];
     const angle = startAngle + angleStep * i;
-    node.x = cx + radius * Math.cos(angle);
-    node.y = cy + radius * Math.sin(angle);
+    node.x = cx + rx * Math.cos(angle);
+    node.y = cy + ry * Math.sin(angle);
   }
   for (const node of nodes) {
     if (node.pin) {
@@ -791,52 +838,133 @@ var graphChartType = {
   render(ctx) {
     const { data, area, theme, options } = ctx;
     const graphOpts = options;
-    const result = [];
-    const { graphNodes, graphEdges } = parseGraphData(data, options);
-    if (graphNodes.length === 0) return result;
-    for (const node of graphNodes) {
-      const size = measureNodeSize(node.label, theme.fontSizeSmall, node.shape);
-      node.width = size.width;
-      node.height = size.height;
-    }
-    runLayout(graphNodes, graphEdges, graphOpts, area);
-    const edgeNodes = renderEdges(graphNodes, graphEdges, graphOpts, theme);
-    if (edgeNodes.length > 0) {
-      result.push(group(edgeNodes, { class: "chartts-graph-edges" }));
-    }
-    for (const node of graphNodes) {
-      const color = node.color ?? options.colors[node.index % options.colors.length];
-      const shapeNodes = renderNodeShape(node, color, theme);
-      result.push(group(shapeNodes, {
-        class: `chartts-series chartts-series-${node.index}`,
-        "data-series-name": node.label
+    if (graphOpts.nodes || graphOpts.edges) {
+      return renderRichGraph(ctx);
+    }
+    const nodes = [];
+    const { graphNodes, graphEdges } = parseLegacyGraphData(data);
+    if (graphNodes.length === 0) return nodes;
+    forceLayout2(graphNodes, graphEdges, area, 80);
+    for (let ei = 0; ei < graphEdges.length; ei++) {
+      const edge = graphEdges[ei];
+      const src = graphNodes[edge.source];
+      const tgt = graphNodes[edge.target];
+      nodes.push(line(src.x, src.y, tgt.x, tgt.y, {
+        class: "chartts-graph-edge",
+        stroke: theme.gridColor,
+        strokeWidth: Math.max(1, Math.min(3, edge.weight * 0.5)),
+        opacity: 0.5
       }));
     }
-    return result;
+    const maxVal = Math.max(...graphNodes.map((n) => n.value), 1);
+    const minR = 5;
+    const maxR = Math.min(20, Math.min(area.width, area.height) * 0.06);
+    for (let ni = 0; ni < graphNodes.length; ni++) {
+      const gn = graphNodes[ni];
+      const color = options.colors[ni % options.colors.length];
+      const r = minR + gn.value / maxVal * (maxR - minR);
+      const nodeGroup = [];
+      nodeGroup.push(circle(gn.x, gn.y, r, {
+        class: "chartts-graph-node",
+        fill: color,
+        fillOpacity: 0.85,
+        stroke: color,
+        strokeWidth: 1.5,
+        "data-series": ni,
+        "data-index": 0,
+        tabindex: 0,
+        role: "img",
+        ariaLabel: `${gn.name}: ${gn.value}`
+      }));
+      nodeGroup.push(text(gn.x, gn.y - r - 5, gn.name, {
+        class: "chartts-graph-label",
+        fill: theme.textColor,
+        textAnchor: "middle",
+        dominantBaseline: "auto",
+        fontSize: theme.fontSizeSmall,
+        fontFamily: theme.fontFamily
+      }));
+      nodes.push(group(nodeGroup, {
+        class: `chartts-series chartts-series-${ni}`,
+        "data-series-name": gn.name
+      }));
+    }
+    return nodes;
   },
   hitTest(ctx, mx, my) {
-    const { data, area, theme, options } = ctx;
+    const { data, area, options } = ctx;
     const graphOpts = options;
-    const { graphNodes, graphEdges } = parseGraphData(data, options);
-    if (graphNodes.length === 0) return null;
-    for (const node of graphNodes) {
-      const size = measureNodeSize(node.label, theme.fontSizeSmall, node.shape);
-      node.width = size.width;
-      node.height = size.height;
+    if (graphOpts.nodes || graphOpts.edges) {
+      return richHitTest(ctx, mx, my);
     }
-    runLayout(graphNodes, graphEdges, graphOpts, area);
+    const { graphNodes, graphEdges } = parseLegacyGraphData(data);
+    if (graphNodes.length === 0) return null;
+    forceLayout2(graphNodes, graphEdges, area, 80);
+    const maxVal = Math.max(...graphNodes.map((n) => n.value), 1);
+    const minR = 5;
+    const maxR = Math.min(20, Math.min(area.width, area.height) * 0.06);
     let best = null;
     let bestDist = Infinity;
-    for (const node of graphNodes) {
-      const dist = shapeDistance(node, mx, my);
-      if (dist < bestDist && dist < 8) {
+    for (let ni = 0; ni < graphNodes.length; ni++) {
+      const gn = graphNodes[ni];
+      const r = minR + gn.value / maxVal * (maxR - minR);
+      const dist = Math.sqrt((mx - gn.x) ** 2 + (my - gn.y) ** 2);
+      if (dist < bestDist && dist < r + 8) {
         bestDist = dist;
-        best = { seriesIndex: node.index, pointIndex: 0, distance: dist, x: node.x, y: node.y };
+        best = { seriesIndex: ni, pointIndex: 0, distance: dist, x: gn.x, y: gn.y };
       }
     }
     return best;
   }
 };
+function renderRichGraph(ctx) {
+  const { data, area, theme, options } = ctx;
+  const graphOpts = options;
+  const result = [];
+  const { graphNodes, graphEdges } = parseGraphData(data, options);
+  if (graphNodes.length === 0) return result;
+  for (const node of graphNodes) {
+    const size = measureNodeSize(node.label, theme.fontSizeSmall, node.shape);
+    node.width = size.width;
+    node.height = size.height;
+  }
+  runLayout(graphNodes, graphEdges, graphOpts, area);
+  const edgeNodes = renderEdges(graphNodes, graphEdges, graphOpts, theme);
+  if (edgeNodes.length > 0) {
+    result.push(group(edgeNodes, { class: "chartts-graph-edges" }));
+  }
+  for (const node of graphNodes) {
+    const color = node.color ?? options.colors[node.index % options.colors.length];
+    const shapeNodes = renderNodeShape(node, color, theme);
+    result.push(group(shapeNodes, {
+      class: `chartts-series chartts-series-${node.index}`,
+      "data-series-name": node.label
+    }));
+  }
+  return result;
+}
+function richHitTest(ctx, mx, my) {
+  const { data, area, theme, options } = ctx;
+  const graphOpts = options;
+  const { graphNodes, graphEdges } = parseGraphData(data, options);
+  if (graphNodes.length === 0) return null;
+  for (const node of graphNodes) {
+    const size = measureNodeSize(node.label, theme.fontSizeSmall, node.shape);
+    node.width = size.width;
+    node.height = size.height;
+  }
+  runLayout(graphNodes, graphEdges, graphOpts, area);
+  let best = null;
+  let bestDist = Infinity;
+  for (const node of graphNodes) {
+    const dist = shapeDistance(node, mx, my);
+    if (dist < bestDist && dist < 8) {
+      bestDist = dist;
+      best = { seriesIndex: node.index, pointIndex: 0, distance: dist, x: node.x, y: node.y };
+    }
+  }
+  return best;
+}
 function runLayout(nodes, edges, opts, area) {
   const layout = opts.layout ?? "force";
   switch (layout) {
@@ -881,7 +1009,6 @@ function shapeDistance(node, mx, my) {
       const d = dx * dx / (rx * rx) + dy * dy / (ry * ry);
       return d <= 1 ? 0 : Math.sqrt(dx * dx + dy * dy) * (Math.sqrt(d) - 1);
     }
-    // rect, stadium
     default: {
       const hw = node.width / 2;
       const hh = node.height / 2;
@@ -891,7 +1018,125 @@ function shapeDistance(node, mx, my) {
     }
   }
 }
+function parseLegacyGraphData(data, _options) {
+  const graphNodes = [];
+  const graphEdges = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  function getOrCreateNode(name, value = 1) {
+    if (nodeMap.has(name)) return nodeMap.get(name);
+    const idx = graphNodes.length;
+    nodeMap.set(name, idx);
+    graphNodes.push({
+      name,
+      index: idx,
+      value,
+      x: 0,
+      y: 0,
+      vx: 0,
+      vy: 0
+    });
+    return idx;
+  }
+  const hasArrows = data.series.some((s) => s.name.includes("\u2192") || s.name.includes("->"));
+  if (hasArrows) {
+    for (const series of data.series) {
+      const parts = series.name.split(/\s*(?:→|->)\s*/);
+      if (parts.length < 2) continue;
+      const srcName = parts[0].trim();
+      const tgtName = parts[1].trim();
+      const weight = series.values[0] ?? 1;
+      const src = getOrCreateNode(srcName);
+      const tgt = getOrCreateNode(tgtName);
+      graphEdges.push({ source: src, target: tgt, weight });
+      graphNodes[src].value += weight;
+      graphNodes[tgt].value += weight;
+    }
+  } else {
+    for (let i = 0; i < data.labels.length; i++) {
+      getOrCreateNode(String(data.labels[i]), Math.abs(data.series[0]?.values[i] ?? 1));
+    }
+    if (data.series.length > 1 && data.series.length === data.labels.length) {
+      for (let si = 0; si < data.series.length; si++) {
+        for (let j = 0; j < data.series[si].values.length; j++) {
+          const val = data.series[si].values[j];
+          if (val > 0 && si !== j) {
+            graphEdges.push({ source: si, target: j, weight: val });
+          }
+        }
+      }
+    }
+  }
+  return { graphNodes, graphEdges };
+}
+function forceLayout2(nodes, edges, area, iterations) {
+  const cx = area.x + area.width / 2;
+  const cy = area.y + area.height / 2;
+  const n = nodes.length;
+  if (n === 0) return;
+  for (let i = 0; i < n; i++) {
+    const angle = 2 * Math.PI * i / n;
+    const r = Math.min(area.width, area.height) * 0.3;
+    nodes[i].x = cx + r * Math.cos(angle);
+    nodes[i].y = cy + r * Math.sin(angle);
+    nodes[i].vx = 0;
+    nodes[i].vy = 0;
+  }
+  const k = Math.sqrt(area.width * area.height / Math.max(n, 1));
+  const repulsion = k * k;
+  for (let iter = 0; iter < iterations; iter++) {
+    const temp = 0.1 * (1 - iter / iterations) * Math.min(area.width, area.height) * 0.5;
+    for (const node of nodes) {
+      node.vx = 0;
+      node.vy = 0;
+    }
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        const dx = nodes[i].x - nodes[j].x;
+        const dy = nodes[i].y - nodes[j].y;
+        const dist = Math.max(Math.sqrt(dx * dx + dy * dy), 1);
+        const force = repulsion / (dist * dist);
+        const fx = dx / dist * force;
+        const fy = dy / dist * force;
+        nodes[i].vx += fx;
+        nodes[i].vy += fy;
+        nodes[j].vx -= fx;
+        nodes[j].vy -= fy;
+      }
+    }
+    for (const edge of edges) {
+      const src = nodes[edge.source];
+      const tgt = nodes[edge.target];
+      const dx = tgt.x - src.x;
+      const dy = tgt.y - src.y;
+      const dist = Math.max(Math.sqrt(dx * dx + dy * dy), 1);
+      const force = dist * dist / k;
+      const fx = dx / dist * force * 0.1;
+      const fy = dy / dist * force * 0.1;
+      src.vx += fx;
+      src.vy += fy;
+      tgt.vx -= fx;
+      tgt.vy -= fy;
+    }
+    for (const node of nodes) {
+      const dx = cx - node.x;
+      const dy = cy - node.y;
+      node.vx += dx * 0.01;
+      node.vy += dy * 0.01;
+    }
+    for (const node of nodes) {
+      const speed = Math.sqrt(node.vx * node.vx + node.vy * node.vy);
+      if (speed > 0) {
+        const capped = Math.min(speed, temp);
+        node.x += node.vx / speed * capped;
+        node.y += node.vy / speed * capped;
+      }
+      const margin = 20;
+      node.x = Math.max(area.x + margin, Math.min(area.x + area.width - margin, node.x));
+      node.y = Math.max(area.y + margin, Math.min(area.y + area.height - margin, node.y));
+    }
+  }
+}
 
 export { graphChartType };
-//# sourceMappingURL=chunk-LRHMLNPW.js.map
-//# sourceMappingURL=chunk-LRHMLNPW.js.map
+//# sourceMappingURL=chunk-XB5K7OYD.js.map
+//# sourceMappingURL=chunk-XB5K7OYD.js.map