vlite3 1.4.31 → 1.4.32

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;

package/components/Chart/GanttChartDependencyUtils.js

@@ -0,0 +1,113 @@
+import { GANTT_DEPENDENCY_TYPE_LABELS as f } from "./types.js";
+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), {
+      predecessorId: n,
+      successorId: r
+    });
+  };
+  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));
+  }
+  return [...t.values()];
+}
+function d(e, t, i) {
+  return l(e).some(
+    (n) => n.predecessorId === t && n.successorId === i
+  );
+}
+function h(e, t, i = 8) {
+  const n = e.y + t / 2;
+  if (e.milestone) {
+    const r = t * 0.4;
+    return { cx: e.x + e.fullW / 2 + r + i * 0.5, cy: n };
+  }
+  return { cx: e.x + e.fullW + i, cy: n };
+}
+function v(e, t, i, n, r = 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;
+      continue;
+    }
+    if (t >= o.x - r && t <= o.x + o.fullW + r && i >= o.y - r && i <= o.y + n + r)
+      return o;
+  }
+  return null;
+}
+function y(e, t, i) {
+  if (t === i) 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];
+  for (; c.length; ) {
+    const o = c.shift();
+    if (r.has(o)) continue;
+    r.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);
+      }
+  }
+  return !1;
+}
+function x(e, t, i) {
+  if (t === i)
+    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" };
+}
+function E(e, t, i) {
+  if (e.valid === !0)
+    return `Dependency requested: ${i} waiting on ${t}`;
+  switch ("reason" in e ? e.reason : void 0) {
+    case "self":
+      return `Cannot create a dependency from ${t} to itself`;
+    case "duplicate":
+      return `${i} is already waiting on ${t}`;
+    case "circular":
+      return `Cannot link ${t} to ${i}: would create a circular dependency`;
+    case "missing-predecessor":
+      return "Predecessor task is not available";
+    case "missing-successor":
+      return "Successor task is not available";
+    default:
+      return "Invalid dependency target";
+  }
+}
+function p(e, t) {
+  return `${e}\0${t}`;
+}
+function G(e, t, i, n) {
+  return { x: (e + i) / 2, y: (t + n) / 2 };
+}
+function $(e, t, i, n = 40, r = 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 };
+}
+export {
+  E as describeGanttDependencyLinkValidation,
+  v as findGanttDependencyBarAtPoint,
+  p as ganttDependencyEdgeKey,
+  y as ganttDependencyReachable,
+  D as ganttDependencyTypeLabel,
+  h as getGanttDependencyConnectorPosition,
+  G as getGanttDependencyEdgeMidpoint,
+  $ as getGanttDependencyEdgeScrollDelta,
+  d as hasGanttScheduleDependency,
+  l as resolveGanttScheduleDependencyEdges,
+  x as validateGanttDependencyLink
+};

package/components/Chart/GanttChartResizePreviewUtils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure resize/move preview math for GanttChart.
+ * Preview snapping must match the values emitted on pointer release.
+ */
+export type GanttInteractionMode = 'move' | 'resize-left' | 'resize-right';
+export type GanttInteractionPreview = {
+    /** Half-day-snapped day delta applied to the interaction */
+    snappedDays: number;
+    /** Pixel delta after min-duration clamp (pre-snap) */
+    clampedPxDelta: number;
+    start: Date;
+    end: Date;
+};
+/** Same snap used on drag end — half-day increments */
+export declare function snapGanttDayDelta(daysDelta: number): number;
+/**
+ * Clamp a resize pixel delta so the task never shrinks below min duration.
+ */
+export declare function clampGanttResizePxDelta(input: {
+    mode: 'resize-left' | 'resize-right';
+    pxDelta: number;
+    origDurationDays: number;
+    pxToDays: (px: number) => number;
+    daysToPx: (days: number) => number;
+    minDurationDays?: number;
+}): number;
+/**
+ * Compute temporary preview dates for move/resize.
+ * Uses the same half-day snap and min-duration rules as the final emission.
+ */
+export declare function computeGanttInteractionPreview(input: {
+    mode: GanttInteractionMode;
+    pxDelta: number;
+    origStart: Date;
+    origEnd: Date;
+    origDurationDays: number;
+    pxToDays: (px: number) => number;
+    daysToPx: (days: number) => number;
+    addDays: (d: Date, n: number) => Date;
+    minDurationDays?: number;
+}): GanttInteractionPreview;
+/** Pixel geometry for a temporary preview bar derived from preview dates */
+export declare function ganttPreviewBarGeometry(input: {
+    start: Date;
+    end: Date;
+    dateToX: (d: Date) => number;
+    minWidthPx?: number;
+}): {
+    x: number;
+    fullW: number;
+    xEnd: number;
+};

