vlite3 1.4.32 → 1.4.34

package/components/Chart/GanttChartConnectorRouting.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Obstacle-aware dependency connector routing for GanttChart.
+ *
+ * Replaces the fixed elbow calculation with a deterministic router that:
+ *  - anchors finish-to-start edges on the predecessor's right edge and the
+ *    successor's left edge (milestones use the diamond tips)
+ *  - distributes exit / entry points when several edges share a task so
+ *    arrowheads and stubs never stack
+ *  - generates orthogonal candidate paths per edge (direct, Z-shaped and
+ *    row-corridor routes, plus variants that slide vertical runs past
+ *    blocking bars) and picks the cheapest one by length + turns +
+ *    task-bar collisions + connector crossings/overlaps + viewport cost
+ *  - nudges coincident segments into separate lanes so parallel connectors
+ *    stay individually traceable
+ *  - renders unavoidable crossings with a small line bridge (hop) instead
+ *    of visually merging two connectors
+ *
+ * The router is pure and layout-driven: the same bars and edges always
+ * produce the same paths (no randomness, input-order independent). It
+ * knows nothing about dependency semantics — callers must only pass
+ * schedule edges (related-to never reaches here).
+ */
+export interface GanttConnectorBar {
+    id: string;
+    /** Bar left edge in timeline SVG coordinates */
+    x: number;
+    /** Bar top edge in timeline SVG coordinates */
+    y: number;
+    /** Full bar width (not progress width) */
+    w: number;
+    /** Bar height */
+    h: number;
+    /** Visible row index the bar sits on */
+    row: number;
+    milestone?: boolean;
+}
+export interface GanttConnectorEdge {
+    predecessorId: string;
+    successorId: string;
+    /** Stable edge key (see ganttDependencyEdgeKey) */
+    key: string;
+}
+export interface GanttRoutedConnector {
+    key: string;
+    predecessorId: string;
+    successorId: string;
+    /** Rounded orthogonal SVG path for the connector line */
+    d: string;
+    /** Arrowhead path entering the successor's left edge */
+    ad: string;
+    /** On-path midpoint (delete control / label placement) */
+    midX: number;
+    midY: number;
+}
+export interface GanttConnectorRoutingOptions {
+    rowHeight: number;
+    barHeight: number;
+    /** Timeline drawing width — routes are kept inside the viewport */
+    chartWidth: number;
+    /** Timeline drawing height */
+    chartHeight: number;
+    cornerRadius?: number;
+    arrowSize?: number;
+}
+type Pt = {
+    x: number;
+    y: number;
+};
+/**
+ * Build an SVG path with consistent rounded corners and crossing bridges.
+ * Exposed for reuse by the lightweight interaction preview.
+ */
+export declare function ganttRoundedConnectorPath(points: ReadonlyArray<Pt>, radius?: number, bridges?: Map<number, number[]>): string;
+/** Arrowhead entering horizontally from the left, tip at (x, y) */
+export declare function ganttConnectorArrowPath(x: number, y: number, size?: number): string;
+/**
+ * Lightweight connector path used while dragging/resizing. No obstacle
+ * lookup — just the classic elbow with the same rounded-corner styling —
+ * so per-frame updates stay cheap. Final routing runs after the gesture.
+ */
+export declare function ganttConnectorPreviewPath(fX: number, fY: number, tX: number, tY: number, rowHeight: number, barHeight: number, radius?: number): string;
+export declare function routeGanttDependencyConnectors(edges: GanttConnectorEdge[], barsById: ReadonlyMap<string, GanttConnectorBar>, options: GanttConnectorRoutingOptions): GanttRoutedConnector[];
+export {};

package/components/Chart/GanttChartConnectorRouting.js

