nuxt-ui-elements-pro 0.1.9 → 0.1.11

package/dist/runtime/utils/event-calendar.d.ts

@@ -1,14 +1,6 @@
 import type { CalendarDate, CalendarDateTime } from "@internationalized/date";
 import type { NormalizedEvent, PositionedEvent, CalendarWeek, MonthWeekLayout, AllDayLayout, TimeGridDay } from "../types/event-calendar.js";
-/**
- * Compute the start of the week for any weekStartsOn value (0=Sunday … 6=Saturday).
- * Uses getDayOfWeek with a fixed locale ('en-US') so Sunday is always 0.
- */
-export declare function startOfWeekByDay(date: CalendarDate, weekStartsOn: number): CalendarDate;
-/**
- * Compute the end of the week for any weekStartsOn value.
- */
-export declare function endOfWeekByDay(date: CalendarDate, weekStartsOn: number): CalendarDate;
+export { startOfWeekByDay, endOfWeekByDay } from "./date.js";
 /** Check whether a DateValue has hour/minute (CalendarDateTime vs CalendarDate) */
 export declare function hasTimeComponent(d: CalendarDate | CalendarDateTime): boolean;
 /**

package/dist/runtime/utils/event-calendar.js

@@ -1,12 +1,5 @@
-import { getDayOfWeek, toCalendarDate, toCalendarDateTime } from "@internationalized/date";
-export function startOfWeekByDay(date, weekStartsOn) {
-  const dow = getDayOfWeek(date, "en-US");
-  const diff = (dow - weekStartsOn + 7) % 7;
-  return toCalendarDate(date.subtract({ days: diff }));
-}
-export function endOfWeekByDay(date, weekStartsOn) {
-  return toCalendarDate(startOfWeekByDay(date, weekStartsOn).add({ days: 6 }));
-}
+import { toCalendarDate, toCalendarDateTime } from "@internationalized/date";
+export { startOfWeekByDay, endOfWeekByDay } from "./date.js";
 export function hasTimeComponent(d) {
   return "hour" in d;
 }

package/dist/runtime/utils/gantt-chart.d.ts

@@ -0,0 +1,85 @@
+import { CalendarDate } from "@internationalized/date";
+import type { NormalizedGanttTask, GanttTaskTreeNode, GanttTaskBar, GanttDependency, GanttDependencyPath, GanttTimelineColumn, GanttHeaderGroup, GanttLayout, GanttZoomLevel, GanttZoomPresets } from "../types/gantt-chart.js";
+export declare const DEFAULT_ROW_HEIGHT = 40;
+export declare const DEFAULT_ZOOM_PRESETS: GanttZoomPresets;
+/** Count the number of days from `a` to `b` (b - a). Can be negative. */
+export declare function daysBetween(a: CalendarDate, b: CalendarDate): number;
+/** Approximate month difference (fractional) from `a` to `b`. */
+export declare function monthsBetween(a: CalendarDate, b: CalendarDate): number;
+/**
+ * Align a date to the start or end of the appropriate zoom boundary.
+ * E.g., for "month" zoom, aligns to the 1st of the month.
+ */
+export declare function alignToZoomBoundary(date: CalendarDate, zoomLevel: GanttZoomLevel, edge: "start" | "end"): CalendarDate;
+/**
+ * Convert a CalendarDate to pixel offset from the timeline start.
+ */
+export declare function dateToPixel(date: CalendarDate, timelineStart: CalendarDate, zoomLevel: GanttZoomLevel, unitWidth: number): number;
+/**
+ * Convert a pixel offset to a CalendarDate, snapped to the appropriate unit.
+ */
+export declare function pixelToDate(px: number, timelineStart: CalendarDate, zoomLevel: GanttZoomLevel, unitWidth: number): CalendarDate;
+/**
+ * Snap a pixel value to the nearest grid line for the given zoom level.
+ */
+export declare function snapToGrid(px: number, zoomLevel: GanttZoomLevel, unitWidth: number): number;
+/**
+ * Compute timeline start/end from tasks, with padding aligned to zoom boundaries.
+ */
+export declare function computeTimelineBounds(tasks: NormalizedGanttTask[], zoomLevel: GanttZoomLevel): {
+    start: CalendarDate;
+    end: CalendarDate;
+};
+/**
+ * Generate timeline columns for the bottom header row.
+ */
+export declare function generateColumns(start: CalendarDate, end: CalendarDate, zoomLevel: GanttZoomLevel, unitWidth: number, locale: string): GanttTimelineColumn[];
+/**
+ * Generate header groups (top row above columns).
+ */
+export declare function generateHeaderGroups(columns: GanttTimelineColumn[], zoomLevel: GanttZoomLevel, locale: string): GanttHeaderGroup[];
+/**
+ * Build a forest of trees from a flat task list using parentId.
+ * Tasks with parentId === null/undefined are roots. Multiple roots are supported.
+ */
+export declare function buildTaskTree(tasks: NormalizedGanttTask[]): GanttTaskTreeNode[];
+/**
+ * Flatten the task tree into a visible list, respecting expanded state.
+ */
+export declare function flattenVisibleTasks(tree: GanttTaskTreeNode[], expandedIds: Set<string | number>): {
+    task: NormalizedGanttTask;
+    depth: number;
+    isGroup: boolean;
+    isExpanded: boolean;
+    childCount: number;
+}[];
+/**
+ * Walk the tree bottom-up and set each group's start/end to the min/max
+ * of all its descendants. This ensures summary bars always encompass
+ * their children, matching the behavior of tools like MS Project.
+ */
+export declare function computeGroupSpans(tree: GanttTaskTreeNode[]): void;
+/**
+ * Collect all task IDs that have children (i.e., are groups).
+ */
+export declare function getAllGroupIds(tree: GanttTaskTreeNode[]): Set<string | number>;
+/**
+ * Compute SVG path data for Finish-to-Start dependency arrows.
+ */
+export declare function computeDependencyPaths(bars: GanttTaskBar[], dependencies: GanttDependency[], rowHeight: number): GanttDependencyPath[];
+export declare function buildDependencyPath(from: GanttTaskBar, to: GanttTaskBar, rowHeight: number): {
+    path: string;
+    fromPoint: {
+        x: number;
+        y: number;
+    };
+    toPoint: {
+        x: number;
+        y: number;
+    };
+};
+/**
+ * Compute the full Gantt chart layout: task bar positions, columns, headers,
+ * dependency paths, and today marker.
+ */
+export declare function computeGanttLayout(tasks: NormalizedGanttTask[], dependencies: GanttDependency[], expandedIds: Set<string | number>, zoomLevel: GanttZoomLevel, unitWidth: number, rowHeight: number, locale: string): GanttLayout;