package/components/Chart/GanttChartResizePreviewUtils.js

@@ -0,0 +1,53 @@
+function D(a) {
+  return Math.round(a * 2) / 2;
+}
+function d(a) {
+  const o = a.minDurationDays ?? 0.5, r = a.pxToDays(a.pxDelta), e = a.origDurationDays;
+  return a.mode === "resize-left" && r >= e - o ? a.daysToPx(e - o) : a.mode === "resize-right" && -r >= e - o ? -a.daysToPx(e - o) : a.pxDelta;
+}
+function n(a) {
+  const o = a.minDurationDays ?? 0.5;
+  let r = a.pxDelta;
+  (a.mode === "resize-left" || a.mode === "resize-right") && (r = d({
+    mode: a.mode,
+    pxDelta: a.pxDelta,
+    origDurationDays: a.origDurationDays,
+    pxToDays: a.pxToDays,
+    daysToPx: a.daysToPx,
+    minDurationDays: o
+  }));
+  let e = D(a.pxToDays(r));
+  if (a.mode === "move")
+    return {
+      snappedDays: e,
+      clampedPxDelta: r,
+      start: a.addDays(a.origStart, e),
+      end: a.addDays(a.origEnd, e)
+    };
+  if (a.mode === "resize-left") {
+    const s = a.origDurationDays - o;
+    return e = Math.min(e, s), {
+      snappedDays: e,
+      clampedPxDelta: r,
+      start: a.addDays(a.origStart, e),
+      end: new Date(a.origEnd.getTime())
+    };
+  }
+  const t = -(a.origDurationDays - o);
+  return e = Math.max(e, t), {
+    snappedDays: e,
+    clampedPxDelta: r,
+    start: new Date(a.origStart.getTime()),
+    end: a.addDays(a.origEnd, e)
+  };
+}
+function m(a) {
+  const o = a.dateToX(a.start), r = a.dateToX(a.end), e = Math.max(a.minWidthPx ?? 8, r - o);
+  return { x: o, fullW: e, xEnd: o + e };
+}
+export {
+  d as clampGanttResizePxDelta,
+  n as computeGanttInteractionPreview,
+  m as ganttPreviewBarGeometry,
+  D as snapGanttDayDelta
+};

package/components/Chart/GanttChartTooltipUtils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure tooltip placement helpers for GanttChart.
+ * Keeps task tooltips clear of the dependency connector and viewport edges.
+ */
+/** Axis-aligned screen rect to steer the tooltip away from */
+export type GanttTooltipAvoidRect = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export type GanttTooltipPlaceInput = {
+    pointerX: number;
+    pointerY: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    /** Estimated tooltip box — used only for collision / clamping */
+    estimatedWidth?: number;
+    estimatedHeight?: number;
+    /** Optional region to avoid (e.g. dependency connector hit area in screen space) */
+    avoid?: GanttTooltipAvoidRect | null;
+    gap?: number;
+    /** Extra shift below the pointer (positive moves tooltip down) */
+    offsetBottom?: number;
+    margin?: number;
+};
+export type GanttTooltipPlaceResult = {
+    left: number;
+    top: number;
+};
+/**
+ * Place a Gantt task tooltip near the pointer while avoiding an optional
+ * connector rect and staying inside the viewport.
+ * Prefers sitting just below the task/pointer so it does not cover the connector.
+ */
+export declare function placeGanttTaskTooltip(input: GanttTooltipPlaceInput): GanttTooltipPlaceResult;
+/**
+ * Whether a pointer in SVG space is inside the connector clear zone
+ * (hide tooltip rather than fighting overlap).
+ */
+export declare function isGanttPointerNearConnector(pointerSvgX: number, pointerSvgY: number, connectorSvgX: number, connectorSvgY: number, radius?: number): boolean;

package/components/Chart/GanttChartTooltipUtils.js