@@ -0,0 +1,405 @@
+const g = (t) => Math.round(t * 100) / 100, H = (t, n, e) => Math.min(e, Math.max(n, t));
+function P(t) {
+  return t.h * 0.4;
+}
+function k(t) {
+  return t.milestone ? t.x + t.w / 2 + P(t) : t.x + t.w;
+}
+function U(t) {
+  return t.milestone ? t.x + t.w / 2 - P(t) : t.x;
+}
+function v(t) {
+  return t.y + t.h / 2;
+}
+function T(t) {
+  if (t.milestone) {
+    const n = P(t), e = t.x + t.w / 2, o = v(t);
+    return { id: t.id, x: e - n, y: o - n, w: n * 2, h: n * 2, row: t.row };
+  }
+  return { id: t.id, x: t.x, y: t.y, w: t.w, h: t.h, row: t.row };
+}
+function C(t) {
+  const n = [];
+  for (let e = 0; e < t.length - 1; e++) {
+    const o = t[e], c = t[e + 1];
+    Math.abs(o.x - c.x) < 0.01 && Math.abs(o.y - c.y) < 0.01 || n.push({ x1: o.x, y1: o.y, x2: c.x, y2: c.y, vertical: Math.abs(o.x - c.x) < 0.01 });
+  }
+  return n;
+}
+function N(t) {
+  return Math.abs(t.x2 - t.x1) + Math.abs(t.y2 - t.y1);
+}
+function A(t, n, e, o, c = 0) {
+  const s = Math.max(Math.min(t, n), Math.min(e, o));
+  return Math.min(Math.max(t, n), Math.max(e, o)) - s > c;
+}
+function B(t, n) {
+  return t.vertical ? t.x1 <= n.x + 0.5 || t.x1 >= n.x + n.w - 0.5 ? !1 : A(t.y1, t.y2, n.y + 0.5, n.y + n.h - 0.5) : t.y1 <= n.y + 0.5 || t.y1 >= n.y + n.h - 0.5 ? !1 : A(t.x1, t.x2, n.x + 0.5, n.x + n.w - 0.5);
+}
+function L(t, n, e = 0.75) {
+  if (t.vertical === n.vertical) return !1;
+  const o = t.vertical ? t : n, c = t.vertical ? n : t, s = o.x1 > Math.min(c.x1, c.x2) + e && o.x1 < Math.max(c.x1, c.x2) - e, i = c.y1 > Math.min(o.y1, o.y2) + e && c.y1 < Math.max(o.y1, o.y2) - e;
+  return s && i;
+}
+function G(t, n, e) {
+  return t.vertical !== n.vertical ? !1 : t.vertical ? Math.abs(t.x1 - n.x1) >= e ? !1 : A(t.y1, t.y2, n.y1, n.y2, 4) : Math.abs(t.y1 - n.y1) >= e ? !1 : A(t.x1, t.x2, n.x1, n.x2, 4);
+}
+function O(t) {
+  const n = [];
+  for (const e of t) {
+    const o = n[n.length - 1];
+    o && Math.abs(o.x - e.x) < 0.01 && Math.abs(o.y - e.y) < 0.01 || n.push({ x: e.x, y: e.y });
+  }
+  for (let e = n.length - 2; e >= 1; e--) {
+    const o = n[e - 1], c = n[e], s = n[e + 1], i = Math.abs(o.x - c.x) < 0.01, r = Math.abs(c.x - s.x) < 0.01, l = Math.abs(o.y - c.y) < 0.01, h = Math.abs(c.y - s.y) < 0.01;
+    (i && r || l && h) && n.splice(e, 1);
+  }
+  return n;
+}
+class V {
+  byRow = /* @__PURE__ */ new Map();
+  rowHeight;
+  constructor(n, e) {
+    this.rowHeight = e;
+    for (const o of n) {
+      const c = T(o), s = this.byRow.get(c.row);
+      s ? s.push(c) : this.byRow.set(c.row, [c]);
+    }
+  }
+  /** First obstacle strictly intersected by the segment, or null */
+  firstHit(n, e, o) {
+    const c = Math.min(n.y1, n.y2), s = Math.max(n.y1, n.y2), i = Math.floor(c / this.rowHeight) - 1, r = Math.floor(s / this.rowHeight) + 1;
+    for (let l = i; l <= r; l++) {
+      const h = this.byRow.get(l);
+      if (h) {
+        for (const f of h)
+          if (!(f.id === e || f.id === o) && B(n, f))
+            return f;
+      }
+    }
+    return null;
+  }
+  /** Number of obstacles strictly intersected by the segment */
+  hitCount(n, e, o) {
+    const c = Math.min(n.y1, n.y2), s = Math.max(n.y1, n.y2), i = Math.floor(c / this.rowHeight) - 1, r = Math.floor(s / this.rowHeight) + 1;
+    let l = 0;
+    for (let h = i; h <= r; h++) {
+      const f = this.byRow.get(h);
+      if (f)
+        for (const u of f)
+          u.id === e || u.id === o || B(n, u) && l++;
+    }
+    return l;
+  }
+}
+function $(t, n, e) {
+  const o = /* @__PURE__ */ new Map();
+  for (const s of t) {
+    const i = n === "source" ? s.pred.id : s.succ.id, r = o.get(i);
+    r ? r.push(s) : o.set(i, [s]);
+  }
+  const c = /* @__PURE__ */ new Map();
+  for (const s of o.values()) {
+    if (s.length === 1) {
+      c.set(s[0].key, 0);
+      continue;
+    }
+    const i = [...s].sort((u, a) => {
+      const x = n === "source" ? u.succ : u.pred, d = n === "source" ? a.succ : a.pred;
+      return x.row !== d.row ? x.row - d.row : x.x !== d.x ? x.x - d.x : u.key < a.key ? -1 : 1;
+    }), r = i.length, h = (n === "source" ? i[0].pred : i[0].succ).milestone ? 4 : Math.max(3, e / 2 - 3), f = Math.min(6, 2 * h / (r - 1));
+    i.forEach((u, a) => {
+      c.set(u.key, H((a - (r - 1) / 2) * f, -h, h));
+    });
+  }
+  return c;
+}
+function W(t, n) {
+  if (t === n) return [t, t + 1];
+  const e = Math.min(t, n) + 1, o = Math.max(t, n);
+  if (o - e <= 3) {
+    const c = [];
+    for (let s = e; s <= o; s++) c.push(s);
+    return c;
+  }
+  return [.../* @__PURE__ */ new Set([e, Math.floor((e + o) / 2), o])];
+}
+function R(t, n, e, o, c, s, i, r, l) {
+  let h = t;
+  for (let f = 0; f < 6; f++) {
+    const u = l.obstacles.firstHit(
+      { x1: h, y1: n, x2: h, y2: e, vertical: !0 },
+      c,
+      s
+    );
+    if (!u) return h >= i && h <= r ? h : null;
+    h = o > 0 ? u.x + u.w + 5 : u.x - 5;
+  }
+  return null;
+}
+function F(t, n, e, o, c, s, i) {
+  const r = [], l = n.x - t.x >= 24, h = 2, f = i.chartWidth - 2;
+  if (l)
+    if (Math.abs(t.y - n.y) < 0.75)
+      r.push([t, n]);
+    else {
+      const x = [.../* @__PURE__ */ new Set([t.x + 12, (t.x + n.x) / 2, n.x - 12])], d = [];
+      for (const y of x) {
+        r.push([t, { x: y, y: t.y }, { x: y, y: n.y }, n]);
+        for (const M of [1, -1]) {
+          const w = R(
+            y,
+            t.y,
+            n.y,
+            M,
+            c,
+            s,
+            t.x + 2,
+            n.x - 2,
+            i
+          );
+          w !== null && Math.abs(w - y) > 0.5 && d.push(w);
+        }
+      }
+      for (const y of [...new Set(d)])
+        r.push([t, { x: y, y: t.y }, { x: y, y: n.y }, n]);
+    }
+  const u = H(t.x + 12, h, f), a = H(n.x - 12, h, f);
+  for (const x of W(e, o)) {
+    const d = H(x * i.rowHeight, 2, i.chartHeight - 2), y = [u], M = R(
+      u,
+      t.y,
+      d,
+      1,
+      c,
+      s,
+      t.x + 2,
+      f,
+      i
+    );
+    M !== null && Math.abs(M - u) > 0.5 && y.push(M);
+    const w = [a], I = R(
+      a,
+      d,
+      n.y,
+      -1,
+      c,
+      s,
+      h,
+      n.x - 2,
+      i
+    );
+    I !== null && Math.abs(I - a) > 0.5 && w.push(I);
+    for (const _ of y)
+      for (const E of w)
+        r.push([
+          t,
+          { x: _, y: t.y },
+          { x: _, y: d },
+          { x: E, y: d },
+          { x: E, y: n.y },
+          n
+        ]);
+  }
+  return r.map(O).filter((x) => x.length >= 2);
+}
+function z(t, n, e, o) {
+  let c = 0, s = 0, i = 0;
+  for (const r of t)
+    c += N(r), s += o.obstacles.hitCount(r, n, e), (r.x1 < 0 || r.x1 > o.chartWidth || r.x2 < 0 || r.x2 > o.chartWidth || r.y1 < 0 || r.y1 > o.chartHeight || r.y2 < 0 || r.y2 > o.chartHeight) && i++;
+  return c + (t.length - 1) * 14 + s * 2e3 + i * 400;
+}
+function j(t, n, e) {
+  let o = 0, c = 0;
+  for (const s of t) {
+    const i = s.vertical ? e : n, r = s.vertical ? n : e;
+    for (const l of i)
+      L(s, l) && o++;
+    for (const l of r)
+      G(s, l, 4) && c++;
+  }
+  return o * 12 + c * 280;
+}
+const Q = 4;
+function Z(t, n, e, o, c, s) {
+  const i = t.map((u) => ({ x: u.x, y: u.y })), r = i.length - 1;
+  if (r < 3) return i;
+  const l = Math.max(0, (s.rowHeight - s.barHeight) / 2), h = [
+    5,
+    -5,
+    10,
+    -10,
+    15,
+    -15
+  ], f = (u) => {
+    if (s.obstacles.firstHit(u, n, e)) return !0;
+    const a = u.vertical ? o : c;
+    for (const x of a)
+      if (G(u, x, 5 - 0.5)) return !0;
+    return !1;
+  };
+  for (let u = 1; u <= r - 2; u++) {
+    const a = i[u], x = i[u + 1], d = Math.abs(a.x - x.x) < 0.01, y = { x1: a.x, y1: a.y, x2: x.x, y2: x.y, vertical: d };
+    if (f(y))
+      if (d) {
+        const M = i[u - 1], w = i[u + 2], I = Math.sign(a.x - M.x), _ = Math.sign(w.x - x.x);
+        for (const E of h) {
+          const S = a.x + E;
+          if (!(S < 2 || S > s.chartWidth - 2) && !(I !== 0 && (Math.sign(S - M.x) !== I || Math.abs(S - M.x) < 2)) && !(_ !== 0 && (Math.sign(w.x - S) !== _ || Math.abs(w.x - S) < 2)) && !f({ x1: S, y1: a.y, x2: S, y2: x.y, vertical: !0 })) {
+            a.x = S, x.x = S;
+            break;
+          }
+        }
+      } else {
+        const M = t[u].y, w = i[u - 1], I = i[u + 2], _ = Math.sign(a.y - w.y), E = Math.sign(I.y - x.y), S = Math.max(0, l - 1.5);
+        for (const m of h) {
+          if (Math.abs(m) > S) continue;
+          const p = M + m;
+          if (!(p < 2 || p > s.chartHeight - 2) && !(_ !== 0 && (Math.sign(p - w.y) !== _ || Math.abs(p - w.y) < 2)) && !(E !== 0 && (Math.sign(I.y - p) !== E || Math.abs(I.y - p) < 2)) && !f({ x1: a.x, y1: p, x2: x.x, y2: p, vertical: !1 })) {
+            a.y = p, x.y = p;
+            break;
+          }
+        }
+      }
+  }
+  return i;
+}
+function J(t, n, e, o) {
+  const c = /* @__PURE__ */ new Map(), s = C(t), i = o + 3.5 + 2;
+  return s.forEach((r, l) => {
+    const h = r.vertical ? e : n, f = [];
+    for (const y of h)
+      L(r, y) && f.push(r.vertical ? y.y1 : y.x1);
+    if (!f.length) return;
+    const u = (r.vertical ? Math.min(r.y1, r.y2) : Math.min(r.x1, r.x2)) + i, a = (r.vertical ? Math.max(r.y1, r.y2) : Math.max(r.x1, r.x2)) - i, x = [...new Set(f)].sort((y, M) => y - M).filter((y) => y > u && y < a), d = [];
+    for (const y of x)
+      d.length && y - d[d.length - 1] < 3.5 * 2 + 1 || d.push(y);
+    d.length && c.set(l, d);
+  }), c;
+}
+function K(t, n, e) {
+  const o = t[n - 1], c = t[n], s = t[n + 1], i = Math.abs(c.x - o.x) + Math.abs(c.y - o.y), r = Math.abs(s.x - c.x) + Math.abs(s.y - c.y);
+  return Math.max(0, Math.min(e, i / 2, r / 2));
+}
+function D(t, n = 5, e = /* @__PURE__ */ new Map()) {
+  const o = O(t);
+  if (o.length < 2) return "";
+  const c = [`M ${g(o[0].x)} ${g(o[0].y)}`];
+  for (let s = 0; s < o.length - 1; s++) {
+    const i = o[s], r = o[s + 1], l = Math.sign(r.x - i.x), h = Math.sign(r.y - i.y), f = s < o.length - 2 ? K(o, s + 1, n) : 0, u = e.get(s) ?? [];
+    if (u.length) {
+      const a = h === 0 ? l : h, x = a > 0 ? 1 : 0, d = [...u].sort((y, M) => a > 0 ? y - M : M - y);
+      for (const y of d)
+        h === 0 ? (c.push(`L ${g(y - l * 3.5)} ${g(i.y)}`), c.push(`A ${3.5} ${3.5} 0 0 ${x} ${g(y + l * 3.5)} ${g(i.y)}`)) : (c.push(`L ${g(i.x)} ${g(y - h * 3.5)}`), c.push(`A ${3.5} ${3.5} 0 0 ${x} ${g(i.x)} ${g(y + h * 3.5)}`));
+    }
+    if (c.push(`L ${g(r.x - l * f)} ${g(r.y - h * f)}`), s < o.length - 2 && f > 0) {
+      const a = o[s + 2], x = Math.sign(a.x - r.x), d = Math.sign(a.y - r.y);
+      c.push(`Q ${g(r.x)} ${g(r.y)} ${g(r.x + x * f)} ${g(r.y + d * f)}`);
+    }
+  }
+  return c.join(" ");
+}
+function q(t, n, e = 5) {
+  return `M ${g(t)} ${g(n)} L ${g(t - e)} ${g(n - e * 0.6)} L ${g(t - e)} ${g(n + e * 0.6)} Z`;
+}
+function X(t) {
+  const n = C(t);
+  if (!n.length) return t[0] ?? { x: 0, y: 0 };
+  let o = n.reduce((s, i) => s + N(i), 0) / 2;
+  for (const s of n) {
+    const i = N(s);
+    if (o <= i) {
+      const r = i > 0 ? o / i : 0;
+      return { x: s.x1 + (s.x2 - s.x1) * r, y: s.y1 + (s.y2 - s.y1) * r };
+    }
+    o -= i;
+  }
+  const c = n[n.length - 1];
+  return { x: c.x2, y: c.y2 };
+}
+function Y(t, n, e, o, c, s, i = 5) {
+  let l;
+  if (e > t + 32)
+    if (Math.abs(n - o) < 2)
+      l = [{ x: t, y: n }, { x: e, y: o }];
+    else {
+      const h = t + (e - t) / 2;
+      l = [{ x: t, y: n }, { x: h, y: n }, { x: h, y: o }, { x: e, y: o }];
+    }
+  else if (Math.abs(n - o) < c * 0.5) {
+    const h = Math.max(n, o) + s / 2 + 16;
+    l = [
+      { x: t, y: n },
+      { x: t + 16, y: n },
+      { x: t + 16, y: h },
+      { x: e - 16, y: h },
+      { x: e - 16, y: o },
+      { x: e, y: o }
+    ];
+  } else
+    l = [{ x: t, y: n }, { x: t + 16, y: n }, { x: t + 16, y: o }, { x: e, y: o }];
+  return D(l, i);
+}
+function tt(t, n, e) {
+  const o = {
+    rowHeight: e.rowHeight,
+    barHeight: e.barHeight,
+    chartWidth: Math.max(e.chartWidth, 40),
+    chartHeight: Math.max(e.chartHeight, e.rowHeight),
+    obstacles: new V(n.values(), e.rowHeight)
+  }, c = e.cornerRadius, s = e.arrowSize ?? 5, i = [];
+  for (const a of t) {
+    const x = n.get(a.predecessorId), d = n.get(a.successorId);
+    !x || !d || i.push({ key: a.key, predecessorId: a.predecessorId, successorId: a.successorId, pred: x, succ: d });
+  }
+  i.sort((a, x) => a.pred.row - x.pred.row || a.succ.row - x.succ.row || (a.key < x.key ? -1 : a.key > x.key ? 1 : 0));
+  const r = $(i, "source", o.barHeight), l = $(i, "target", o.barHeight), h = [], f = [], u = [];
+  for (const a of i) {
+    const x = {
+      x: k(a.pred),
+      y: v(a.pred) + (r.get(a.key) ?? 0)
+    }, d = {
+      x: U(a.succ),
+      y: v(a.succ) + (l.get(a.key) ?? 0)
+    }, y = F(
+      x,
+      d,
+      a.pred.row,
+      a.succ.row,
+      a.pred.id,
+      a.succ.id,
+      o
+    );
+    if (!y.length) continue;
+    const M = y.map((m, p) => {
+      const b = C(m);
+      return { pts: m, segs: b, index: p, base: z(b, a.pred.id, a.succ.id, o) };
+    }).sort((m, p) => m.base - p.base || m.index - p.index);
+    let w = M[0].pts, I = Number.POSITIVE_INFINITY;
+    for (const m of M.slice(0, Q)) {
+      const p = m.base + j(m.segs, h, f);
+      p < I - 1e-6 && (I = p, w = m.pts);
+    }
+    const _ = O(
+      Z(w, a.pred.id, a.succ.id, h, f, o)
+    ), E = J(_, h, f, c), S = X(_);
+    u.push({
+      key: a.key,
+      predecessorId: a.predecessorId,
+      successorId: a.successorId,
+      d: D(_, c, E),
+      ad: q(d.x, d.y, s),
+      midX: g(S.x),
+      midY: g(S.y)
+    });
+    for (const m of C(_))
+      m.vertical ? h.push(m) : f.push(m);
+  }
+  return u;
+}
+export {
+  q as ganttConnectorArrowPath,
+  Y as ganttConnectorPreviewPath,
+  D as ganttRoundedConnectorPath,
+  tt as routeGanttDependencyConnectors
+};