package/dist/runtime/utils/gantt-chart.js

@@ -0,0 +1,549 @@
+import { CalendarDate, getDayOfWeek, today, getLocalTimeZone } from "@internationalized/date";
+import { startOfWeekByDay } from "./date.js";
+export const DEFAULT_ROW_HEIGHT = 40;
+export const DEFAULT_ZOOM_PRESETS = {
+  day: { unitWidth: 40 },
+  week: { unitWidth: 60 },
+  month: { unitWidth: 30 },
+  quarter: { unitWidth: 30 },
+  year: { unitWidth: 60 }
+};
+export function daysBetween(a, b) {
+  return b.compare(a);
+}
+export function monthsBetween(a, b) {
+  const yearDiff = b.year - a.year;
+  const monthDiff = b.month - a.month;
+  const dayFraction = (b.day - a.day) / 30;
+  return yearDiff * 12 + monthDiff + dayFraction;
+}
+function daysInMonth(year, month) {
+  return new CalendarDate(year, month, 1).add({ months: 1 }).subtract({ days: 1 }).day;
+}
+export function alignToZoomBoundary(date, zoomLevel, edge) {
+  switch (zoomLevel) {
+    case "day":
+      return edge === "start" ? date : date;
+    case "week": {
+      const weekStart = startOfWeekByDay(date, 1);
+      return edge === "start" ? weekStart : weekStart.add({ days: 6 });
+    }
+    case "month":
+      return edge === "start" ? new CalendarDate(date.year, date.month, 1) : new CalendarDate(date.year, date.month, daysInMonth(date.year, date.month));
+    case "quarter": {
+      const qStartMonth = Math.floor((date.month - 1) / 3) * 3 + 1;
+      if (edge === "start") {
+        return new CalendarDate(date.year, qStartMonth, 1);
+      }
+      const qEndMonth = qStartMonth + 2;
+      return new CalendarDate(date.year, qEndMonth, daysInMonth(date.year, qEndMonth));
+    }
+    case "year":
+      return edge === "start" ? new CalendarDate(date.year, 1, 1) : new CalendarDate(date.year, 12, 31);
+  }
+}
+export function dateToPixel(date, timelineStart, zoomLevel, unitWidth) {
+  switch (zoomLevel) {
+    case "day": {
+      const days = daysBetween(timelineStart, date);
+      return days * 24 * unitWidth;
+    }
+    case "week":
+    case "month": {
+      const days = daysBetween(timelineStart, date);
+      return days * unitWidth;
+    }
+    case "quarter": {
+      const days = daysBetween(timelineStart, date);
+      return days / 7 * unitWidth;
+    }
+    case "year": {
+      const months = monthsBetween(timelineStart, date);
+      return months * unitWidth;
+    }
+  }
+}
+export function pixelToDate(px, timelineStart, zoomLevel, unitWidth) {
+  switch (zoomLevel) {
+    case "day": {
+      const totalHours = px / unitWidth;
+      const days = Math.floor(totalHours / 24);
+      return timelineStart.add({ days });
+    }
+    case "week":
+    case "month": {
+      const days = Math.round(px / unitWidth);
+      return timelineStart.add({ days });
+    }
+    case "quarter": {
+      const weeks = px / unitWidth;
+      const days = Math.round(weeks * 7);
+      return timelineStart.add({ days });
+    }
+    case "year": {
+      const months = Math.round(px / unitWidth);
+      return timelineStart.add({ months });
+    }
+  }
+}
+export function snapToGrid(px, zoomLevel, unitWidth) {
+  switch (zoomLevel) {
+    case "day":
+      return Math.round(px / unitWidth) * unitWidth;
+    case "week":
+    case "month":
+      return Math.round(px / unitWidth) * unitWidth;
+    case "quarter":
+      return Math.round(px / unitWidth) * unitWidth;
+    case "year":
+      return Math.round(px / unitWidth) * unitWidth;
+  }
+}
+export function computeTimelineBounds(tasks, zoomLevel) {
+  if (tasks.length === 0) {
+    const now = today(getLocalTimeZone());
+    return {
+      start: alignToZoomBoundary(now.subtract({ months: 1 }), zoomLevel, "start"),
+      end: alignToZoomBoundary(now.add({ months: 1 }), zoomLevel, "end")
+    };
+  }
+  let minStart = tasks[0].start;
+  let maxEnd = tasks[0].end;
+  for (const task of tasks) {
+    if (task.start.compare(minStart) < 0) minStart = task.start;
+    if (task.end.compare(maxEnd) > 0) maxEnd = task.end;
+  }
+  const paddingMap = {
+    day: { days: 1 },
+    week: { days: 7 },
+    month: { days: 14 },
+    quarter: { months: 1 },
+    year: { months: 2 }
+  };
+  const padding = paddingMap[zoomLevel];
+  const paddedStart = padding.months ? minStart.subtract({ months: padding.months }) : minStart.subtract({ days: padding.days ?? 7 });
+  const paddedEnd = padding.months ? maxEnd.add({ months: padding.months }) : maxEnd.add({ days: padding.days ?? 7 });
+  return {
+    start: alignToZoomBoundary(paddedStart, zoomLevel, "start"),
+    end: alignToZoomBoundary(paddedEnd, zoomLevel, "end")
+  };
+}
+export function generateColumns(start, end, zoomLevel, unitWidth, locale) {
+  const columns = [];
+  const todayDate = today(getLocalTimeZone());
+  switch (zoomLevel) {
+    case "day": {
+      const hourFormatter = new Intl.DateTimeFormat(locale, { hour: "numeric" });
+      let cursor = start;
+      while (cursor.compare(end) <= 0) {
+        for (let hour = 0; hour < 24; hour++) {
+          const leftPx = dateToPixel(cursor, start, zoomLevel, unitWidth) + hour * unitWidth;
+          const label = hourFormatter.format(new Date(cursor.year, cursor.month - 1, cursor.day, hour));
+          columns.push({
+            date: cursor,
+            label,
+            widthPx: unitWidth,
+            leftPx,
+            isToday: cursor.compare(todayDate) === 0,
+            isWeekend: getDayOfWeek(cursor, "en-US") === 0 || getDayOfWeek(cursor, "en-US") === 6
+          });
+        }
+        cursor = cursor.add({ days: 1 });
+      }
+      break;
+    }
+    case "week":
+    case "month": {
+      let cursor = start;
+      let leftPx = 0;
+      while (cursor.compare(end) <= 0) {
+        const dow = getDayOfWeek(cursor, "en-US");
+        columns.push({
+          date: cursor,
+          label: zoomLevel === "week" ? new Intl.DateTimeFormat(locale, { weekday: "short" }).format(new Date(cursor.year, cursor.month - 1, cursor.day)) + " " + cursor.day : String(cursor.day),
+          widthPx: unitWidth,
+          leftPx,
+          isToday: cursor.compare(todayDate) === 0,
+          isWeekend: dow === 0 || dow === 6
+        });
+        cursor = cursor.add({ days: 1 });
+        leftPx += unitWidth;
+      }
+      break;
+    }
+    case "quarter": {
+      let cursor = startOfWeekByDay(start, 1);
+      let leftPx = 0;
+      while (cursor.compare(end) <= 0) {
+        columns.push({
+          date: cursor,
+          label: `W${getWeekNumber(cursor)}`,
+          widthPx: unitWidth,
+          leftPx,
+          isToday: cursor.compare(todayDate) <= 0 && cursor.add({ days: 6 }).compare(todayDate) >= 0,
+          isWeekend: false
+        });
+        cursor = cursor.add({ days: 7 });
+        leftPx += unitWidth;
+      }
+      break;
+    }
+    case "year": {
+      let cursor = new CalendarDate(start.year, start.month, 1);
+      let leftPx = 0;
+      while (cursor.compare(end) <= 0) {
+        const label = new Intl.DateTimeFormat(locale, { month: "short" }).format(
+          new Date(cursor.year, cursor.month - 1, 1)
+        );
+        columns.push({
+          date: cursor,
+          label,
+          widthPx: unitWidth,
+          leftPx,
+          isToday: cursor.year === todayDate.year && cursor.month === todayDate.month,
+          isWeekend: false
+        });
+        if (cursor.month === 12) {
+          cursor = new CalendarDate(cursor.year + 1, 1, 1);
+        } else {
+          cursor = new CalendarDate(cursor.year, cursor.month + 1, 1);
+        }
+        leftPx += unitWidth;
+      }
+      break;
+    }
+  }
+  return columns;
+}
+function getWeekNumber(date) {
+  const jsDate = new Date(Date.UTC(date.year, date.month - 1, date.day));
+  const dayNum = jsDate.getUTCDay() || 7;
+  jsDate.setUTCDate(jsDate.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(jsDate.getUTCFullYear(), 0, 1));
+  return Math.ceil(((jsDate.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+export function generateHeaderGroups(columns, zoomLevel, locale) {
+  if (columns.length === 0) return [];
+  const groups = [];
+  switch (zoomLevel) {
+    case "day": {
+      let currentDate = columns[0].date;
+      let groupStart = 0;
+      for (let i = 0; i < columns.length; i++) {
+        if (columns[i].date.compare(currentDate) !== 0) {
+          const span2 = i - groupStart;
+          groups.push({
+            label: formatGroupLabel(currentDate, "day", locale),
+            span: span2,
+            leftPx: columns[groupStart].leftPx,
+            widthPx: span2 * columns[0].widthPx
+          });
+          currentDate = columns[i].date;
+          groupStart = i;
+        }
+      }
+      const span = columns.length - groupStart;
+      groups.push({
+        label: formatGroupLabel(currentDate, "day", locale),
+        span,
+        leftPx: columns[groupStart].leftPx,
+        widthPx: span * columns[0].widthPx
+      });
+      break;
+    }
+    case "week": {
+      let currentWeekStart = startOfWeekByDay(columns[0].date, 1);
+      let groupStartIdx = 0;
+      for (let i = 0; i < columns.length; i++) {
+        const ws = startOfWeekByDay(columns[i].date, 1);
+        if (ws.compare(currentWeekStart) !== 0) {
+          pushGroupFromColumns(groups, columns, groupStartIdx, i, currentWeekStart, "week", locale);
+          currentWeekStart = ws;
+          groupStartIdx = i;
+        }
+      }
+      pushGroupFromColumns(groups, columns, groupStartIdx, columns.length, currentWeekStart, "week", locale);
+      break;
+    }
+    case "month": {
+      let currentKey = `${columns[0].date.year}-${columns[0].date.month}`;
+      let groupStartIdx = 0;
+      for (let i = 0; i < columns.length; i++) {
+        const key = `${columns[i].date.year}-${columns[i].date.month}`;
+        if (key !== currentKey) {
+          pushGroupFromColumns(groups, columns, groupStartIdx, i, columns[groupStartIdx].date, "month", locale);
+          currentKey = key;
+          groupStartIdx = i;
+        }
+      }
+      pushGroupFromColumns(groups, columns, groupStartIdx, columns.length, columns[groupStartIdx].date, "month", locale);
+      break;
+    }
+    case "quarter": {
+      const firstColMonth = getMonthForWeekColumn(columns[0].date);
+      let currentKey = `${firstColMonth.year}-${firstColMonth.month}`;
+      let groupStartIdx = 0;
+      for (let i = 0; i < columns.length; i++) {
+        const colMonth = getMonthForWeekColumn(columns[i].date);
+        const key = `${colMonth.year}-${colMonth.month}`;
+        if (key !== currentKey) {
+          pushGroupFromColumns(groups, columns, groupStartIdx, i, columns[groupStartIdx].date, "quarter", locale);
+          currentKey = key;
+          groupStartIdx = i;
+        }
+      }
+      pushGroupFromColumns(groups, columns, groupStartIdx, columns.length, columns[groupStartIdx].date, "quarter", locale);
+      break;
+    }
+    case "year": {
+      let currentYear = columns[0].date.year;
+      let groupStartIdx = 0;
+      for (let i = 0; i < columns.length; i++) {
+        if (columns[i].date.year !== currentYear) {
+          pushGroupFromColumns(groups, columns, groupStartIdx, i, columns[groupStartIdx].date, "year", locale);
+          currentYear = columns[i].date.year;
+          groupStartIdx = i;
+        }
+      }
+      pushGroupFromColumns(groups, columns, groupStartIdx, columns.length, columns[groupStartIdx].date, "year", locale);
+      break;
+    }
+  }
+  return groups;
+}
+function pushGroupFromColumns(groups, columns, startIdx, endIdx, date, zoomLevel, locale) {
+  const span = endIdx - startIdx;
+  if (span <= 0) return;
+  const leftPx = columns[startIdx].leftPx;
+  const widthPx = columns[endIdx - 1].leftPx + columns[endIdx - 1].widthPx - leftPx;
+  groups.push({
+    label: formatGroupLabel(date, zoomLevel, locale),
+    span,
+    leftPx,
+    widthPx
+  });
+}
+function getMonthForWeekColumn(weekStartDate) {
+  const thursday = weekStartDate.add({ days: 3 });
+  return { year: thursday.year, month: thursday.month };
+}
+function formatGroupLabel(date, zoomLevel, locale) {
+  const jsDate = new Date(date.year, date.month - 1, date.day);
+  switch (zoomLevel) {
+    case "day":
+      return new Intl.DateTimeFormat(locale, { weekday: "short", month: "short", day: "numeric" }).format(jsDate);
+    case "week":
+      return `W${getWeekNumber(date)} \u2013 ${new Intl.DateTimeFormat(locale, { month: "short", year: "numeric" }).format(jsDate)}`;
+    case "month":
+    case "quarter":
+      return new Intl.DateTimeFormat(locale, { month: "long", year: "numeric" }).format(jsDate);
+    case "year":
+      return String(date.year);
+  }
+}
+export function buildTaskTree(tasks) {
+  const taskIds = new Set(tasks.map((t) => t.id));
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const key = task.parentId != null && taskIds.has(task.parentId) ? task.parentId : null;
+    if (task.parentId != null && !taskIds.has(task.parentId)) {
+      console.warn(`[GanttChart] Task "${task.id}" references unknown parentId "${task.parentId}" \u2014 promoted to root.`);
+    }
+    const list = childrenMap.get(key);
+    if (list) list.push(task);
+    else childrenMap.set(key, [task]);
+  }
+  function build(task, depth) {
+    const children = (childrenMap.get(task.id) ?? []).map((child) => build(child, depth + 1));
+    return { task: { ...task }, children, depth };
+  }
+  const roots = childrenMap.get(null) ?? [];
+  return roots.map((root) => build(root, 0));
+}
+export function flattenVisibleTasks(tree, expandedIds) {
+  const result = [];
+  function walk(nodes) {
+    for (const node of nodes) {
+      const isGroup = node.children.length > 0;
+      const isExpanded = isGroup && expandedIds.has(node.task.id);
+      result.push({
+        task: node.task,
+        depth: node.depth,
+        isGroup,
+        isExpanded,
+        childCount: node.children.length
+      });
+      if (isExpanded) {
+        walk(node.children);
+      }
+    }
+  }
+  walk(tree);
+  return result;
+}
+export function computeGroupSpans(tree) {
+  function walk(node) {
+    if (node.children.length === 0) {
+      return { start: node.task.start, end: node.task.end };
+    }
+    let minStart = node.task.start;
+    let maxEnd = node.task.end;
+    for (const child of node.children) {
+      const span = walk(child);
+      if (span.start.compare(minStart) < 0) minStart = span.start;
+      if (span.end.compare(maxEnd) > 0) maxEnd = span.end;
+    }
+    node.task.start = minStart;
+    node.task.end = maxEnd;
+    return { start: minStart, end: maxEnd };
+  }
+  for (const root of tree) {
+    walk(root);
+  }
+}
+export function getAllGroupIds(tree) {
+  const ids = /* @__PURE__ */ new Set();
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (node.children.length > 0) {
+        ids.add(node.task.id);
+        walk(node.children);
+      }
+    }
+  }
+  walk(tree);
+  return ids;
+}
+export function computeDependencyPaths(bars, dependencies, rowHeight) {
+  const barMap = /* @__PURE__ */ new Map();
+  for (const bar of bars) {
+    barMap.set(bar.task.id, bar);
+  }
+  const paths = [];
+  for (const dep of dependencies) {
+    const from = barMap.get(dep.fromId);
+    const to = barMap.get(dep.toId);
+    if (!from || !to) continue;
+    const result = buildDependencyPath(from, to, rowHeight);
+    paths.push({ dependency: dep, path: result.path, from, to, fromPoint: result.fromPoint, toPoint: result.toPoint });
+  }
+  return paths;
+}
+export function buildDependencyPath(from, to, rowHeight) {
+  const stubLength = 20;
+  const r = 4;
+  const depthIndent = 16;
+  const fromOffset = from.isGroup ? 0 : from.depth * depthIndent;
+  const toOffset = to.isGroup ? 0 : to.depth * depthIndent;
+  const fromX = from.leftPx + fromOffset + from.widthPx;
+  const fromY = from.rowIndex * rowHeight + rowHeight / 2;
+  const toX = to.leftPx + toOffset;
+  const toY = to.rowIndex * rowHeight + rowHeight / 2;
+  const fromPoint = { x: fromX, y: fromY };
+  const toPoint = { x: toX, y: toY };
+  const endX = toX;
+  if (fromY === toY) {
+    if (endX > fromX + stubLength) {
+      return { path: `M ${fromX} ${fromY} L ${endX} ${toY}`, fromPoint, toPoint };
+    }
+    const midY2 = fromY - rowHeight * 0.6;
+    const midX2 = fromX + stubLength;
+    const approachX2 = endX - stubLength;
+    return {
+      path: [
+        `M ${fromX} ${fromY}`,
+        `L ${midX2 - r} ${fromY}`,
+        `Q ${midX2} ${fromY}, ${midX2} ${fromY - r}`,
+        `L ${midX2} ${midY2 + r}`,
+        `Q ${midX2} ${midY2}, ${midX2 - r} ${midY2}`,
+        `L ${approachX2 + r} ${midY2}`,
+        `Q ${approachX2} ${midY2}, ${approachX2} ${midY2 + r}`,
+        `L ${approachX2} ${toY - r}`,
+        `Q ${approachX2} ${toY}, ${approachX2 + r} ${toY}`,
+        `L ${endX} ${toY}`
+      ].join(" "),
+      fromPoint,
+      toPoint
+    };
+  }
+  if (endX > fromX + stubLength * 2) {
+    const midX2 = fromX + stubLength;
+    return {
+      path: [
+        `M ${fromX} ${fromY}`,
+        `L ${midX2 - r} ${fromY}`,
+        `Q ${midX2} ${fromY}, ${midX2} ${fromY + (toY > fromY ? r : -r)}`,
+        `L ${midX2} ${toY - (toY > fromY ? r : -r)}`,
+        `Q ${midX2} ${toY}, ${midX2 + r} ${toY}`,
+        `L ${endX} ${toY}`
+      ].join(" "),
+      fromPoint,
+      toPoint
+    };
+  }
+  const midX = fromX + stubLength;
+  const approachX = endX - stubLength;
+  const goingDown = toY > fromY;
+  const midY = goingDown ? Math.min(fromY + rowHeight / 2, toY - rowHeight / 2) : Math.max(fromY - rowHeight / 2, toY + rowHeight / 2);
+  return {
+    path: [
+      `M ${fromX} ${fromY}`,
+      `L ${midX - r} ${fromY}`,
+      `Q ${midX} ${fromY}, ${midX} ${fromY + (goingDown ? r : -r)}`,
+      `L ${midX} ${midY - (goingDown ? r : -r)}`,
+      `Q ${midX} ${midY}, ${midX - r} ${midY}`,
+      `L ${approachX + r} ${midY}`,
+      `Q ${approachX} ${midY}, ${approachX} ${midY + (goingDown ? r : -r)}`,
+      `L ${approachX} ${toY - (goingDown ? r : -r)}`,
+      `Q ${approachX} ${toY}, ${approachX + r} ${toY}`,
+      `L ${endX} ${toY}`
+    ].join(" "),
+    fromPoint,
+    toPoint
+  };
+}
+export function computeGanttLayout(tasks, dependencies, expandedIds, zoomLevel, unitWidth, rowHeight, locale) {
+  const tree = buildTaskTree(tasks);
+  computeGroupSpans(tree);
+  const visible = flattenVisibleTasks(tree, expandedIds);
+  const bounds = computeTimelineBounds(tasks, zoomLevel);
+  const timelineStart = bounds.start;
+  const timelineEnd = bounds.end;
+  const columns = generateColumns(timelineStart, timelineEnd, zoomLevel, unitWidth, locale);
+  const headerGroups = generateHeaderGroups(columns, zoomLevel, locale);
+  const totalWidth = columns.length > 0 ? columns[columns.length - 1].leftPx + columns[columns.length - 1].widthPx : 0;
+  const taskBars = visible.map((item, index) => {
+    const { task, depth, isGroup, isExpanded, childCount } = item;
+    const isMilestone = task.milestone;
+    const leftPx = dateToPixel(task.start, timelineStart, zoomLevel, unitWidth);
+    const endPx = dateToPixel(task.end.add({ days: 1 }), timelineStart, zoomLevel, unitWidth);
+    const widthPx = isMilestone ? 0 : Math.max(endPx - leftPx, unitWidth / 2);
+    return {
+      task,
+      rowIndex: index,
+      depth,
+      isGroup,
+      isExpanded,
+      childCount,
+      leftPx,
+      widthPx,
+      isMilestone
+    };
+  });
+  const dependencyPaths = computeDependencyPaths(taskBars, dependencies, rowHeight);
+  const todayDate = today(getLocalTimeZone());
+  let todayOffsetPx = null;
+  if (todayDate.compare(timelineStart) >= 0 && todayDate.compare(timelineEnd) <= 0) {
+    todayOffsetPx = dateToPixel(todayDate, timelineStart, zoomLevel, unitWidth);
+  }
+  const totalHeight = visible.length * rowHeight;
+  return {
+    taskBars,
+    dependencyPaths,
+    columns,
+    headerGroups,
+    totalWidth,
+    totalHeight,
+    todayOffsetPx
+  };
+}

package/dist/runtime/utils/recurrence.js

@@ -5,7 +5,8 @@ import {
   add,
   subtract
 } from "#std/date";
-import { hasTimeComponent, startOfWeekByDay } from "./event-calendar.js";
+import { hasTimeComponent } from "./event-calendar.js";
+import { startOfWeekByDay } from "./date.js";
 export function getVisibleRange(displayDate, view, weekStartsOn, fixedWeeks) {
   if (view === "month") {
     const monthStart = startOf(displayDate, "month");