@@ -0,0 +1,63 @@
+function d(f, t, a, s, p) {
+  const o = f + a, e = t + s;
+  return !(o < p.left || f > p.right || e < p.top || t > p.bottom);
+}
+function m(f, t, a, s, p, o, e) {
+  return {
+    left: Math.max(e, Math.min(f, Math.max(e, p - a - e))),
+    top: Math.max(e, Math.min(t, Math.max(e, o - s - e)))
+  };
+}
+function x(f) {
+  const {
+    pointerX: t,
+    pointerY: a,
+    viewportWidth: s,
+    viewportHeight: p,
+    estimatedWidth: o = 200,
+    estimatedHeight: e = 120,
+    avoid: i = null,
+    gap: n = 12,
+    offsetBottom: M = 16,
+    margin: u = 8
+  } = f, l = a + M, h = [];
+  i && (h.push({
+    left: t + n,
+    top: Math.max(l, i.bottom + n)
+  }), h.push({
+    left: i.left - o - n,
+    top: Math.max(l, i.bottom + n)
+  }), h.push({
+    left: Math.min(t, i.left) - o - n,
+    top: l
+  })), h.push({ left: t + n, top: l }), h.push({ left: t - o - n, top: l }), h.push({ left: t - o / 2, top: l }), h.push({ left: t + n, top: a - n }), h.push({ left: t - o / 2, top: a - e - n });
+  for (const c of h) {
+    const r = m(
+      c.left,
+      c.top,
+      o,
+      e,
+      s,
+      p,
+      u
+    );
+    if (!i || !d(r.left, r.top, o, e, i))
+      return r;
+  }
+  return m(
+    t - o - n,
+    l,
+    o,
+    e,
+    s,
+    p,
+    u
+  );
+}
+function b(f, t, a, s, p = 16) {
+  return Math.hypot(f - a, t - s) <= p;
+}
+export {
+  b as isGanttPointerNearConnector,
+  x as placeGanttTaskTooltip
+};

package/components/Chart/index.d.ts

@@ -9,5 +9,7 @@ export { default as SegmentBarChart } from './SegmentBarChart.vue';
 export { default as StatCardChart } from './StatCardChart.vue';
 export { default as WaffleChart } from './WaffleChart.vue';
 export { default as GanttChart } from './GanttChart.vue';
-export type { ChartDataPoint, ChartDataset, ChartLegendsVariant, LegendPosition, LineChartProps, BarChartProps, PieChartProps, CircleChartProps, GaugeChartProps, GaugeVariant, GaugeZone, SpeedometerChartProps, SpeedometerVariant, TimelineChartProps, TimelineTask, SegmentBarChartProps, StatCardChartProps, StatCardItem, WaffleChartProps, GanttChartProps, GanttTask, GanttViewMode, } from './types';
+export type { ChartDataPoint, ChartDataset, ChartLegendsVariant, LegendPosition, LineChartProps, BarChartProps, PieChartProps, CircleChartProps, GaugeChartProps, GaugeVariant, GaugeZone, SpeedometerChartProps, SpeedometerVariant, TimelineChartProps, TimelineTask, SegmentBarChartProps, StatCardChartProps, StatCardItem, WaffleChartProps, GanttChartProps, GanttTask, GanttViewMode, GanttDependencyType, GanttTaskDependencyLink, GanttDependencyCreatePayload, GanttDependencyDeletePayload, } from './types';
+export { GANTT_DEPENDENCY_TYPE_LABELS } from './types';
+export { formatGanttLocalDate, parseGanttDate, ganttDateToX, ganttCalendarDaysBetween, } from './GanttChartDateUtils';
 export { default as ChartLegend } from './ChartLegend.vue';

package/components/Chart/types.d.ts

@@ -362,6 +362,30 @@ export interface WaffleChartProps {
 }
 /** View granularity for the Gantt time axis */
 export type GanttViewMode = 'day' | 'week' | 'month';
