@datnguye/erd-flow 1.0.0

package/dist/index.js

@@ -0,0 +1,987 @@
+import { jsxs as $, jsx as b } from "react/jsx-runtime";
+import { memo as St, useCallback as P, useMemo as T, useState as nt, useRef as R, useEffect as W } from "react";
+import { useInternalNode as st, getSmoothStepPath as Fe, Position as z, BaseEdge as Ye, Handle as Zt, useNodesState as We, useEdgesState as ze, ReactFlow as Ke, Background as je, Controls as Ve, MiniMap as Xe } from "@xyflow/react";
+import Jt from "@dagrejs/dagre";
+function qe(t) {
+  const n = /* @__PURE__ */ new Map(), e = (o, s) => {
+    if (!s) return;
+    const c = n.get(o) ?? /* @__PURE__ */ new Set();
+    c.add(s), n.set(o, c);
+  };
+  for (const o of t) {
+    if (!o.selected) continue;
+    const s = o.data ?? {};
+    e(o.source, s.from_column), e(o.target, s.to_column);
+    for (const c of s.from_columns ?? []) e(o.source, c);
+    for (const c of s.to_columns ?? []) e(o.target, c);
+  }
+  return n;
+}
+const Ze = 5, Je = 5;
+function X(t, n = !0) {
+  return n && t > Ze;
+}
+function it(t, n, e = !0) {
+  return X(t, e) && !n ? Je : t;
+}
+const Qe = 24, he = 32, wt = 22, fe = 4, tn = 4, ge = 1, pe = 220, Qt = /* @__PURE__ */ new WeakMap();
+function en(t) {
+  const n = Qt.get(t);
+  if (n) return n;
+  const e = /* @__PURE__ */ new Map();
+  return t.forEach((o, s) => {
+    e.has(o.name) || e.set(o.name, s);
+  }), Qt.set(t, e), e;
+}
+function ct(t) {
+  var e, o, s, c;
+  if (!t) return null;
+  const n = ((e = t.data) == null ? void 0 : e.columns) ?? [];
+  return {
+    base: t.internals.positionAbsolute,
+    width: ((o = t.measured) == null ? void 0 : o.width) ?? t.width ?? pe,
+    columnIndex: en(n),
+    columnCount: n.length,
+    expanded: ((s = t.data) == null ? void 0 : s.__expanded) === !0,
+    collapse: ((c = t.data) == null ? void 0 : c.__collapse) !== !1
+  };
+}
+function nn(t) {
+  return ge + he + fe + t * wt + wt / 2;
+}
+function on(t, n) {
+  const e = it(t.columnCount, t.expanded, t.collapse), o = n ? t.columnIndex.get(n) ?? -1 : -1;
+  return o >= 0 && o < e ? o : Math.max(0, e - 1);
+}
+function rt(t, n, e) {
+  return { x: e ? t.base.x : t.base.x + t.width, y: t.base.y + nn(on(t, n)) };
+}
+function _e(t, n) {
+  const e = t.base.x <= n.base.x;
+  return { fromIsLeft: !e, toIsLeft: e };
+}
+function ye(t, n) {
+  return {
+    stroke: t ? "var(--erd-edge-selected, #e5c07b)" : "var(--erd-edge, #007acc)",
+    strokeWidth: t ? "var(--erd-edge-selected-width, 3)" : "var(--erd-edge-width, 2)",
+    fill: "none",
+    ...n
+  };
+}
+const te = 40, sn = 0.6, cn = 0.7;
+function ee(t) {
+  return t.reduce((n, e) => n + e.y, 0) / t.length;
+}
+function ne(t, n, e, o) {
+  const s = e ? t.x + n : t.x, c = e ? te : -te;
+  return { x: s + c, y: o };
+}
+function xe(t, n, e, o) {
+  const s = Math.abs(n.x - t.x) * e, c = t.x + (o ? s : -s), i = n.x - (o ? s : -s);
+  return `M ${t.x} ${t.y} C ${c} ${t.y}, ${i} ${n.y}, ${n.x} ${n.y}`;
+}
+function rn(t, n, e) {
+  return xe(t, n, cn, e);
+}
+function Mt(t, n) {
+  return xe(t, n, sn, n.x - t.x >= 0);
+}
+function oe(t, n, e) {
+  const o = n.map((s) => rt(t, s, e));
+  return o.length > 0 ? o : [rt(t, null, e)];
+}
+const an = St(function({
+  source: n,
+  target: e,
+  data: o,
+  style: s,
+  markerEnd: c,
+  selected: i
+}) {
+  const d = st(n), a = st(e), r = o, m = ct(d), u = ct(a);
+  if (!m || !u || !r) return null;
+  const { fromIsLeft: f, toIsLeft: x } = _e(m, u), g = oe(m, r.from_columns, f), w = oe(u, r.to_columns, x), y = ne(m.base, m.width, !f, ee(g)), I = ne(u.base, u.width, !x, ee(w)), M = ye(i ?? !1, s), E = i || r.__animated === !1 ? "" : " animated", p = rn(y, I, !f);
+  return /* @__PURE__ */ $("g", { className: "react-flow__edge-path erd-composite-edge", children: [
+    /* @__PURE__ */ b(
+      "path",
+      {
+        d: p,
+        className: "react-flow__edge-interaction",
+        fill: "none",
+        stroke: "transparent",
+        strokeWidth: 20
+      }
+    ),
+    g.map((S, N) => /* @__PURE__ */ b(
+      "path",
+      {
+        d: Mt(S, y),
+        className: "erd-composite-tail",
+        style: M
+      },
+      `from-${N}`
+    )),
+    /* @__PURE__ */ b(
+      "path",
+      {
+        d: p,
+        className: `erd-composite-bundle${E}`,
+        style: M,
+        markerEnd: c
+      }
+    ),
+    w.map((S, N) => /* @__PURE__ */ b(
+      "path",
+      {
+        d: Mt(I, S),
+        className: `erd-composite-tail${E}`,
+        style: M
+      },
+      `to-${N}`
+    ))
+  ] });
+}), dn = St(function({
+  source: n,
+  target: e,
+  data: o,
+  style: s,
+  markerEnd: c,
+  selected: i
+}) {
+  const d = st(n), a = st(e), r = ct(d), m = ct(a);
+  if (!r || !m) return null;
+  const u = o, f = (u == null ? void 0 : u.from_column) ?? null, x = (u == null ? void 0 : u.to_column) ?? null, { fromIsLeft: g, toIsLeft: w } = _e(r, m), y = rt(r, f, g), I = rt(m, x, w), M = (u == null ? void 0 : u.__edgePath) === "smoothstep" ? Fe({
+    sourceX: y.x,
+    sourceY: y.y,
+    sourcePosition: g ? z.Left : z.Right,
+    targetX: I.x,
+    targetY: I.y,
+    targetPosition: w ? z.Left : z.Right
+  })[0] : Mt(y, I), E = (u == null ? void 0 : u.__animated) !== !1 && !i;
+  return /* @__PURE__ */ b(
+    Ye,
+    {
+      path: M,
+      markerEnd: c,
+      className: `erd-single-edge${E ? " animated" : ""}`,
+      style: ye(i ?? !1, s)
+    }
+  );
+}), ln = {
+  composite: an,
+  single: dn
+};
+function be(t) {
+  return {
+    width: t,
+    height: t,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: 2,
+    strokeLinecap: "round",
+    strokeLinejoin: "round"
+  };
+}
+function un({ size: t = 14, className: n }) {
+  return /* @__PURE__ */ b("svg", { ...be(t), className: n, "aria-hidden": "true", children: /* @__PURE__ */ b("path", { d: "M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18" }) });
+}
+function mn({ size: t = 14, className: n }) {
+  return /* @__PURE__ */ $("svg", { ...be(t), className: n, "aria-hidden": "true", children: [
+    /* @__PURE__ */ b("ellipse", { cx: "12", cy: "5", rx: "9", ry: "3" }),
+    /* @__PURE__ */ b("path", { d: "M3 5v14a9 3 0 0 0 18 0V5" }),
+    /* @__PURE__ */ b("path", { d: "M3 12a9 3 0 0 0 18 0" })
+  ] });
+}
+function hn(t) {
+  return t.is_primary_key ? "PK" : t.is_foreign_key ? "FK" : "";
+}
+function fn({ col: t, highlighted: n }) {
+  const e = hn(t);
+  return /* @__PURE__ */ $("li", { className: "erd-column", "data-highlighted": n ? "true" : "false", children: [
+    /* @__PURE__ */ b("span", { className: `erd-column-badge badge-${e.toLowerCase() || "none"}`, children: e }),
+    /* @__PURE__ */ b("span", { className: "erd-column-name", children: t.name }),
+    /* @__PURE__ */ b("span", { className: "erd-column-type", children: t.data_type ?? "" })
+  ] });
+}
+const gn = St(function({ id: n, data: e }) {
+  const o = typeof e.compiled_sql == "string" && e.compiled_sql.length > 0, s = e.__collapse !== !1, c = X(e.columns.length, s), i = e.__expanded === !0, d = e.__onToggleExpand, a = P(
+    (p) => {
+      p.stopPropagation(), d == null || d(n);
+    },
+    [n, d]
+  ), r = P((p) => {
+    p.key !== "Enter" && p.key !== " " || (p.preventDefault(), p.currentTarget.click());
+  }, []), m = e.columns.slice(
+    0,
+    it(e.columns.length, i, s)
+  ), u = e.columns.length - m.length, f = e.__filterState, x = e.__active === !0, g = e.__focus === !0, w = e.__dimmed === !0, y = e.__showSchema === !0 && !!e.schema_name, I = e.hidden_column_count ?? 0, M = e.__highlightColumns, E = e.__icon;
+  return /* @__PURE__ */ $(
+    "div",
+    {
+      className: "erd-table",
+      "data-resource": e.resource_type,
+      "data-filter": f ?? "off",
+      "data-active": x ? "true" : "false",
+      "data-focus": g ? "true" : "false",
+      "data-dimmed": w ? "true" : "false",
+      children: [
+        /* @__PURE__ */ b(Zt, { type: "target", position: z.Left, id: "__node_in", className: "erd-hidden-handle" }),
+        /* @__PURE__ */ b(Zt, { type: "source", position: z.Right, id: "__node_out", className: "erd-hidden-handle" }),
+        /* @__PURE__ */ $(
+          "header",
+          {
+            className: "erd-table-header nokey",
+            title: o ? "Double-click to open" : "",
+            role: "button",
+            tabIndex: 0,
+            onKeyDown: r,
+            children: [
+              /* @__PURE__ */ b("span", { className: "erd-table-icon", children: E === "database" ? /* @__PURE__ */ b(mn, { size: 14 }) : /* @__PURE__ */ b(un, { size: 14 }) }),
+              /* @__PURE__ */ b("span", { className: "erd-table-name", children: e.name }),
+              y ? /* @__PURE__ */ b("span", { className: "erd-table-schema", children: e.schema_name }) : null
+            ]
+          }
+        ),
+        /* @__PURE__ */ b("ul", { className: "erd-table-columns", children: m.map((p, S) => /* @__PURE__ */ b(
+          fn,
+          {
+            col: p,
+            highlighted: (M == null ? void 0 : M.has(p.name)) ?? !1
+          },
+          `${p.name}-${S}`
+        )) }),
+        I > 0 ? /* @__PURE__ */ $("div", { className: "erd-table-more", children: [
+          "+",
+          I,
+          " more columns"
+        ] }) : null,
+        c ? /* @__PURE__ */ b(
+          "button",
+          {
+            type: "button",
+            className: "erd-table-expand",
+            onClick: a,
+            title: i ? "Collapse columns" : `Show ${u} more columns`,
+            children: i ? "▲ Collapse" : `▼ ${u} more`
+          }
+        ) : null
+      ]
+    }
+  );
+}), pn = {
+  erdTable: gn
+}, _n = 440, yn = 7, xn = 60, bn = 80;
+function wn(t) {
+  const n = (s) => s.name.length + (s.data_type ? s.data_type.length + 2 : 0), o = t.columns.reduce(
+    (s, c) => Math.max(s, n(c)),
+    t.name.length
+  ) * yn + xn;
+  return Math.min(_n, Math.max(pe, o));
+}
+function Mn(t, n = !0) {
+  const e = t.columns.length, o = it(e, !1, n), s = t.hidden_column_count ? 1 : 0, c = X(e, n) ? Qe : 0;
+  return Math.max(
+    bn,
+    he + (o + s) * wt + fe + tn + 2 * ge + c
+  );
+}
+function we(t, n = !0) {
+  return { width: wn(t), height: Mn(t, n) };
+}
+function En(t, n = !0, e) {
+  return t.map((o) => {
+    const s = e ? e(
+      o,
+      it(o.columns.length, !1, n),
+      X(o.columns.length, n)
+    ) : we(o, n);
+    return { ...o, ...s };
+  });
+}
+function Nt(t) {
+  return new Map(t.map((n) => [n.id, { width: n.width, height: n.height }]));
+}
+const Sn = 6, Me = 40;
+function se(t, n, e) {
+  return Math.min(e, Math.max(n, t));
+}
+function vt(t, n = !0) {
+  const e = /* @__PURE__ */ new Map();
+  for (const o of t) e.set(o.id, we(o, n));
+  return e;
+}
+function Ee(t, n) {
+  return { x: t.x - n.width / 2, y: t.y - n.height / 2 };
+}
+function Se(t, n, e) {
+  return t.map((o) => {
+    const s = n.get(o.id) ?? { x: 0, y: 0 };
+    return { id: o.id, x: s.x, y: s.y, dimensions: e.get(o.id) };
+  });
+}
+function It(t) {
+  const n = /* @__PURE__ */ new Map(), e = (o, s) => {
+    const c = n.get(o) ?? /* @__PURE__ */ new Set();
+    c.add(s), n.set(o, c);
+  };
+  for (const o of t)
+    o.from_id !== o.to_id && (e(o.from_id, o.to_id), e(o.to_id, o.from_id));
+  return n;
+}
+function Ne(t, n) {
+  const e = [], o = [];
+  for (const s of t)
+    (n.has(s) ? e : o).push(s);
+  return { connected: e, islands: o };
+}
+function Nn(t, n) {
+  const e = /* @__PURE__ */ new Set(), o = [];
+  for (const s of t) {
+    if (e.has(s)) continue;
+    const c = [s];
+    e.add(s);
+    const i = [];
+    for (; c.length > 0; ) {
+      const d = c.shift();
+      i.push(d);
+      for (const a of n.get(d) ?? [])
+        e.has(a) || (e.add(a), c.push(a));
+    }
+    o.push(i);
+  }
+  return o;
+}
+function ve(t, n, e = 0, o = 0, s = Me) {
+  const c = /* @__PURE__ */ new Map(), i = t.reduce((m, u) => Math.max(m, n.get(u).width), 0) + s;
+  let d = o, a = 0, r = 0;
+  return t.forEach((m, u) => {
+    const f = u % Sn;
+    f === 0 && u > 0 && (d += a + s, a = 0);
+    const x = n.get(m);
+    c.set(m, { x: e + f * i, y: d }), a = Math.max(a, x.height), r = Math.max(r, f * i + x.width);
+  }), { positions: c, width: r, height: d + a - o };
+}
+function Ie(t, n, e) {
+  const o = /* @__PURE__ */ new Map();
+  let s = 1 / 0, c = 1 / 0, i = -1 / 0, d = -1 / 0;
+  for (const a of t) {
+    const r = n.get(a) ?? { x: 0, y: 0 }, m = e.get(a), { x: u, y: f } = Ee(r, m);
+    o.set(a, { x: u, y: f }), s = Math.min(s, u), c = Math.min(c, f), i = Math.max(i, u + m.width), d = Math.max(d, f + m.height);
+  }
+  Number.isFinite(s) || (s = 0, c = 0, i = 0, d = 0);
+  for (const [a, r] of o)
+    o.set(a, { x: r.x - s, y: r.y - c });
+  return { positions: o, box: { minX: s, minY: c, maxX: i, maxY: d } };
+}
+const vn = "LR", In = 40, Cn = 80, ce = 24, Ln = "network-simplex", kn = "UL";
+function Tn(t, n, e = !0, o) {
+  const s = new Jt.graphlib.Graph({ compound: !1 });
+  s.setGraph({
+    rankdir: vn,
+    nodesep: In,
+    ranksep: Cn,
+    marginx: ce,
+    marginy: ce,
+    ranker: Ln,
+    align: kn
+  }), s.setDefaultEdgeLabel(() => ({}));
+  const c = o ?? vt(t, e);
+  for (const i of t)
+    s.setNode(i.id, c.get(i.id));
+  for (const i of n)
+    s.setEdge(i.from_id, i.to_id);
+  return Jt.layout(s), t.map((i) => {
+    const d = s.node(i.id), a = c.get(i.id), { x: r, y: m } = Ee(d, a);
+    return { id: i.id, x: r, y: m, dimensions: a };
+  });
+}
+function Ce(t, n, e, o, s = 40) {
+  for (let c = 0; c < s; c++) {
+    let i = !1;
+    for (let d = 0; d < t.length; d++)
+      for (let a = d + 1; a < t.length; a++) {
+        const r = n.get(t[d]), m = n.get(t[a]), u = e.get(t[d]), f = e.get(t[a]), x = u.width / 2 + f.width / 2 + o, g = u.height / 2 + f.height / 2 + o, w = m.x - r.x, y = m.y - r.y, I = x - Math.abs(w), M = g - Math.abs(y);
+        if (!(I <= 0 || M <= 0)) {
+          if (I < M) {
+            const E = I / 2 * (w < 0 ? -1 : 1);
+            r.x -= E, m.x += E;
+          } else {
+            const E = M / 2 * (y < 0 ? -1 : 1);
+            r.y -= E, m.y += E;
+          }
+          i = !0;
+        }
+      }
+    if (!i) break;
+  }
+}
+const An = 300, Rn = 32e4, On = 0.02, Le = 80, re = 0.012, ie = 0.85, ot = 60, ae = 1;
+function Pn(t, n) {
+  const e = new Map(t.map((s) => [s.id, s])), o = n.map((s) => ({ a: e.get(s.from_id), b: e.get(s.to_id) })).filter((s) => !!s.a && !!s.b && s.a !== s.b);
+  for (let s = 0; s < An; s++) {
+    for (let c = 0; c < t.length; c++) {
+      const i = t[c];
+      for (let d = c + 1; d < t.length; d++) {
+        const a = t[d];
+        let r = i.x - a.x, m = i.y - a.y, u = r * r + m * m;
+        u === 0 && (r = c - d || 1, m = 1, u = r * r + m * m), u = Math.max(u, ae * ae);
+        const f = Math.sqrt(u), x = i.radius + a.radius, g = Rn / u + (f < x ? (x - f) * 4 : 0), w = r / f * g, y = m / f * g;
+        i.vx += w, i.vy += y, a.vx -= w, a.vy -= y;
+      }
+    }
+    for (const { a: c, b: i } of o) {
+      const d = i.x - c.x, a = i.y - c.y, r = Math.sqrt(d * d + a * a) || 1, m = c.radius + i.radius + Le, u = On * (r - m), f = d / r * u, x = a / r * u;
+      c.vx += f, c.vy += x, i.vx -= f, i.vy -= x;
+    }
+    for (const c of t)
+      c.vx -= c.x * re, c.vy -= c.y * re, c.vx *= ie, c.vy *= ie, c.x += se(c.vx, -ot, ot), c.y += se(c.vy, -ot, ot);
+  }
+}
+function Dn(t, n, e = !0, o) {
+  const s = o ?? vt(t, e), c = It(n), { connected: i, islands: d } = Ne(
+    t.map((y) => y.id),
+    c
+  ), a = new Set(i), r = t.filter((y) => a.has(y.id)), m = Math.max(200, r.length * 24), u = r.map((y, I) => {
+    const M = I / Math.max(r.length, 1) * 2 * Math.PI, E = s.get(y.id);
+    return {
+      id: y.id,
+      x: Math.cos(M) * m,
+      y: Math.sin(M) * m,
+      vx: 0,
+      vy: 0,
+      radius: Math.hypot(E.width, E.height) / 2,
+      dim: E
+    };
+  });
+  Pn(u, n);
+  const f = new Map(u.map((y) => [y.id, { x: y.x, y: y.y }]));
+  Ce(i, f, s, Le / 2);
+  const { positions: x, box: g } = Ie(i, f, s), w = g.maxY - g.minY;
+  if (d.length > 0) {
+    const { positions: y } = ve(
+      d,
+      s,
+      0,
+      w + Me
+    );
+    for (const [I, M] of y) x.set(I, M);
+  }
+  return Se(t, x, s);
+}
+const Hn = 120, de = 60, bt = 120;
+function Gn(t, n, e) {
+  const o = (p) => {
+    var S;
+    return ((S = n.get(p)) == null ? void 0 : S.size) ?? 0;
+  }, c = [...t].sort((p, S) => o(S) - o(p))[0], i = /* @__PURE__ */ new Map([[c, null]]), d = /* @__PURE__ */ new Map([[c, 0]]), a = /* @__PURE__ */ new Map(), r = [c];
+  for (; r.length > 0; ) {
+    const p = r.shift(), S = [...n.get(p) ?? []].sort((N, L) => o(L) - o(N));
+    for (const N of S)
+      if (!i.has(N)) {
+        i.set(N, p), d.set(N, d.get(p) + 1);
+        const L = a.get(p) ?? [];
+        L.push(N), a.set(p, L), r.push(N);
+      }
+  }
+  const m = t.reduce((p, S) => {
+    const N = e.get(S);
+    return Math.max(p, N.width, N.height);
+  }, 0), u = m + Hn, f = m + de, x = /* @__PURE__ */ new Map([[c, { x: 0, y: 0 }]]), g = /* @__PURE__ */ new Map(), w = (p) => {
+    const S = a.get(p) ?? [];
+    if (S.length === 0)
+      return g.set(p, 1), 1;
+    const N = S.reduce((L, U) => L + w(U), 0);
+    return g.set(p, N), N;
+  };
+  w(c);
+  const y = (p) => {
+    const N = (a.get(c) ?? []).length * f / (2 * Math.PI);
+    return Math.max(u, N) + (p - 1) * u;
+  }, I = (p, S, N) => {
+    const L = a.get(p) ?? [];
+    if (L.length === 0) return;
+    const U = N - S, K = g.get(p), F = f * L.length / Math.max(U, 1e-3), j = Math.max(y(d.get(L[0])), F);
+    let Y = S;
+    for (const D of L) {
+      const q = g.get(D) / K, H = Y, k = Y + U * q, V = (H + k) / 2;
+      x.set(D, {
+        x: Math.cos(V) * j,
+        y: Math.sin(V) * j
+      }), I(D, H, k), Y = k;
+    }
+  };
+  I(c, 0, 2 * Math.PI), Ce(t, x, e, de / 2);
+  const { positions: M, box: E } = Ie(t, x, e);
+  return {
+    ids: t,
+    width: E.maxX - E.minX,
+    height: E.maxY - E.minY,
+    positions: M
+  };
+}
+function Bn(t, n, e = !0, o) {
+  const s = o ?? vt(t, e), c = It(n), { connected: i, islands: d } = Ne(
+    t.map((g) => g.id),
+    c
+  ), a = Nn(i, c).map((g) => Gn(g, c, s)).sort((g, w) => w.ids.length - g.ids.length);
+  if (d.length > 0) {
+    const g = ve(d, s);
+    a.push({ ids: d, ...g });
+  }
+  const r = Math.max(...a.map((g) => g.width), 1) * 2 + bt, m = /* @__PURE__ */ new Map();
+  let u = 0, f = 0, x = 0;
+  for (const g of a) {
+    u > 0 && u + g.width > r && (u = 0, f += x + bt, x = 0);
+    for (const w of g.ids) {
+      const y = g.positions.get(w);
+      m.set(w, { x: u + y.x, y: f + y.y });
+    }
+    u += g.width + bt, x = Math.max(x, g.height);
+  }
+  return Se(t, m, s);
+}
+const $n = ["hierarchical", "radial", "force"], Ct = "radial";
+function eo(t) {
+  return typeof t == "string" && $n.includes(t);
+}
+const Et = /* @__PURE__ */ new Map();
+function Lt(t, n) {
+  Et.set(t, n);
+}
+function Un(t) {
+  return Et.get(t) ?? Et.get(Ct);
+}
+Lt(
+  "hierarchical",
+  (t, n) => Tn(t, n, !0, Nt(t))
+);
+Lt(
+  "radial",
+  (t, n) => Bn(t, n, !0, Nt(t))
+);
+Lt(
+  "force",
+  (t, n) => Dn(t, n, !0, Nt(t))
+);
+function Fn(t) {
+  const n = new Set(t.nodes.map((e) => e.id));
+  return t.edges.filter((e) => n.has(e.from_id) && n.has(e.to_id));
+}
+function Yn(t, n = Ct, e = !0, o = {}) {
+  const s = En(t.nodes, e, o.estimateSize), c = Un(n)(s, Fn(t), {
+    centerId: o.centerId ?? null
+  }), i = new Map(c.map((r) => [r.id, r])), d = t.nodes.map((r) => {
+    const m = i.get(r.id);
+    return {
+      id: r.id,
+      type: "erdTable",
+      data: { ...r, __collapse: e },
+      position: { x: m.x, y: m.y }
+    };
+  }), a = t.edges.flatMap((r) => Wn(r, o));
+  return { nodes: d, edges: a };
+}
+function le(t, n) {
+  return t && t.length > 0 ? t : n ? [n] : [];
+}
+function Wn(t, n) {
+  const e = le(t.from_columns, t.from_column), o = le(t.to_columns, t.to_column), s = (e.length > 1 || o.length > 1) && e.length > 0 && o.length > 0, c = n.animateEdge ? n.animateEdge(t) : !0, i = {};
+  if (c || (i.__animated = !1), n.edgePath === "smoothstep" && (i.__edgePath = "smoothstep"), s && n.compositeEdges === "fan") {
+    const d = Math.max(e.length, o.length);
+    return Array.from({ length: d }, (a, r) => ({
+      id: `${t.id}__${r}`,
+      source: t.from_id,
+      target: t.to_id,
+      type: "single",
+      animated: c,
+      data: {
+        from_column: e[Math.min(r, e.length - 1)] ?? null,
+        to_column: o[Math.min(r, o.length - 1)] ?? null,
+        relationship_type: t.relationship_type,
+        ...i
+      }
+    }));
+  }
+  return s ? [
+    {
+      id: t.id,
+      source: t.from_id,
+      target: t.to_id,
+      type: "composite",
+      animated: c,
+      data: { from_columns: e, to_columns: o, ...i }
+    }
+  ] : [
+    {
+      id: t.id,
+      source: t.from_id,
+      target: t.to_id,
+      type: "single",
+      animated: c,
+      data: {
+        from_column: e[0] ?? null,
+        to_column: o[0] ?? null,
+        relationship_type: t.relationship_type,
+        ...i
+      }
+    }
+  ];
+}
+function zn(t, n, e = 1) {
+  const o = /* @__PURE__ */ new Set([n]), s = It(t.edges);
+  let c = [n];
+  for (let i = e; i > 0 && c.length > 0; i--) {
+    const d = [];
+    for (const a of c)
+      for (const r of s.get(a) ?? [])
+        o.has(r) || (o.add(r), d.push(r));
+    c = d;
+  }
+  return o;
+}
+function Kn(t) {
+  return t.is_primary_key === !0 || t.is_foreign_key === !0;
+}
+function jn(t) {
+  const n = t.filter(Kn);
+  return n.length ? n : t;
+}
+function Vn(t, n) {
+  const { focus: e, focusDepth: o = 1, compact: s = !1 } = n;
+  let c = t.nodes, i = t.edges;
+  if (e) {
+    const d = zn(t, e, o);
+    c = c.filter((a) => d.has(a.id)), i = i.filter((a) => d.has(a.from_id) && d.has(a.to_id));
+  }
+  return s && (c = c.map((d) => {
+    const a = jn(d.columns), r = d.columns.length - a.length;
+    return r > 0 ? { ...d, columns: a, hidden_column_count: r } : { ...d, columns: a };
+  })), { ...t, nodes: c, edges: i };
+}
+const Xn = {
+  model: { color: "#2f6feb", icon: "table" },
+  source: { color: "#16a34a", icon: "database" },
+  seed: { color: "#b45309", icon: "table" },
+  snapshot: { color: "#7c3aed", icon: "table" }
+}, ue = {
+  nodeBg: "--erd-node-bg",
+  nodeFg: "--erd-node-fg",
+  border: "--erd-border",
+  accent: "--erd-accent",
+  fk: "--erd-fk",
+  headerBg: "--erd-header-bg",
+  hoverBg: "--erd-hover-bg",
+  mutedFg: "--erd-muted-fg",
+  linkFg: "--erd-link-fg",
+  divider: "--erd-divider",
+  icon: "--erd-icon",
+  fontMono: "--erd-font-mono",
+  edge: "--erd-edge",
+  edgeSelected: "--erd-edge-selected",
+  edgeWidth: "--erd-edge-width",
+  edgeSelectedWidth: "--erd-edge-selected-width",
+  minimapBg: "--erd-minimap-bg",
+  minimapDim: "--erd-minimap-dim",
+  minimapMask: "--erd-minimap-mask",
+  shadow: "--erd-shadow"
+};
+function qn(t) {
+  if (!t) return {};
+  const n = {};
+  for (const e of Object.keys(ue)) {
+    const o = t[e];
+    o != null && (n[ue[e]] = o);
+  }
+  return n;
+}
+function me(t) {
+  return t.trim().toLowerCase();
+}
+function no(t) {
+  const {
+    data: n,
+    focus: e = null,
+    focusDepth: o = 1,
+    compact: s = !1,
+    collapseColumns: c = !0,
+    expandAll: i,
+    onExpandStateChange: d,
+    interactive: a = !0,
+    onNodeActivate: r,
+    onOpenNode: m,
+    resourceMeta: u,
+    labelFor: f,
+    theme: x,
+    colorMode: g = "dark",
+    minimap: w = !0,
+    controls: y = !0,
+    background: I = !0,
+    showSchema: M = !1,
+    compositeEdges: E = "bundle",
+    edgePath: p = "cubic",
+    animateEdge: S,
+    estimateSize: N,
+    dimOnSelect: L = !1,
+    onlyRenderVisibleElements: U = !1,
+    fitViewOptions: K,
+    refitKey: F,
+    className: j
+  } = t, Y = t.layout ?? t.defaultLayout ?? Ct, D = t.filter ?? "", q = t.hideUnconnected ?? !1, H = T(
+    () => ({ ...Xn, ...u ?? {} }),
+    [u]
+  ), [k, V] = nt([]), [Z, ke] = nt([]), [Te, kt, Tt] = We([]), [O, At, Ae] = ze([]), [Rt, Ot] = nt(), [J, Pt] = nt(/* @__PURE__ */ new Set()), Dt = P((l) => {
+    Pt((_) => {
+      const h = new Set(_);
+      return h.has(l) ? h.delete(l) : h.add(l), h;
+    });
+  }, []), at = R(null), dt = R(!1), Ht = R(f);
+  Ht.current = f;
+  const Gt = R(N);
+  Gt.current = N;
+  const Bt = R(S);
+  Bt.current = S, W(() => {
+    const l = Vn(n, { focus: e, focusDepth: o, compact: s }), _ = Yn(l, Y, c, {
+      centerId: e ?? null,
+      estimateSize: Gt.current,
+      compositeEdges: E,
+      edgePath: p,
+      animateEdge: Bt.current
+    }), h = Ht.current;
+    if (h)
+      for (const C of _.nodes) C.data.name = h(C.data);
+    V(_.nodes), ke(_.edges), dt.current = !0;
+  }, [n, e, o, s, c, Y, E, p]);
+  const $t = T(() => {
+    const l = me(D);
+    if (!l) return /* @__PURE__ */ new Set();
+    const _ = /* @__PURE__ */ new Set();
+    for (const h of k)
+      me(h.data.name).includes(l) && _.add(h.id);
+    return _;
+  }, [D, k]), lt = D.trim().length > 0, Ut = T(
+    () => new Set(Z.flatMap((l) => [l.source, l.target])),
+    [Z]
+  ), Q = T(
+    () => qe(O),
+    [O]
+  ), Ft = T(() => {
+    const l = /* @__PURE__ */ new Map();
+    for (const [_, h] of Q)
+      l.set(_, [...h].sort().join(","));
+    return l;
+  }, [Q]), tt = T(
+    () => q ? k.filter((l) => l.id === e || Ut.has(l.id)) : k,
+    [k, Ut, q, e]
+  ), G = T(
+    () => new Set(tt.map((l) => l.id)),
+    [tt]
+  ), ut = T(() => {
+    if (!L) return /* @__PURE__ */ new Set();
+    const l = /* @__PURE__ */ new Set();
+    for (const _ of O)
+      _.selected && (l.add(_.source), l.add(_.target));
+    return l;
+  }, [L, O]), Yt = R(/* @__PURE__ */ new Map()), Wt = T(() => {
+    const l = Yt.current, _ = /* @__PURE__ */ new Map(), h = ut.size > 0, C = tt.map((v) => {
+      var qt;
+      const ht = lt ? $t.has(v.id) : !1, ft = v.id === Rt, gt = lt ? ht ? "match" : "dim" : void 0, Ue = Q.get(v.id), Xt = Ft.get(v.id) ?? "", pt = J.has(v.id), _t = ((qt = H[v.data.resource_type ?? ""]) == null ? void 0 : qt.icon) ?? "table", yt = v.id === e, xt = h && !ut.has(v.id), A = l.get(v.id);
+      let et;
+      return A && A.source === v && A.filterState === gt && A.active === ft && A.expanded === pt && A.highlightKey === Xt && A.icon === _t && A.focus === yt && A.dimmed === xt && A.showSchema === M ? et = A : et = {
+        source: v,
+        filterState: gt,
+        active: ft,
+        expanded: pt,
+        highlightKey: Xt,
+        icon: _t,
+        focus: yt,
+        dimmed: xt,
+        showSchema: M,
+        decorated: {
+          ...v,
+          data: {
+            ...v.data,
+            __filterState: gt,
+            __active: ft,
+            __highlightColumns: Ue,
+            __expanded: pt,
+            __onToggleExpand: Dt,
+            __icon: _t,
+            __focus: yt,
+            __dimmed: xt,
+            __showSchema: M
+          }
+        }
+      }, _.set(v.id, et), et.decorated;
+    });
+    return Yt.current = _, C;
+  }, [
+    tt,
+    $t,
+    lt,
+    Rt,
+    Q,
+    Ft,
+    J,
+    Dt,
+    H,
+    e,
+    ut,
+    M
+  ]), zt = T(
+    () => Z.filter((l) => G.has(l.source) && G.has(l.target)),
+    [Z, G]
+  ), mt = R(K);
+  mt.current = K;
+  const Kt = R(null);
+  W(() => {
+    var C;
+    kt(Wt);
+    const l = Kt.current, _ = l !== null && (l.size !== G.size || [...G].some((v) => !l.has(v)));
+    Kt.current = G;
+    const h = dt.current;
+    dt.current = !1, (_ || h) && ((C = at.current) == null || C.fitView({ duration: 200, ...mt.current }));
+  }, [Wt, kt, G]);
+  const jt = R(F);
+  W(() => {
+    if (jt.current === F) return;
+    jt.current = F;
+    const l = setTimeout(() => {
+      var _;
+      (_ = at.current) == null || _.fitView({ duration: 200, ...mt.current });
+    }, 120);
+    return () => clearTimeout(l);
+  }, [F]), W(() => {
+    At((l) => {
+      const _ = new Set(l.filter((h) => h.selected).map((h) => h.id));
+      return zt.map((h) => _.has(h.id) ? { ...h, selected: !0 } : h);
+    });
+  }, [zt, At]);
+  const Re = P(
+    (l, _) => {
+      var v;
+      const h = l.target;
+      if (!(h != null && h.closest(".erd-table-header"))) return;
+      Ot(_.id);
+      const C = (v = k.find((ht) => ht.id === _.id)) == null ? void 0 : v.data;
+      C && (r == null || r(C));
+    },
+    [k, r]
+  ), Oe = P(
+    (l, _) => {
+      var C;
+      const h = (C = k.find((v) => v.id === _.id)) == null ? void 0 : C.data;
+      h && (m == null || m(h));
+    },
+    [k, m]
+  ), Pe = P(
+    (l) => {
+      Tt(l);
+      const _ = /* @__PURE__ */ new Map();
+      for (const h of l)
+        h.type === "position" && h.dragging === !1 && h.position && _.set(h.id, h.position);
+      _.size !== 0 && V(
+        (h) => h.map((C) => {
+          const v = _.get(C.id);
+          return v ? { ...C, position: v } : C;
+        })
+      );
+    },
+    [Tt]
+  ), De = P(() => {
+    Ot(void 0), r == null || r(null);
+  }, [r]), B = T(
+    () => c ? k.filter((l) => X(l.data.columns.length)).map((l) => l.id) : [],
+    [k, c]
+  ), He = [...B].sort().join(",");
+  W(() => {
+    i !== void 0 && Pt(i ? new Set(B) : /* @__PURE__ */ new Set());
+  }, [i, He]);
+  const Vt = T(
+    () => B.length > 0 && B.every((l) => J.has(l)),
+    [B, J]
+  );
+  W(() => {
+    d == null || d({ allExpanded: Vt, canExpand: B.length > 0 });
+  }, [Vt, B.length, d]);
+  const Ge = P(
+    (l) => {
+      var C;
+      const _ = l.data ?? {};
+      if (_.__filterState === "dim")
+        return "var(--erd-minimap-dim, rgba(120, 120, 120, 0.45))";
+      const h = _.resource_type;
+      return h && ((C = H[h]) == null ? void 0 : C.color) || "var(--erd-border, #007acc)";
+    },
+    [H]
+  ), Be = T(() => qn(x), [x]), $e = T(() => !L || !O.some((l) => l.selected) ? O : O.map(
+    (l) => l.selected ? { ...l, animated: !0 } : { ...l, style: { ...l.style, opacity: 0.1 } }
+  ), [L, O]);
+  return /* @__PURE__ */ b("div", { className: `erd-flow${j ? ` ${j}` : ""}`, style: Be, children: /* @__PURE__ */ $(
+    Ke,
+    {
+      nodes: Te,
+      edges: $e,
+      onNodesChange: Pe,
+      onEdgesChange: Ae,
+      onNodeClick: Re,
+      onNodeDoubleClick: Oe,
+      onPaneClick: De,
+      nodeTypes: pn,
+      edgeTypes: ln,
+      onInit: (l) => {
+        at.current = l;
+      },
+      fitView: !0,
+      fitViewOptions: K,
+      onlyRenderVisibleElements: U,
+      minZoom: 0.05,
+      colorMode: g,
+      proOptions: { hideAttribution: !0 },
+      panOnDrag: a,
+      zoomOnScroll: a,
+      zoomOnPinch: a,
+      zoomOnDoubleClick: a,
+      nodesDraggable: a,
+      panOnScroll: !1,
+      children: [
+        I ? /* @__PURE__ */ b(je, {}) : null,
+        y ? /* @__PURE__ */ b(Ve, {}) : null,
+        w ? /* @__PURE__ */ b(
+          Xe,
+          {
+            position: "bottom-right",
+            pannable: !0,
+            zoomable: !0,
+            ariaLabel: "Mini-map",
+            nodeColor: Ge,
+            nodeStrokeColor: "var(--erd-border, #007acc)",
+            nodeStrokeWidth: 2,
+            nodeBorderRadius: 4,
+            maskColor: "var(--erd-minimap-mask, rgba(0, 0, 0, 0.4))",
+            style: {
+              background: "var(--erd-minimap-bg, #1e1e1e)",
+              border: "1px solid var(--erd-divider, #3c3c3c)",
+              borderRadius: 6
+            }
+          }
+        ) : null
+      ]
+    }
+  ) });
+}
+export {
+  Ct as DEFAULT_LAYOUT,
+  Xn as DEFAULT_RESOURCE_META,
+  no as ErdFlow,
+  $n as LAYOUT_STYLES,
+  jn as compactColumns,
+  zn as erdNeighborhood,
+  eo as isLayoutStyle,
+  En as measureNodes,
+  Lt as registerLayout,
+  Un as resolveLayout,
+  qn as themeStyle,
+  Yn as toFlowGraph,
+  Vn as windowPayload
+};