package/components/Chart/GanttChartDependencyUtils.js

@@ -3,83 +3,83 @@ function D(e) {
   return f[e];
 }
 function l(e) {
-  const t = /* @__PURE__ */ new Map(), i = (n, r) => {
-    !n || !r || n === r || t.set(p(n, r), {
+  const i = /* @__PURE__ */ new Map(), r = (n, t) => {
+    !n || !t || n === t || i.set(p(n, t), {
       predecessorId: n,
-      successorId: r
+      successorId: t
     });
   };
   for (const n of e) {
-    for (const r of n.dependencies ?? [])
-      i(r, n.id);
-    for (const r of n.dependencyLinks ?? [])
-      r.type !== "related-to" && (r.type === "waiting-on" ? i(r.taskId, n.id) : r.type === "blocking" && i(n.id, r.taskId));
+    for (const t of n.dependencies ?? [])
+      r(t, n.id);
+    for (const t of n.dependencyLinks ?? [])
+      t.type !== "related-to" && (t.type === "waiting-on" ? r(t.taskId, n.id) : t.type === "blocking" && r(n.id, t.taskId));
   }
-  return [...t.values()];
+  return [...i.values()];
 }
-function d(e, t, i) {
+function d(e, i, r) {
   return l(e).some(
-    (n) => n.predecessorId === t && n.successorId === i
+    (n) => n.predecessorId === i && n.successorId === r
   );
 }
-function h(e, t, i = 8) {
-  const n = e.y + t / 2;
+function h(e, i, r = 8) {
+  const n = e.y + i / 2;
   if (e.milestone) {
-    const r = t * 0.4;
-    return { cx: e.x + e.fullW / 2 + r + i * 0.5, cy: n };
+    const t = i * 0.4;
+    return { cx: e.x + e.fullW / 2 + t + r * 0.5, cy: n };
   }
-  return { cx: e.x + e.fullW + i, cy: n };
+  return { cx: e.x + e.fullW + r, cy: n };
 }
-function v(e, t, i, n, r = 4) {
+function v(e, i, r, n, t = 4) {
   for (let c = e.length - 1; c >= 0; c--) {
     const o = e[c];
     if (o.milestone) {
-      const s = o.x + o.fullW / 2, u = o.y + n / 2, a = n * 0.4 + r;
-      if (Math.abs(t - s) <= a && Math.abs(i - u) <= a) return o;
+      const s = o.x + o.fullW / 2, a = o.y + n / 2, u = n * 0.4 + t;
+      if (Math.abs(i - s) <= u && Math.abs(r - a) <= u) return o;
       continue;
     }
-    if (t >= o.x - r && t <= o.x + o.fullW + r && i >= o.y - r && i <= o.y + n + r)
+    if (i >= o.x - t && i <= o.x + o.fullW + t && r >= o.y - t && r <= o.y + n + t)
       return o;
   }
   return null;
 }
-function y(e, t, i) {
-  if (t === i) return !0;
+function y(e, i, r) {
+  if (i === r) return !0;
   const n = /* @__PURE__ */ new Map();
   for (const o of l(e)) {
     const s = n.get(o.successorId) ?? [];
     s.push(o.predecessorId), n.set(o.successorId, s);
   }
-  const r = /* @__PURE__ */ new Set(), c = [t];
+  const t = /* @__PURE__ */ new Set(), c = [i];
   for (; c.length; ) {
     const o = c.shift();
-    if (r.has(o)) continue;
-    r.add(o);
+    if (t.has(o)) continue;
+    t.add(o);
     const s = n.get(o);
     if (s?.length)
-      for (const u of s) {
-        if (u === i) return !0;
-        r.has(u) || c.push(u);
+      for (const a of s) {
+        if (a === r) return !0;
+        t.has(a) || c.push(a);
       }
   }
   return !1;
 }
-function x(e, t, i) {
-  if (t === i)
+function $(e, i, r) {
+  if (i === r)
     return { valid: !1, reason: "self" };
-  const n = e.find((c) => c.id === t), r = e.find((c) => c.id === i);
-  return n ? r ? d(e, t, i) ? { valid: !1, reason: "duplicate" } : y(e, t, i) ? { valid: !1, reason: "circular" } : { valid: !0 } : { valid: !1, reason: "missing-successor" } : { valid: !1, reason: "missing-predecessor" };
+  const n = e.find((c) => c.id === i), t = e.find((c) => c.id === r);
+  return n ? t ? d(e, i, r) ? { valid: !1, reason: "duplicate" } : y(e, i, r) ? { valid: !1, reason: "circular" } : { valid: !0 } : { valid: !1, reason: "missing-successor" } : { valid: !1, reason: "missing-predecessor" };
 }
-function E(e, t, i) {
+function k(e, i, r) {
   if (e.valid === !0)
-    return `Dependency requested: ${i} waiting on ${t}`;
+    return `Dependency requested: ${r} waiting on ${i}`;
   switch ("reason" in e ? e.reason : void 0) {
     case "self":
-      return `Cannot create a dependency from ${t} to itself`;
+      return `Cannot create a dependency from ${i} to itself`;
     case "duplicate":
-      return `${i} is already waiting on ${t}`;
+      return `${r} is already waiting on ${i}`;
     case "circular":
-      return `Cannot link ${t} to ${i}: would create a circular dependency`;
+      return `Cannot link ${i} to ${r}: would create a circular dependency`;
     case "missing-predecessor":
       return "Predecessor task is not available";
     case "missing-successor":
@@ -88,26 +88,22 @@ function E(e, t, i) {
       return "Invalid dependency target";
   }
 }
-function p(e, t) {
-  return `${e}\0${t}`;
+function p(e, i) {
+  return `${e}\0${i}`;
 }
-function G(e, t, i, n) {
-  return { x: (e + i) / 2, y: (t + n) / 2 };
-}
-function $(e, t, i, n = 40, r = 14) {
+function x(e, i, r, n = 40, t = 14) {
   let c = 0, o = 0;
-  return e < i.left + n ? c = -r : e > i.right - n && (c = r), t < i.top + n ? o = -r : t > i.bottom - n && (o = r), { dx: c, dy: o };
+  return e < r.left + n ? c = -t : e > r.right - n && (c = t), i < r.top + n ? o = -t : i > r.bottom - n && (o = t), { dx: c, dy: o };
 }
 export {
-  E as describeGanttDependencyLinkValidation,
+  k as describeGanttDependencyLinkValidation,
   v as findGanttDependencyBarAtPoint,
   p as ganttDependencyEdgeKey,
   y as ganttDependencyReachable,
   D as ganttDependencyTypeLabel,
   h as getGanttDependencyConnectorPosition,
-  G as getGanttDependencyEdgeMidpoint,
-  $ as getGanttDependencyEdgeScrollDelta,
+  x as getGanttDependencyEdgeScrollDelta,
   d as hasGanttScheduleDependency,
   l as resolveGanttScheduleDependencyEdges,
-  x as validateGanttDependencyLink
+  $ as validateGanttDependencyLink
 };

package/components/Chart/types.d.ts

@@ -416,6 +416,14 @@ export interface GanttTask {
     dependencyLinks?: GanttTaskDependencyLink[];
     /** If true, renders as a diamond milestone marker instead of a bar */
     milestone?: boolean;
+    /**
+     * Presentational blocked state (e.g. waiting on incomplete work or manually
+     * blocked). Renders a hatched overlay + lock marker on the bar and a
+     * blocked line in the tooltip. Purely visual — parents own the rule.
+     */
+    blocked?: boolean;
+    /** Short human-readable reason shown in the tooltip when `blocked` */
+    blockedReason?: string;
 }
 export interface GanttChartProps {
     /** Array of task objects */
@@ -462,7 +470,14 @@ export interface GanttChartProps {
      * rendering of existing arrows). Default `false` for backward compatibility.
      */
     editableDependencies?: boolean;
-    /** When moving a task, also shift all dependent tasks recursively */
+    /**
+     * When moving a task, dependent tasks visually FOLLOW during the drag as a
+     * preview. On release only ONE `task-update` is emitted (the root task) —
+     * the parent/server owns the authoritative cascade and passes the final
+     * dates back through `tasks`. (The pre-1.x behavior of emitting one update
+     * per dependent task is removed: it produced N independent writes with no
+     * transactional guarantee.)
+     */
     cascadeDependencies?: boolean;
     /** Show zoom controls and enable Ctrl/Meta + wheel zoom */
     zoom?: boolean;