@chartts/core 0.1.2 → 0.1.4

package/dist/chunk-LRHMLNPW.js

@@ -0,0 +1,897 @@
+import { prepareNoAxes } from './chunk-T7SCCACB.js';
+import { group, line, PathBuilder, path, rect, text, circle } from './chunk-AEQXFDL7.js';
+
+// src/charts/graph/parse.ts
+function parseGraphData(data, options) {
+  const opts = options;
+  const defaultShape = opts.nodeShape ?? "rect";
+  if (opts.nodes || opts.edges) {
+    return parseRichFormat(data, opts, defaultShape);
+  }
+  const hasArrow = data.series.some(
+    (s) => s.name.includes("\u2192") || s.name.includes("->")
+  );
+  if (hasArrow) {
+    return parseArrowNotation(data, defaultShape);
+  }
+  return parseAdjacencyMatrix(data, defaultShape);
+}
+function makeNode(id, label, index, value, shape, color, pin) {
+  return {
+    id,
+    label,
+    index,
+    value,
+    shape,
+    color,
+    pin,
+    x: 0,
+    y: 0,
+    vx: 0,
+    vy: 0,
+    width: 0,
+    height: 0
+  };
+}
+function makeEdge(source, target, weight, label, style, color) {
+  return { source, target, weight, label, style, color };
+}
+function parseRichFormat(_data, opts, defaultShape) {
+  const graphNodes = [];
+  const idToIndex = /* @__PURE__ */ new Map();
+  if (opts.nodes) {
+    for (const nodeDef of opts.nodes) {
+      const idx = graphNodes.length;
+      idToIndex.set(nodeDef.id, idx);
+      graphNodes.push(
+        makeNode(
+          nodeDef.id,
+          nodeDef.label ?? nodeDef.id,
+          idx,
+          1,
+          nodeDef.shape ?? defaultShape,
+          nodeDef.color ?? null,
+          nodeDef.pin ?? null
+        )
+      );
+    }
+  }
+  const graphEdges = [];
+  if (opts.edges) {
+    for (const edgeDef of opts.edges) {
+      if (!idToIndex.has(edgeDef.source)) {
+        const idx = graphNodes.length;
+        idToIndex.set(edgeDef.source, idx);
+        graphNodes.push(
+          makeNode(edgeDef.source, edgeDef.source, idx, 1, defaultShape, null, null)
+        );
+      }
+      if (!idToIndex.has(edgeDef.target)) {
+        const idx = graphNodes.length;
+        idToIndex.set(edgeDef.target, idx);
+        graphNodes.push(
+          makeNode(edgeDef.target, edgeDef.target, idx, 1, defaultShape, null, null)
+        );
+      }
+      const srcIdx = idToIndex.get(edgeDef.source);
+      const tgtIdx = idToIndex.get(edgeDef.target);
+      graphEdges.push(
+        makeEdge(
+          srcIdx,
+          tgtIdx,
+          edgeDef.weight ?? 1,
+          edgeDef.label ?? null,
+          edgeDef.style ?? "solid",
+          edgeDef.color ?? null
+        )
+      );
+    }
+  }
+  return { graphNodes, graphEdges };
+}
+var ARROW_RE = /\s*(?:→|->)\s*/;
+function parseArrowNotation(data, defaultShape) {
+  const graphNodes = [];
+  const nameToIndex = /* @__PURE__ */ new Map();
+  const graphEdges = [];
+  function getOrCreateNode(name) {
+    let idx = nameToIndex.get(name);
+    if (idx !== void 0) return idx;
+    idx = graphNodes.length;
+    nameToIndex.set(name, idx);
+    graphNodes.push(makeNode(name, name, idx, 0, defaultShape, null, null));
+    return idx;
+  }
+  for (const series of data.series) {
+    const parts = series.name.split(ARROW_RE);
+    if (parts.length < 2) continue;
+    const srcName = parts[0];
+    const tgtName = parts[1];
+    const weight = series.values[0] ?? 1;
+    const srcIdx = getOrCreateNode(srcName);
+    const tgtIdx = getOrCreateNode(tgtName);
+    graphNodes[srcIdx].value += weight;
+    graphNodes[tgtIdx].value += weight;
+    graphEdges.push(makeEdge(srcIdx, tgtIdx, weight, null, "solid", null));
+  }
+  return { graphNodes, graphEdges };
+}
+function parseAdjacencyMatrix(data, defaultShape) {
+  const graphNodes = [];
+  for (let i = 0; i < data.labels.length; i++) {
+    const name = String(data.labels[i]);
+    const value = Math.abs(data.series[0]?.values[i] ?? 1);
+    graphNodes.push(makeNode(name, name, i, value, defaultShape, null, null));
+  }
+  const graphEdges = [];
+  if (data.series.length > 1 && data.series.length === data.labels.length) {
+    for (let i = 0; i < data.series.length; i++) {
+      const row = data.series[i];
+      for (let j = 0; j < row.values.length; j++) {
+        const weight = row.values[j] ?? 0;
+        if (weight > 0) {
+          graphEdges.push(makeEdge(i, j, weight, null, "solid", null));
+        }
+      }
+    }
+  }
+  return { graphNodes, graphEdges };
+}
+
+// src/charts/graph/text-measure.ts
+var CHAR_WIDTH_RATIO = 0.6;
+var PADDING_H = 16;
+var PADDING_V = 10;
+function measureNodeSize(label, fontSize, shape) {
+  const charWidth = fontSize * CHAR_WIDTH_RATIO;
+  const textWidth = label.length * charWidth;
+  const textHeight = fontSize * 1.2;
+  let w = textWidth + PADDING_H * 2;
+  let h = textHeight + PADDING_V * 2;
+  w = Math.max(w, 40);
+  h = Math.max(h, 28);
+  switch (shape) {
+    case "circle": {
+      const d = Math.sqrt(w * w + h * h);
+      return { width: d, height: d };
+    }
+    case "diamond": {
+      return { width: w * 1.45, height: h * 1.45 };
+    }
+    case "hexagon": {
+      return { width: w * 1.25, height: h * 1.15 };
+    }
+    case "stadium":
+    case "rect":
+    default:
+      return { width: w, height: h };
+  }
+}
+
+// src/charts/graph/shapes.ts
+function renderNodeShape(node, color, theme) {
+  const cx = node.x;
+  const cy = node.y;
+  const w = node.width;
+  const h = node.height;
+  const baseAttrs = {
+    class: "chartts-graph-node",
+    fill: color,
+    fillOpacity: 0.85,
+    stroke: color,
+    strokeWidth: 1.5,
+    "data-series": node.index,
+    "data-index": 0,
+    tabindex: 0,
+    role: "img",
+    ariaLabel: `${node.label}: ${node.value}`
+  };
+  let shapeNode;
+  switch (node.shape) {
+    case "circle": {
+      const r = Math.max(w, h) / 2;
+      shapeNode = circle(cx, cy, r, { ...baseAttrs });
+      break;
+    }
+    case "diamond": {
+      const pb = new PathBuilder();
+      pb.moveTo(cx, cy - h / 2).lineTo(cx + w / 2, cy).lineTo(cx, cy + h / 2).lineTo(cx - w / 2, cy).close();
+      shapeNode = path(pb.build(), { ...baseAttrs });
+      break;
+    }
+    case "hexagon": {
+      const rx = w / 2;
+      const ry = h / 2;
+      const pb = new PathBuilder();
+      for (let i = 0; i < 6; i++) {
+        const angle = Math.PI / 180 * (i * 60);
+        const px = cx + rx * Math.cos(angle);
+        const py = cy + ry * Math.sin(angle);
+        if (i === 0) pb.moveTo(px, py);
+        else pb.lineTo(px, py);
+      }
+      pb.close();
+      shapeNode = path(pb.build(), { ...baseAttrs });
+      break;
+    }
+    case "stadium": {
+      shapeNode = rect(cx - w / 2, cy - h / 2, w, h, {
+        ...baseAttrs,
+        rx: h / 2
+      });
+      break;
+    }
+    // 'rect' is the default
+    default: {
+      shapeNode = rect(cx - w / 2, cy - h / 2, w, h, {
+        ...baseAttrs,
+        rx: 8
+      });
+      break;
+    }
+  }
+  const labelNode = text(cx, cy, node.label, {
+    class: "chartts-graph-label",
+    fill: "#fff",
+    textAnchor: "middle",
+    dominantBaseline: "central",
+    fontSize: theme.fontSizeSmall,
+    fontFamily: theme.fontFamily,
+    fontWeight: 600
+  });
+  return [shapeNode, labelNode];
+}
+var PAD = 3;
+function clipToNodeBoundary(node, angle) {
+  const cx = node.x;
+  const cy = node.y;
+  const w = node.width;
+  const h = node.height;
+  const cos = Math.cos(angle);
+  const sin = Math.sin(angle);
+  let bx;
+  let by;
+  switch (node.shape) {
+    case "circle": {
+      const r = Math.max(w, h) / 2;
+      bx = cx + r * cos;
+      by = cy + r * sin;
+      break;
+    }
+    case "diamond": {
+      const hw = w / 2;
+      const hh = h / 2;
+      const t = 1 / (Math.abs(cos) / hw + Math.abs(sin) / hh);
+      bx = cx + t * cos;
+      by = cy + t * sin;
+      break;
+    }
+    case "hexagon": {
+      const rx = w / 2;
+      const ry = h / 2;
+      const pt = hexBoundary(cx, cy, rx, ry, angle, cos, sin);
+      bx = pt.x;
+      by = pt.y;
+      break;
+    }
+    // rect and stadium share the same rectangular bounding box logic
+    default: {
+      const hw = w / 2;
+      const hh = h / 2;
+      const cornerAngle = Math.atan2(hh, hw);
+      let a = (angle % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+      if (a < cornerAngle || a >= 2 * Math.PI - cornerAngle) {
+        const t = hw / Math.abs(cos);
+        bx = cx + hw;
+        by = cy + t * sin;
+      } else if (a < Math.PI - cornerAngle) {
+        const t = hh / Math.abs(sin);
+        bx = cx + t * cos;
+        by = cy + hh;
+      } else if (a < Math.PI + cornerAngle) {
+        const t = hw / Math.abs(cos);
+        bx = cx - hw;
+        by = cy + t * sin;
+      } else {
+        const t = hh / Math.abs(sin);
+        bx = cx + t * cos;
+        by = cy - hh;
+      }
+      break;
+    }
+  }
+  bx += PAD * cos;
+  by += PAD * sin;
+  return { x: bx, y: by };
+}
+function hexBoundary(cx, cy, rx, ry, _angle, cos, sin) {
+  const verts = [];
+  for (let i = 0; i < 6; i++) {
+    const a = Math.PI / 180 * (i * 60);
+    verts.push({ x: cx + rx * Math.cos(a), y: cy + ry * Math.sin(a) });
+  }
+  let bestT = Infinity;
+  let bestPt = { x: cx + rx * cos, y: cy + ry * sin };
+  for (let i = 0; i < 6; i++) {
+    const v0 = verts[i];
+    const v1 = verts[(i + 1) % 6];
+    const dx = v1.x - v0.x;
+    const dy = v1.y - v0.y;
+    const denom = cos * dy - sin * dx;
+    if (Math.abs(denom) < 1e-12) continue;
+    const t = ((v0.x - cx) * dy - (v0.y - cy) * dx) / denom;
+    const s = cos !== 0 ? (cx + t * cos - v0.x) / dx : (cy + t * sin - v0.y) / dy;
+    if (t > 1e-6 && s >= -1e-6 && s <= 1 + 1e-6 && t < bestT) {
+      bestT = t;
+      bestPt = { x: cx + t * cos, y: cy + t * sin };
+    }
+  }
+  return bestPt;
+}
+
+// src/charts/graph/edges.ts
+function renderArrowhead(tipX, tipY, angle, size, color) {
+  const cosA = Math.cos(angle);
+  const sinA = Math.sin(angle);
+  const baseX = tipX - cosA * size;
+  const baseY = tipY - sinA * size;
+  const perpX = -sinA * size * 0.4;
+  const perpY = cosA * size * 0.4;
+  const leftX = baseX + perpX;
+  const leftY = baseY + perpY;
+  const rightX = baseX - perpX;
+  const rightY = baseY - perpY;
+  const pb = new PathBuilder();
+  pb.moveTo(tipX, tipY).lineTo(leftX, leftY).lineTo(rightX, rightY).close();
+  return path(pb.build(), {
+    fill: color,
+    class: "chartts-graph-arrow"
+  });
+}
+function renderEdges(nodes, edges, options, theme) {
+  const result = [];
+  const pairIndex = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const src = nodes[edge.source];
+    const tgt = nodes[edge.target];
+    if (!src || !tgt) continue;
+    const angle = Math.atan2(tgt.y - src.y, tgt.x - src.x);
+    const start = clipToNodeBoundary(src, angle);
+    const end = clipToNodeBoundary(tgt, angle + Math.PI);
+    const edgeColor = edge.color ?? theme.gridColor;
+    const edgeAttrs = {
+      class: "chartts-graph-edge",
+      stroke: edgeColor,
+      strokeWidth: Math.max(1, Math.min(3, edge.weight * 0.5)),
+      strokeDasharray: edge.style === "dashed" ? "8,4" : edge.style === "dotted" ? "2,4" : void 0,
+      opacity: 0.6,
+      fill: "none"
+    };
+    let arrowAngle = angle;
+    let labelX = (start.x + end.x) / 2;
+    let labelY = (start.y + end.y) / 2;
+    if (options.edgeStyle === "straight" || options.edgeStyle === void 0) {
+      result.push(line(start.x, start.y, end.x, end.y, edgeAttrs));
+    } else {
+      const pairKey = Math.min(edge.source, edge.target) + ":" + Math.max(edge.source, edge.target);
+      const idx = pairIndex.get(pairKey) ?? 0;
+      pairIndex.set(pairKey, idx + 1);
+      const sign = idx % 2 === 0 ? 1 : -1;
+      const offset = Math.max(edge.weight * 8, 15);
+      const mx = (start.x + end.x) / 2;
+      const my = (start.y + end.y) / 2;
+      const perpAngle = angle + Math.PI / 2;
+      const cx = mx + Math.cos(perpAngle) * offset * sign;
+      const cy = my + Math.sin(perpAngle) * offset * sign;
+      const pb = new PathBuilder();
+      pb.moveTo(start.x, start.y).quadTo(cx, cy, end.x, end.y);
+      result.push(path(pb.build(), edgeAttrs));
+      arrowAngle = Math.atan2(end.y - cy, end.x - cx);
+      labelX = 0.25 * start.x + 0.5 * cx + 0.25 * end.x;
+      labelY = 0.25 * start.y + 0.5 * cy + 0.25 * end.y;
+    }
+    if (options.arrows !== false) {
+      const arrowSize = 8;
+      result.push(renderArrowhead(end.x, end.y, arrowAngle, arrowSize, edgeColor));
+    }
+    if (edge.label != null) {
+      const lx = labelX;
+      const ly = labelY;
+      const charWidth = (theme.fontSizeSmall - 1) * 0.6;
+      const pw = edge.label.length * charWidth + 8;
+      const ph = theme.fontSizeSmall - 1 + 6;
+      const bgFill = theme.background === "transparent" ? "#fff" : theme.background;
+      result.push(
+        rect(lx - pw / 2, ly - ph / 2, pw, ph, {
+          fill: bgFill,
+          rx: 3
+        })
+      );
+      result.push(
+        text(lx, ly, edge.label, {
+          fill: theme.textMuted,
+          textAnchor: "middle",
+          dominantBaseline: "central",
+          fontSize: theme.fontSizeSmall - 1,
+          fontFamily: theme.fontFamily
+        })
+      );
+    }
+  }
+  return result;
+}
+
+// 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;
+    }
+  }
+  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 ni = nodes[i];
+        const nj = nodes[j];
+        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 force = repulsion / (effectiveDist * effectiveDist);
+        const fx = dx / dist * force;
+        const fy = dy / dist * force;
+        ni.vx += fx;
+        ni.vy += fy;
+        nj.vx -= fx;
+        nj.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) {
+      if (node.pin) continue;
+      node.vx *= 0.8;
+      node.vy *= 0.8;
+      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 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));
+    }
+  }
+  layoutCache.set(key, nodes.map((nd) => ({ x: nd.x, y: nd.y })));
+}
+
+// src/charts/graph/layout-hierarchy.ts
+function hierarchyLayout(nodes, edges, opts) {
+  const n = nodes.length;
+  if (n === 0) return;
+  const { area, direction } = opts;
+  const outgoing = new Array(n);
+  const incoming = new Array(n);
+  for (let i = 0; i < n; i++) {
+    outgoing[i] = [];
+    incoming[i] = [];
+  }
+  const edgesCopy = edges.map((e) => ({ ...e }));
+  breakCycles(edgesCopy, n, outgoing, incoming);
+  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);
+  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]];
+      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;
+      }
+      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);
+          break;
+        case "LR":
+          node.x = layerCoord;
+          node.y = posCoord;
+          break;
+        case "RL":
+          node.x = area.x + area.width - (layerCoord - area.x);
+          node.y = posCoord;
+          break;
+      }
+    }
+  }
+}
+function breakCycles(edges, n, outgoing, incoming) {
+  for (const e of edges) {
+    outgoing[e.source].push(e.target);
+    incoming[e.target].push(e.source);
+  }
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const color = new Array(n).fill(WHITE);
+  function dfs(u) {
+    color[u] = GRAY;
+    const out = outgoing[u];
+    for (let i = 0; i < out.length; i++) {
+      const v = out[i];
+      if (color[v] === GRAY) {
+        for (const e of edges) {
+          if (e.source === u && e.target === v) {
+            e.source = v;
+            e.target = u;
+            break;
+          }
+        }
+        out.splice(i, 1);
+        i--;
+        outgoing[v].push(u);
+        incoming[u].push(v);
+        const idx = incoming[v].indexOf(u);
+        if (idx >= 0) incoming[v].splice(idx, 1);
+      } else if (color[v] === WHITE) {
+        dfs(v);
+      }
+    }
+    color[u] = BLACK;
+  }
+  for (let i = 0; i < n; i++) {
+    if (color[i] === WHITE) dfs(i);
+  }
+}
+function assignLayers(n, outgoing, incoming) {
+  const layers = new Array(n).fill(-1);
+  const roots = [];
+  for (let i = 0; i < n; i++) {
+    if (incoming[i].length === 0) roots.push(i);
+  }
+  if (roots.length === 0 && n > 0) roots.push(0);
+  const queue = [];
+  for (const r of roots) {
+    layers[r] = 0;
+    queue.push(r);
+  }
+  let qi = 0;
+  while (qi < queue.length) {
+    const u = queue[qi++];
+    for (const v of outgoing[u]) {
+      const newLayer = layers[u] + 1;
+      if (layers[v] < newLayer) {
+        layers[v] = newLayer;
+        queue.push(v);
+      }
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    if (layers[i] < 0) layers[i] = 0;
+  }
+  return layers;
+}
+function groupByLayer(layers, n) {
+  const maxLayer = Math.max(...layers, 0);
+  const groups = new Array(maxLayer + 1);
+  for (let i = 0; i <= maxLayer; i++) groups[i] = [];
+  for (let i = 0; i < n; i++) {
+    groups[layers[i]].push(i);
+  }
+  return groups;
+}
+function orderLayers(layerGroups, outgoing, incoming, passes) {
+  for (let pass = 0; pass < passes; pass++) {
+    for (let l = 1; l < layerGroups.length; l++) {
+      const layer = layerGroups[l];
+      const posMap = /* @__PURE__ */ new Map();
+      const prevLayer = layerGroups[l - 1];
+      for (let i = 0; i < prevLayer.length; i++) posMap.set(prevLayer[i], i);
+      layer.sort((a, b) => {
+        const ba = barycenter(a, incoming, posMap);
+        const bb = barycenter(b, incoming, posMap);
+        return ba - bb;
+      });
+    }
+    for (let l = layerGroups.length - 2; l >= 0; l--) {
+      const layer = layerGroups[l];
+      const posMap = /* @__PURE__ */ new Map();
+      const nextLayer = layerGroups[l + 1];
+      for (let i = 0; i < nextLayer.length; i++) posMap.set(nextLayer[i], i);
+      layer.sort((a, b) => {
+        const ba = barycenter(a, outgoing, posMap);
+        const bb = barycenter(b, outgoing, posMap);
+        return ba - bb;
+      });
+    }
+  }
+}
+function barycenter(nodeIdx, adj, posMap) {
+  const neighbors = adj[nodeIdx];
+  if (neighbors.length === 0) return 0;
+  let sum = 0;
+  let count = 0;
+  for (const nb of neighbors) {
+    const pos = posMap.get(nb);
+    if (pos !== void 0) {
+      sum += pos;
+      count++;
+    }
+  }
+  return count > 0 ? sum / count : 0;
+}
+
+// src/charts/graph/layout-circular.ts
+function circularLayout(nodes, edges, opts) {
+  const n = nodes.length;
+  if (n === 0) return;
+  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 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);
+  }
+  for (const node of nodes) {
+    if (node.pin) {
+      node.x = area.x + node.pin.x * area.width;
+      node.y = area.y + node.pin.y * area.height;
+    }
+  }
+}
+function connectivityOrder(nodes, edges) {
+  const n = nodes.length;
+  if (n === 0) return [];
+  const adj = new Array(n);
+  for (let i = 0; i < n; i++) adj[i] = [];
+  for (const e of edges) {
+    adj[e.source].push(e.target);
+    adj[e.target].push(e.source);
+  }
+  let startNode = 0;
+  let maxDeg = 0;
+  for (let i = 0; i < n; i++) {
+    if (adj[i].length > maxDeg) {
+      maxDeg = adj[i].length;
+      startNode = i;
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  const queue = [startNode];
+  visited.add(startNode);
+  while (queue.length > 0) {
+    const u = queue.shift();
+    order.push(u);
+    const neighbors = adj[u].filter((v) => !visited.has(v));
+    neighbors.sort((a, b) => adj[b].length - adj[a].length);
+    for (const v of neighbors) {
+      if (!visited.has(v)) {
+        visited.add(v);
+        queue.push(v);
+      }
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    if (!visited.has(i)) order.push(i);
+  }
+  return order;
+}
+
+// src/charts/graph/graph-type.ts
+var graphChartType = {
+  type: "graph",
+  getScaleTypes() {
+    return { x: "categorical", y: "linear" };
+  },
+  prepareData(data, options) {
+    const opts = options;
+    if ((opts.nodes || opts.edges) && (!data.series.length || data.series.every((s) => s.values.length === 0))) {
+      return {
+        series: [],
+        labels: [],
+        bounds: { xMin: 0, xMax: 1, yMin: 0, yMax: 1 }
+      };
+    }
+    return prepareNoAxes(data, options);
+  },
+  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
+      }));
+    }
+    return result;
+  },
+  hitTest(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) {
+    case "hierarchical":
+      hierarchyLayout(nodes, edges, {
+        area,
+        direction: opts.direction ?? "TB"
+      });
+      break;
+    case "circular":
+      circularLayout(nodes, edges, { area });
+      break;
+    case "force":
+    default:
+      forceLayout(nodes, edges, {
+        area,
+        iterations: opts.iterations ?? 120
+      });
+      break;
+  }
+}
+function shapeDistance(node, mx, my) {
+  const dx = mx - node.x;
+  const dy = my - node.y;
+  const absDx = Math.abs(dx);
+  const absDy = Math.abs(dy);
+  switch (node.shape) {
+    case "circle": {
+      const r = Math.max(node.width, node.height) / 2;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      return Math.max(0, dist - r);
+    }
+    case "diamond": {
+      const hw = node.width / 2;
+      const hh = node.height / 2;
+      const d = absDx / hw + absDy / hh;
+      return d <= 1 ? 0 : Math.sqrt(dx * dx + dy * dy) * (d - 1);
+    }
+    case "hexagon": {
+      const rx = node.width / 2;
+      const ry = node.height / 2;
+      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;
+      const ox = Math.max(0, absDx - hw);
+      const oy = Math.max(0, absDy - hh);
+      return Math.sqrt(ox * ox + oy * oy);
+    }
+  }
+}
+
+export { graphChartType };
+//# sourceMappingURL=chunk-LRHMLNPW.js.map
+//# sourceMappingURL=chunk-LRHMLNPW.js.map