vlite3 1.4.31 → 1.4.33

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/GanttChartDateUtils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pure calendar-date helpers for GanttChart layout and interaction.
+ *
+ * Task dates are treated as local calendar days (not UTC instants).
+ * Date-only ISO strings (`YYYY-MM-DD`) are parsed as local midnight so
+ * bars align with timeline column boundaries in every timezone.
+ */
+export type GanttDateViewMode = 'day' | 'week' | 'month';
+/** Local calendar midnight for a date */
+export declare function ganttStartOfLocalDay(d: Date): Date;
+/**
+ * Parse a Gantt task date as a local calendar day at 00:00:00.
+ * - `YYYY-MM-DD` → local midnight (never UTC)
+ * - Datetime strings / Date → normalized to local start of that calendar day
+ */
+export declare function parseGanttDate(d: Date | string): Date;
+/** Whole calendar days between local dates (time-of-day ignored). */
+export declare function ganttCalendarDaysBetween(a: Date, b: Date): number;
+export declare function ganttAddDays(d: Date, n: number): Date;
+/** Monday-based week start at local midnight */
+export declare function ganttStartOfWeek(d: Date): Date;
+export declare function ganttStartOfMonth(d: Date): Date;
+/** Format a local calendar date as `YYYY-MM-DD` (not UTC via toISOString). */
+export declare function formatGanttLocalDate(d: Date): string;
+/**
+ * Convert a calendar date to timeline X.
+ * A date that equals a column's start boundary maps to that column's left edge.
+ */
+export declare function ganttDateToX(d: Date, rangeStart: Date, viewMode: GanttDateViewMode, columnWidth: number): number;
+/** Pixel delta → calendar-day delta for the active view mode */
+export declare function ganttPxToDays(px: number, viewMode: GanttDateViewMode, columnWidth: number): number;
+/** Calendar-day delta → pixel delta for the active view mode */
+export declare function ganttDaysToPx(days: number, viewMode: GanttDateViewMode, columnWidth: number): number;
+/**
+ * X of the left edge of the column that contains `d` (or starts at `d`
+ * when `d` is exactly on a column boundary).
+ */
+export declare function ganttColumnBoundaryX(d: Date, rangeStart: Date, viewMode: GanttDateViewMode, columnWidth: number): number;

package/components/Chart/GanttChartDateUtils.js

@@ -0,0 +1,79 @@
+const s = /^(\d{4})-(\d{2})-(\d{2})$/, f = /^(\d{4})-(\d{2})-(\d{2})/;
+function u(t) {
+  return new Date(t.getFullYear(), t.getMonth(), t.getDate(), 0, 0, 0, 0);
+}
+function i(t) {
+  if (t instanceof Date)
+    return Number.isNaN(t.getTime()) ? /* @__PURE__ */ new Date(NaN) : u(t);
+  const e = String(t).trim();
+  if (!e) return /* @__PURE__ */ new Date(NaN);
+  const n = s.exec(e);
+  if (n)
+    return new Date(
+      Number(n[1]),
+      Number(n[2]) - 1,
+      Number(n[3]),
+      0,
+      0,
+      0,
+      0
+    );
+  const r = f.exec(e);
+  if (r && (e.includes("T") || e.includes(" ")))
+    return new Date(
+      Number(r[1]),
+      Number(r[2]) - 1,
+      Number(r[3]),
+      0,
+      0,
+      0,
+      0
+    );
+  const a = new Date(e);
+  return Number.isNaN(a.getTime()) ? a : u(a);
+}
+function o(t, e) {
+  const n = Date.UTC(t.getFullYear(), t.getMonth(), t.getDate());
+  return (Date.UTC(e.getFullYear(), e.getMonth(), e.getDate()) - n) / 864e5;
+}
+function N(t, e) {
+  const n = u(t);
+  return n.setDate(n.getDate() + e), n;
+}
+function l(t) {
+  const e = u(t), n = e.getDay();
+  return e.setDate(e.getDate() - (n === 0 ? 6 : n - 1)), e;
+}
+function y(t) {
+  return new Date(t.getFullYear(), t.getMonth(), 1, 0, 0, 0, 0);
+}
+function w(t) {
+  const e = t.getFullYear(), n = String(t.getMonth() + 1).padStart(2, "0"), r = String(t.getDate()).padStart(2, "0");
+  return `${e}-${n}-${r}`;
+}
+function T(t, e, n, r) {
+  if (n === "day")
+    return o(e, t) * r;
+  if (n === "week")
+    return o(e, t) / 7 * r;
+  const a = e, g = (t.getFullYear() - a.getFullYear()) * 12 + (t.getMonth() - a.getMonth()), c = new Date(t.getFullYear(), t.getMonth() + 1, 0).getDate(), D = (t.getDate() - 1) / c;
+  return (g + D) * r;
+}
+function F(t, e, n) {
+  return e === "day" ? t / n : e === "week" ? t / n * 7 : t / n * 30.44;
+}
+function Y(t, e, n) {
+  return e === "day" ? t * n : e === "week" ? t / 7 * n : t / 30.44 * n;
+}
+export {
+  w as formatGanttLocalDate,
+  N as ganttAddDays,
+  o as ganttCalendarDaysBetween,
+  T as ganttDateToX,
+  Y as ganttDaysToPx,
+  F as ganttPxToDays,
+  u as ganttStartOfLocalDay,
+  y as ganttStartOfMonth,
+  l as ganttStartOfWeek,
+  i as parseGanttDate
+};