+/**
+ * User-facing dependency type from the **owning task's** perspective.
+ *
+ * - `waiting-on` — this task cannot proceed until `taskId` is completed
+ * - `blocking` — this task prevents `taskId` from proceeding
+ * - `related-to` — connected, but does not schedule-block (no Gantt arrow)
+ *
+ * `waiting-on` and `blocking` are opposite views of one schedule edge:
+ * "B waiting on A" === "A blocking B". Parents should persist one canonical
+ * record (e.g. BLOCKS with blockingTaskId=A, waitingTaskId=B).
+ */
+export type GanttDependencyType = 'waiting-on' | 'blocking' | 'related-to';
+/** Display labels for the Type | Task selector pattern */
+export declare const GANTT_DEPENDENCY_TYPE_LABELS: Record<GanttDependencyType, string>;
+/**
+ * Typed dependency link on a Gantt task.
+ * Only `waiting-on` / `blocking` contribute to schedule arrows; `related-to` does not.
+ */
+export interface GanttTaskDependencyLink {
+    /** The other task in this relationship */
+    taskId: string;
+    /** Relationship from THIS task's perspective */
+    type: GanttDependencyType;
+}
 /** A single task (or milestone) on the Gantt chart */
 export interface GanttTask {
     /** Unique identifier for this task */
@@ -378,8 +402,18 @@ export interface GanttTask {
     color?: string;
     /** Group label — tasks sharing the same group are visually grouped */
     group?: string;
-    /** IDs of tasks this task depends on. Renders dependency arrows */
+    /**
+     * Legacy / shorthand: IDs of tasks this task is **waiting on** (predecessors).
+     * Renders finish-to-start dependency arrows. Equivalent to
+     * `dependencyLinks: [{ taskId, type: 'waiting-on' }, ...]`.
+     */
     dependencies?: string[];
+    /**
+     * Typed user-facing dependency links (Waiting on / Blocking / Related to).
+     * Schedule arrows are drawn only for waiting-on / blocking edges.
+     * `related-to` is retained for parent UIs and never draws an arrow.
+     */
+    dependencyLinks?: GanttTaskDependencyLink[];
     /** If true, renders as a diamond milestone marker instead of a bar */
     milestone?: boolean;
 }
@@ -422,8 +456,49 @@ export interface GanttChartProps {
     locale?: string;
     /** Allow drag-and-drop to move/resize tasks */
     draggable?: boolean;
+    /**
+     * Opt-in: show dependency connectors and allow creating links by drag
+     * (or keyboard). Independent of `showDependencies` (which only controls
+     * rendering of existing arrows). Default `false` for backward compatibility.
+     */
+    editableDependencies?: boolean;
     /** When moving a task, also shift all dependent tasks recursively */
     cascadeDependencies?: boolean;
     /** Show zoom controls and enable Ctrl/Meta + wheel zoom */
     zoom?: boolean;
 }
+/**
+ * Payload emitted by GanttChart `@dependency-create`.
+ * Parent should persist one canonical schedule edge
+ * (successor waiting on predecessor / predecessor blocking successor)
+ * and pass updated `tasks` back — the chart never mutates tasks.
+ */
+export interface GanttDependencyCreatePayload {
+    /** Task that must finish first (source / arrow origin) */
+    predecessorId: string;
+    /** Task that waits on the predecessor */
+    successorId: string;
+    predecessor: GanttTask;
+    successor: GanttTask;
+    /**
+     * User-facing type from the **successor's** perspective.
+     * Connector linking always emits `waiting-on`
+     * (successor Waiting on | predecessor).
+     */
+    type: Extract<GanttDependencyType, 'waiting-on'>;
+    /** Localized-ready label, e.g. "Waiting on" */
+    typeLabel: string;
+}
+/**
+ * Payload emitted by GanttChart `@dependency-delete`.
+ * Parent should remove the canonical schedule edge and update `tasks`.
+ */
+export interface GanttDependencyDeletePayload {
+    predecessorId: string;
+    successorId: string;
+    predecessor: GanttTask;
+    successor: GanttTask;
+    /** Same semantics as create — schedule edge from successor's view */
+    type: Extract<GanttDependencyType, 'waiting-on'>;
+    typeLabel: string;
+}

package/components/Chart/types.js

@@ -0,0 +1,8 @@
+const o = {
+  "waiting-on": "Waiting on",
+  blocking: "Blocking",
+  "related-to": "Related to"
+};
+export {
+  o as GANTT_DEPENDENCY_TYPE_LABELS
+};

package/components/ColorPicker/ColorIro.vue3.js

@@ -1,5 +1,5 @@
-import o from "./ColorIro.vue.js";
-/* empty css              */
+import o from "./ColorIro.vue2.js";
+/* empty css             */
 export {
   o as default
 };

package/components/ColorPicker/ColorPicker.vue.js

@@ -7,8 +7,8 @@ import "../../core/config.js";
 /* empty css                                    */
 /* empty css                            */
 import k from "../Button.vue.js";
-import N from "./ColorIro.vue.js";
-/* empty css              */
+import N from "./ColorIro.vue2.js";
+/* empty css             */
 import { useEyeDropper as j } from "@vueuse/core";
 const I = ["disabled", "aria-label"], U = { class: "min-w-0 truncate text-foreground" }, A = { class: "absolute left-2.5 top-1/2 -translate-y-1/2 flex items-center justify-center z-20 pointer-events-none" }, F = {
   key: 0,