package/components/Chart/GanttChartDependencyUtils.d.ts

@@ -0,0 +1,92 @@
+import { GanttDependencyType, GanttTask, GanttTaskDependencyLink } from './types';
+/** Why a proposed predecessor → successor link was rejected */
+export type GanttDependencyLinkRejectReason = 'self' | 'duplicate' | 'circular' | 'missing-predecessor' | 'missing-successor';
+export type GanttDependencyLinkValidation = {
+    valid: true;
+} | {
+    valid: false;
+    reason: GanttDependencyLinkRejectReason;
+};
+export type GanttDependencyTaskRef = Pick<GanttTask, 'id' | 'dependencies' | 'dependencyLinks' | 'milestone'> & {
+    name?: string;
+};
+/** Canonical schedule edge used for Gantt arrows (finish-to-start) */
+export type GanttScheduleDependencyEdge = {
+    predecessorId: string;
+    successorId: string;
+};
+/** Minimal bar geometry needed for connector / hit-testing */
+export interface GanttDependencyBarGeometry {
+    id: string;
+    x: number;
+    y: number;
+    fullW: number;
+    milestone?: boolean;
+}
+/** User-facing label for a dependency type (Type | Task selector) */
+export declare function ganttDependencyTypeLabel(type: GanttDependencyType): string;
+/**
+ * Normalize UI / API strings into a canonical `GanttDependencyType`.
+ * Accepts labels ("Waiting on"), kebab/snake/enum forms.
+ */
+export declare function normalizeGanttDependencyType(input: string): GanttDependencyType | null;
+/**
+ * Reverse user-facing view of a schedule edge.
+ * Waiting on ↔ Blocking; Related to is symmetrical.
+ */
+export declare function invertGanttDependencyType(type: GanttDependencyType): GanttDependencyType;
+/**
+ * Resolve all schedule (arrow-drawing) edges from `dependencies[]` and
+ * typed `dependencyLinks`. `related-to` never produces an edge.
+ *
+ * Waiting-on / blocking from either endpoint collapse to one
+ * predecessor → successor direction.
+ */
+export declare function resolveGanttScheduleDependencyEdges(tasks: GanttDependencyTaskRef[]): GanttScheduleDependencyEdge[];
+/** Predecessor IDs this task is waiting on (for arrows / cascade) */
+export declare function getGanttWaitingOnTaskIds(task: GanttDependencyTaskRef): string[];
+/** Whether a schedule edge already exists between predecessor and successor */
+export declare function hasGanttScheduleDependency(tasks: GanttDependencyTaskRef[], predecessorId: string, successorId: string): boolean;
+/**
+ * Connector sits just past the dependency *output* edge so it does not
+ * cover resize handles or bar labels. Milestones use the diamond's right tip.
+ */
+export declare function getGanttDependencyConnectorPosition(bar: GanttDependencyBarGeometry, barHeight: number, offset?: number): {
+    cx: number;
+    cy: number;
+};
+/** Find the visible bar under an SVG-space pointer, if any. */
+export declare function findGanttDependencyBarAtPoint(bars: GanttDependencyBarGeometry[], x: number, y: number, barHeight: number, hitPadding?: number): GanttDependencyBarGeometry | null;
+/**
+ * Walk the schedule graph starting at `fromId`, following edges toward
+ * predecessors (from waiting-on / blocking-resolved edges).
+ */
+export declare function ganttDependencyReachable(tasks: GanttDependencyTaskRef[], fromId: string, targetId: string): boolean;
+/**
+ * Validate adding a schedule edge: successor waiting on predecessor.
+ * Does not mutate any task data. Related-to is out of scope here.
+ */
+export declare function validateGanttDependencyLink(tasks: GanttDependencyTaskRef[], predecessorId: string, successorId: string): GanttDependencyLinkValidation;
+/** Human-readable status for aria-live announcements */
+export declare function describeGanttDependencyLinkValidation(validation: GanttDependencyLinkValidation, predecessorName: string, successorName: string): string;
+/** Stable key for a predecessor → successor dependency edge */
+export declare function ganttDependencyEdgeKey(predecessorId: string, successorId: string): string;
+/** Midpoint used to place the delete control on a dependency edge */
+export declare function getGanttDependencyEdgeMidpoint(fX: number, fY: number, tX: number, tY: number): {
+    x: number;
+    y: number;
+};
+/** Edge scroll: return scroll deltas when the pointer is near a viewport edge */
+export declare function getGanttDependencyEdgeScrollDelta(clientX: number, clientY: number, viewport: {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}, edge?: number, speed?: number): {
+    dx: number;
+    dy: number;
+};
+/** Format "Type | Task" for selectors / announcements */
+export declare function formatGanttDependencySelectorLabel(type: GanttDependencyType, taskName: string): string;
+/** Build a typed waiting-on link for parent state updates */
+export declare function createGanttWaitingOnLink(taskId: string): GanttTaskDependencyLink;