@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-Z72XRXD4.js

@@ -0,0 +1,787 @@
+import {
+  addGanttDuration,
+  buildHolidaySet,
+  parseGanttDate
+} from "./chunk-USZW2HHU.js";
+import {
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  makeDgmoError
+} from "./chunk-CXK4DZH3.js";
+
+// src/gantt/resolver.ts
+function isResolverError(r) {
+  return "kind" in r;
+}
+function collectTasks(nodes) {
+  const tasks = [];
+  function walk(children) {
+    for (const node of children) {
+      if (node.kind === "task") {
+        tasks.push(node);
+      } else if (node.kind === "group" || node.kind === "parallel") {
+        walk(node.children);
+      }
+    }
+  }
+  walk(nodes);
+  return tasks;
+}
+var BRACKET_GROUP_RE = /^\[(.+?)\]\.(.+)$/;
+function ambiguousTaskMessage(trimmed, suggestions) {
+  return `Multiple tasks match "${trimmed}". Did you mean ${suggestions.map((s) => `\`${s}\``).join(" or ")}?`;
+}
+function resolveTaskName(name, allTasks) {
+  let trimmed = name.trim();
+  const bracketMatch = trimmed.match(BRACKET_GROUP_RE);
+  if (bracketMatch) {
+    trimmed = `${bracketMatch[1]}.${bracketMatch[2]}`;
+  }
+  const normTrimmed = normalizeName(trimmed);
+  const exactMatches = allTasks.filter(
+    (t) => normalizeName(t.label) === normTrimmed
+  );
+  if (exactMatches.length === 1) {
+    return { task: exactMatches[0] };
+  }
+  if (exactMatches.length > 1) {
+    const suggestions = exactMatches.map(
+      (t) => t.groupPath.length > 0 ? `${t.groupPath.join(".")}.${t.label}` : t.label
+    );
+    return {
+      kind: "ambiguous",
+      message: ambiguousTaskMessage(trimmed, suggestions)
+    };
+  }
+  const lastDotIdx = trimmed.lastIndexOf(".");
+  if (lastDotIdx > 0) {
+    const groupPrefix = trimmed.substring(0, lastDotIdx);
+    const taskLabel = trimmed.substring(lastDotIdx + 1);
+    const normTaskLabel = normalizeName(taskLabel);
+    const matches = allTasks.filter((t) => {
+      if (normalizeName(t.label) !== normTaskLabel) return false;
+      return matchesGroupPath(t.groupPath, groupPrefix);
+    });
+    if (matches.length === 1) {
+      return { task: matches[0] };
+    }
+    if (matches.length > 1) {
+      const suggestions = matches.map(
+        (t) => t.groupPath.length > 0 ? `${t.groupPath.join(".")}.${t.label}` : t.label
+      );
+      return {
+        kind: "ambiguous",
+        message: ambiguousTaskMessage(trimmed, suggestions)
+      };
+    }
+  }
+  return {
+    kind: "not_found",
+    message: `No task found with name "${trimmed}".`
+  };
+}
+function matchesGroupPath(groupPath, prefix) {
+  const normPrefix = normalizeName(prefix);
+  if (!prefix.includes(".")) {
+    return groupPath.some((g) => normalizeName(g) === normPrefix);
+  }
+  const pathStr = groupPath.map((g) => normalizeName(g)).join(".");
+  return pathStr === normPrefix || pathStr.endsWith("." + normPrefix) || pathStr.startsWith(normPrefix + ".") || pathStr.includes("." + normPrefix + ".");
+}
+
+// src/gantt/calculator.ts
+function calculateSchedule(parsed) {
+  const diagnostics = [...parsed.diagnostics];
+  const result = {
+    tasks: [],
+    groups: [],
+    startDate: /* @__PURE__ */ new Date(),
+    endDate: /* @__PURE__ */ new Date(),
+    holidays: parsed.holidays,
+    tagGroups: parsed.tagGroups.slice(),
+    eras: [],
+    markers: [],
+    sprints: [],
+    options: parsed.options,
+    diagnostics,
+    error: parsed.error
+  };
+  if (parsed.error) return result;
+  const warn = (line, message) => {
+    diagnostics.push(makeDgmoError(line, message, "warning"));
+  };
+  const holidaySet = buildHolidaySet(parsed.holidays);
+  let projectStart;
+  if (parsed.options.start) {
+    projectStart = parseGanttDate(parsed.options.start);
+  } else {
+    projectStart = new Date(2e3, 0, 1);
+  }
+  result.eras = parsed.eras.map((era) => {
+    if (era.offsetStart && era.offsetEnd) {
+      const start = addGanttDuration(
+        projectStart,
+        era.offsetStart.duration,
+        parsed.holidays,
+        /* @__PURE__ */ new Set(),
+        era.offsetStart.direction
+      );
+      const end = addGanttDuration(
+        projectStart,
+        era.offsetEnd.duration,
+        parsed.holidays,
+        /* @__PURE__ */ new Set(),
+        era.offsetEnd.direction
+      );
+      return { ...era, startDate: formatDate(start), endDate: formatDate(end) };
+    }
+    return era;
+  });
+  result.markers = parsed.markers.map((m) => {
+    if (m.offsetDate) {
+      const d = addGanttDuration(
+        projectStart,
+        m.offsetDate.duration,
+        parsed.holidays,
+        /* @__PURE__ */ new Set(),
+        m.offsetDate.direction
+      );
+      return { ...m, date: formatDate(d) };
+    }
+    return m;
+  });
+  const sprintOpts = parsed.options.sprintLength ? { sprintLength: parsed.options.sprintLength } : void 0;
+  const depOffsetMap = /* @__PURE__ */ new Map();
+  const allTasks = collectTasks(parsed.nodes);
+  if (allTasks.length === 0) {
+    return result;
+  }
+  const taskMap = /* @__PURE__ */ new Map();
+  for (const task of allTasks) {
+    taskMap.set(task.id, {
+      task,
+      predecessors: [],
+      startDate: null,
+      endDate: null
+    });
+  }
+  if (parsed.syntaxMode === "legacy") {
+    buildImplicitDeps(parsed.nodes, taskMap);
+  }
+  for (const task of allTasks) {
+    for (const dep of task.dependencies) {
+      const resolved = resolveTaskName(dep.targetName, allTasks);
+      if (isResolverError(resolved)) {
+        warn(dep.lineNumber, `\`-> ${dep.targetName}\` \u2014 ${resolved.message}`);
+        continue;
+      }
+      const targetNode = taskMap.get(resolved.task.id);
+      if (targetNode) {
+        if (targetNode.predecessors.includes(task.id)) {
+          warn(
+            dep.lineNumber,
+            parsed.syntaxMode === "new" ? `Redundant dependency: "${dep.targetName}" already follows "${task.label}".` : `Redundant dependency: "${dep.targetName}" already follows "${task.label}" sequentially. Did you mean to wrap groups in \`parallel\`?`
+          );
+        } else {
+          targetNode.predecessors.push(task.id);
+          if (dep.offset) {
+            depOffsetMap.set(`${task.id}->${resolved.task.id}`, dep.offset);
+          }
+        }
+      }
+    }
+  }
+  let sortedIds = topologicalSort(taskMap);
+  if (!sortedIds) {
+    const cycle = findCycle(taskMap);
+    const cycleStr = cycle.map((id) => taskMap.get(id).task.label).join(" \u2192 ");
+    warn(
+      // Cycle is non-empty when topo sort failed; preserves prior crash-on-empty behavior.
+      taskMap.get(cycle[0]).task.lineNumber,
+      `Circular dependency detected: ${cycleStr}. The cycle-creating dependency was dropped.`
+    );
+    breakCycle(cycle, taskMap, depOffsetMap);
+    sortedIds = topologicalSort(taskMap);
+    let safety = 10;
+    while (!sortedIds && safety-- > 0) {
+      const nextCycle = findCycle(taskMap);
+      if (nextCycle.length === 0) break;
+      breakCycle(nextCycle, taskMap, depOffsetMap);
+      sortedIds = topologicalSort(taskMap);
+    }
+    if (!sortedIds) {
+      sortedIds = [...taskMap.keys()];
+    }
+  }
+  for (const taskId of sortedIds) {
+    const node = taskMap.get(taskId);
+    const task = node.task;
+    let start;
+    if (task.explicitStart) {
+      start = parseGanttDate(task.explicitStart);
+    } else if (node.predecessors.length === 0) {
+      start = new Date(projectStart);
+    } else {
+      start = /* @__PURE__ */ new Date(-864e13);
+      for (const predId of node.predecessors) {
+        const predNode = taskMap.get(predId);
+        if (!predNode.endDate) continue;
+        let predEnd = new Date(predNode.endDate);
+        const depOffset = depOffsetMap.get(`${predId}->${taskId}`);
+        if (depOffset) {
+          predEnd = addGanttDuration(
+            predEnd,
+            depOffset.duration,
+            parsed.holidays,
+            holidaySet,
+            depOffset.direction,
+            sprintOpts
+          );
+        }
+        if (predEnd.getTime() > start.getTime()) {
+          start = predEnd;
+        }
+      }
+    }
+    if (parsed.syntaxMode === "new" && task.groupPath.length > 0) {
+      const groupOffset = findGroupOffset(parsed.nodes, task.groupPath);
+      if (groupOffset) {
+        const groupFloor = addGanttDuration(
+          new Date(projectStart),
+          groupOffset.duration,
+          parsed.holidays,
+          holidaySet,
+          groupOffset.direction,
+          sprintOpts
+        );
+        if (groupFloor.getTime() > start.getTime()) {
+          start = groupFloor;
+        }
+      }
+    }
+    if (task.offset) {
+      start = addGanttDuration(
+        start,
+        task.offset.duration,
+        parsed.holidays,
+        holidaySet,
+        task.offset.direction,
+        sprintOpts
+      );
+      if (start.getTime() < projectStart.getTime()) {
+        warn(
+          task.lineNumber,
+          `Negative offset on task '${task.label}' exceeds available range; start clamped to project start.`
+        );
+        start = new Date(projectStart);
+      }
+    } else if (start.getTime() < projectStart.getTime()) {
+      warn(
+        task.lineNumber,
+        `Negative offset on dependency exceeds available range; start of '${task.label}' clamped to project start.`
+      );
+      start = new Date(projectStart);
+    }
+    if (task.explicitStart && node.predecessors.length > 0) {
+      let maxPredEnd = /* @__PURE__ */ new Date(-864e13);
+      for (const predId of node.predecessors) {
+        const predNode = taskMap.get(predId);
+        if (predNode.endDate && predNode.endDate.getTime() > maxPredEnd.getTime()) {
+          maxPredEnd = predNode.endDate;
+        }
+      }
+      if (start.getTime() < maxPredEnd.getTime()) {
+        warn(
+          task.lineNumber,
+          `Explicit date ${task.explicitStart}${task.offset ? " (with offset)" : ""} overlaps with predecessor ending ${formatDate(maxPredEnd)}. Using explicit date.`
+        );
+      }
+    }
+    let end;
+    if (task.duration) {
+      if (task.duration.amount === 0) {
+        end = new Date(start);
+      } else {
+        end = addGanttDuration(
+          start,
+          task.duration,
+          parsed.holidays,
+          holidaySet,
+          1,
+          sprintOpts
+        );
+      }
+    } else {
+      end = new Date(start);
+    }
+    node.startDate = start;
+    node.endDate = end;
+  }
+  const criticalSet = parsed.options.criticalPath ? computeCriticalPath(
+    sortedIds,
+    taskMap,
+    depOffsetMap,
+    parsed.holidays,
+    holidaySet,
+    sprintOpts
+  ) : /* @__PURE__ */ new Set();
+  const uncertainSet = /* @__PURE__ */ new Set();
+  for (const taskId of sortedIds) {
+    const node = taskMap.get(taskId);
+    if (node.task.uncertain) {
+      uncertainSet.add(taskId);
+    } else {
+      for (const predId of node.predecessors) {
+        if (uncertainSet.has(predId)) {
+          uncertainSet.add(taskId);
+          break;
+        }
+      }
+    }
+  }
+  for (const taskId of sortedIds) {
+    const node = taskMap.get(taskId);
+    result.tasks.push({
+      task: node.task,
+      startDate: node.startDate,
+      endDate: node.endDate,
+      isCriticalPath: criticalSet.has(taskId),
+      isUncertain: uncertainSet.has(taskId),
+      isMilestone: node.task.duration?.amount === 0 || !node.task.duration && !node.task.explicitStart,
+      groupPath: node.task.groupPath.slice(),
+      effectiveMetadata: { ...node.task.metadata }
+    });
+  }
+  buildResolvedGroups(parsed.nodes, taskMap, result.groups, 0);
+  if (result.tasks.length > 0) {
+    let minDate = result.tasks[0].startDate;
+    let maxDate = result.tasks[0].endDate;
+    for (const t of result.tasks) {
+      if (t.startDate.getTime() < minDate.getTime()) minDate = t.startDate;
+      if (t.endDate.getTime() > maxDate.getTime()) maxDate = t.endDate;
+    }
+    result.startDate = minDate;
+    result.endDate = maxDate;
+  }
+  if (parsed.options.sprintMode && parsed.options.sprintLength && result.tasks.length > 0) {
+    result.sprints = generateSprintBands(
+      parsed.options,
+      result.startDate,
+      result.endDate,
+      projectStart
+    );
+    if (result.sprints.length > 0) {
+      const lastSprintEnd = result.sprints[result.sprints.length - 1].endDate;
+      if (lastSprintEnd.getTime() > result.endDate.getTime()) {
+        result.endDate = lastSprintEnd;
+      }
+    }
+  }
+  if (parsed.syntaxMode === "legacy") {
+    const topLevelGroups = parsed.nodes.filter((n) => n.kind === "group");
+    if (topLevelGroups.length >= 2) {
+      const names = topLevelGroups.map(
+        (g) => g.name
+      );
+      warn(
+        topLevelGroups[0].lineNumber,
+        `${names.join(" and ")} are sequential. Wrap in \`parallel\` if they should run concurrently.`
+      );
+    }
+  }
+  return result;
+}
+function buildImplicitDeps(nodes, taskMap) {
+  walkChildren(nodes, null);
+  function walkChildren(children, afterTaskId) {
+    let prevTaskId = afterTaskId;
+    for (const node of children) {
+      if (node.kind === "task") {
+        if (prevTaskId) {
+          const taskNode = taskMap.get(node.id);
+          if (taskNode && !taskNode.predecessors.includes(prevTaskId)) {
+            taskNode.predecessors.push(prevTaskId);
+          }
+        }
+        prevTaskId = node.id;
+      } else if (node.kind === "group") {
+        const lastId = walkSequential(node.children, prevTaskId);
+        if (lastId) prevTaskId = lastId;
+      } else if (node.kind === "parallel") {
+        const branchLastIds = [];
+        for (const child of node.children) {
+          if (child.kind === "task") {
+            if (prevTaskId) {
+              const taskNode = taskMap.get(child.id);
+              if (taskNode && !taskNode.predecessors.includes(prevTaskId)) {
+                taskNode.predecessors.push(prevTaskId);
+              }
+            }
+            branchLastIds.push(child.id);
+          } else if (child.kind === "group") {
+            const firstId = findFirstTask(child.children);
+            if (firstId && prevTaskId) {
+              const taskNode = taskMap.get(firstId);
+              if (taskNode && !taskNode.predecessors.includes(prevTaskId)) {
+                taskNode.predecessors.push(prevTaskId);
+              }
+            }
+            walkSequential(child.children, null);
+            const lastId = findLastTask(child.children);
+            if (lastId) branchLastIds.push(lastId);
+          } else if (child.kind === "parallel") {
+            walkChildren([child], prevTaskId);
+            const lastId = findLastTask(child.children);
+            if (lastId) branchLastIds.push(lastId);
+          }
+        }
+        if (branchLastIds.length > 0) {
+          prevTaskId = null;
+          const nextIdx = children.indexOf(node) + 1;
+          if (nextIdx < children.length) {
+            const nextFirstId = findFirstTask([children[nextIdx]]);
+            if (nextFirstId) {
+              const nextNode = taskMap.get(nextFirstId);
+              if (nextNode) {
+                for (const branchId of branchLastIds) {
+                  if (!nextNode.predecessors.includes(branchId)) {
+                    nextNode.predecessors.push(branchId);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  function walkSequential(children, afterTaskId) {
+    let prevTaskId = afterTaskId;
+    for (const node of children) {
+      if (node.kind === "task") {
+        if (prevTaskId) {
+          const taskNode = taskMap.get(node.id);
+          if (taskNode && !taskNode.predecessors.includes(prevTaskId)) {
+            taskNode.predecessors.push(prevTaskId);
+          }
+        }
+        prevTaskId = node.id;
+      } else if (node.kind === "group") {
+        const lastId = walkSequential(node.children, prevTaskId);
+        if (lastId) prevTaskId = lastId;
+      } else if (node.kind === "parallel") {
+        walkChildren([node], prevTaskId);
+        const lastId = findLastTask(node.children);
+        if (lastId) prevTaskId = lastId;
+      }
+    }
+    return prevTaskId;
+  }
+}
+function findFirstTask(nodes) {
+  for (const node of nodes) {
+    if (node.kind === "task") return node.id;
+    if (node.kind === "group" || node.kind === "parallel") {
+      const found = findFirstTask(node.children);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function findLastTask(nodes) {
+  for (let i = nodes.length - 1; i >= 0; i--) {
+    const node = nodes[i];
+    if (node.kind === "task") return node.id;
+    if (node.kind === "group" || node.kind === "parallel") {
+      const found = findLastTask(node.children);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function topologicalSort(taskMap) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const [id, node] of taskMap) {
+    inDegree.set(id, node.predecessors.length);
+    for (const pred of node.predecessors) {
+      const adj = adjacency.get(pred) ?? [];
+      adj.push(id);
+      adjacency.set(pred, adj);
+    }
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const succ of adjacency.get(current) ?? []) {
+      const newDegree = (inDegree.get(succ) ?? 1) - 1;
+      inDegree.set(succ, newDegree);
+      if (newDegree === 0) queue.push(succ);
+    }
+  }
+  return sorted.length === taskMap.size ? sorted : null;
+}
+function findCycle(taskMap) {
+  const visited = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  const parent = /* @__PURE__ */ new Map();
+  for (const id of taskMap.keys()) {
+    if (!visited.has(id)) {
+      const cycle = dfs(id);
+      if (cycle) return cycle;
+    }
+  }
+  return [];
+  function dfs(id) {
+    visited.add(id);
+    onStack.add(id);
+    const successors = [];
+    for (const [otherId, otherNode] of taskMap) {
+      if (otherNode.predecessors.includes(id)) {
+        successors.push(otherId);
+      }
+    }
+    for (const succ of successors) {
+      if (!visited.has(succ)) {
+        parent.set(succ, id);
+        const cycle = dfs(succ);
+        if (cycle) return cycle;
+      } else if (onStack.has(succ)) {
+        const cycle = [succ];
+        let current = id;
+        while (current !== succ) {
+          cycle.push(current);
+          current = parent.get(current);
+        }
+        cycle.push(succ);
+        return cycle.reverse();
+      }
+    }
+    onStack.delete(id);
+    return null;
+  }
+}
+function breakCycle(cycle, taskMap, depOffsetMap) {
+  if (cycle.length < 3) return;
+  const fromId = cycle[cycle.length - 2];
+  const toId = cycle[0];
+  const toNode = taskMap.get(toId);
+  if (toNode) {
+    const idx = toNode.predecessors.indexOf(fromId);
+    if (idx !== -1) {
+      toNode.predecessors.splice(idx, 1);
+      depOffsetMap.delete(`${fromId}->${toId}`);
+    }
+  }
+}
+function computeCriticalPath(sortedIds, taskMap, depOffsetMap, holidays, holidaySet, sprintOpts) {
+  if (sortedIds.length === 0) return /* @__PURE__ */ new Set();
+  const latestEnd = /* @__PURE__ */ new Map();
+  const latestStart = /* @__PURE__ */ new Map();
+  let projectEnd = 0;
+  for (const id of sortedIds) {
+    const node = taskMap.get(id);
+    if (node.endDate && node.endDate.getTime() > projectEnd) {
+      projectEnd = node.endDate.getTime();
+    }
+  }
+  const successors = /* @__PURE__ */ new Map();
+  for (const [id, node] of taskMap) {
+    for (const pred of node.predecessors) {
+      const succs = successors.get(pred) ?? [];
+      succs.push(id);
+      successors.set(pred, succs);
+    }
+  }
+  for (let i = sortedIds.length - 1; i >= 0; i--) {
+    const id = sortedIds[i];
+    const node = taskMap.get(id);
+    const succs = successors.get(id) ?? [];
+    if (succs.length === 0) {
+      latestEnd.set(id, projectEnd);
+    } else {
+      let minVal = Infinity;
+      for (const succId of succs) {
+        let succLS = latestStart.get(succId);
+        if (succLS === void 0) continue;
+        const succTask = taskMap.get(succId).task;
+        if (succTask.offset) {
+          const reverseDir = succTask.offset.direction * -1;
+          const adjusted = addGanttDuration(
+            new Date(succLS),
+            succTask.offset.duration,
+            holidays,
+            holidaySet,
+            reverseDir,
+            sprintOpts
+          );
+          succLS = adjusted.getTime();
+        }
+        const depOffset = depOffsetMap.get(`${id}->${succId}`);
+        if (depOffset) {
+          const reverseDir = depOffset.direction * -1;
+          const adjusted = addGanttDuration(
+            new Date(succLS),
+            depOffset.duration,
+            holidays,
+            holidaySet,
+            reverseDir,
+            sprintOpts
+          );
+          succLS = adjusted.getTime();
+        }
+        if (succLS < minVal) {
+          minVal = succLS;
+        }
+      }
+      latestEnd.set(id, minVal);
+    }
+    const duration = node.endDate.getTime() - node.startDate.getTime();
+    latestStart.set(id, latestEnd.get(id) - duration);
+  }
+  const critical = /* @__PURE__ */ new Set();
+  for (const id of sortedIds) {
+    const node = taskMap.get(id);
+    const slack = (latestStart.get(id) ?? 0) - node.startDate.getTime();
+    if (Math.abs(slack) < 864e5) {
+      critical.add(id);
+    }
+  }
+  return critical;
+}
+function buildResolvedGroups(nodes, taskMap, groups, depth) {
+  for (const node of nodes) {
+    if (node.kind === "group") {
+      const childTasks = collectTasks(node.children);
+      if (childTasks.length === 0) {
+        groups.push({
+          name: node.name,
+          color: node.color,
+          metadata: node.metadata,
+          startDate: /* @__PURE__ */ new Date(),
+          endDate: /* @__PURE__ */ new Date(),
+          progress: null,
+          lineNumber: node.lineNumber,
+          depth,
+          ...node.collapsed && { collapsed: true }
+        });
+        continue;
+      }
+      let minStart = Infinity;
+      let maxEnd = -Infinity;
+      let totalProgress = 0;
+      let totalDuration = 0;
+      let hasProgress = false;
+      for (const task of childTasks) {
+        const resolved = taskMap.get(task.id);
+        if (!resolved?.startDate || !resolved?.endDate) continue;
+        if (resolved.startDate.getTime() < minStart)
+          minStart = resolved.startDate.getTime();
+        if (resolved.endDate.getTime() > maxEnd)
+          maxEnd = resolved.endDate.getTime();
+        const dur = resolved.endDate.getTime() - resolved.startDate.getTime();
+        totalDuration += dur;
+        if (task.progress !== null) {
+          totalProgress += task.progress * dur;
+          hasProgress = true;
+        }
+      }
+      groups.push({
+        name: node.name,
+        color: node.color,
+        metadata: node.metadata,
+        startDate: new Date(minStart === Infinity ? 0 : minStart),
+        endDate: new Date(maxEnd === -Infinity ? 0 : maxEnd),
+        progress: hasProgress && totalDuration > 0 ? totalProgress / totalDuration : null,
+        lineNumber: node.lineNumber,
+        depth,
+        ...node.collapsed && { collapsed: true }
+      });
+      buildResolvedGroups(node.children, taskMap, groups, depth + 1);
+    } else if (node.kind === "parallel") {
+      buildResolvedGroups(node.children, taskMap, groups, depth);
+    }
+  }
+}
+function generateSprintBands(options, chartStart, chartEnd, projectStart) {
+  const sprintLength = options.sprintLength;
+  const sprintNumber = options.sprintNumber ?? 1;
+  let anchorDate;
+  if (options.sprintStart) {
+    anchorDate = /* @__PURE__ */ new Date(options.sprintStart + "T00:00:00");
+  } else if (options.start) {
+    anchorDate = new Date(projectStart);
+  } else {
+    const now = /* @__PURE__ */ new Date();
+    anchorDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  }
+  anchorDate.setHours(0, 0, 0, 0);
+  const sprintDays = Math.round(
+    sprintLength.amount * (sprintLength.unit === "w" ? 7 : 1)
+  );
+  if (sprintDays <= 0) return [];
+  if (Number.isNaN(anchorDate.getTime())) return [];
+  const chartStartTime = new Date(chartStart);
+  chartStartTime.setHours(0, 0, 0, 0);
+  const chartEndTime = new Date(chartEnd);
+  chartEndTime.setHours(0, 0, 0, 0);
+  const msPerDay = 864e5;
+  const dayDiff = Math.floor(
+    (chartStartTime.getTime() - anchorDate.getTime()) / msPerDay
+  );
+  const startSprintIndex = Math.floor(dayDiff / sprintDays);
+  const sprints = [];
+  const maxSprints = 1e3;
+  for (let i = startSprintIndex; sprints.length < maxSprints; i++) {
+    const sprintStartDate = new Date(anchorDate);
+    sprintStartDate.setDate(sprintStartDate.getDate() + i * sprintDays);
+    sprintStartDate.setHours(0, 0, 0, 0);
+    const sprintEndDate = new Date(sprintStartDate);
+    sprintEndDate.setDate(sprintEndDate.getDate() + sprintDays);
+    sprintEndDate.setHours(0, 0, 0, 0);
+    if (sprintStartDate.getTime() >= chartEndTime.getTime() + msPerDay) break;
+    sprints.push({
+      number: sprintNumber + i,
+      startDate: sprintStartDate,
+      endDate: sprintEndDate
+    });
+  }
+  return sprints;
+}
+function formatDate(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function findGroupOffset(nodes, groupPath) {
+  if (groupPath.length === 0) return null;
+  const groupName = groupPath[groupPath.length - 1];
+  function search(children) {
+    for (const node of children) {
+      if (node.kind === "group") {
+        if (node.name === groupName && node.offset) return node.offset;
+        const found = search(node.children);
+        if (found) return found;
+      } else if (node.kind === "parallel") {
+        const found = search(node.children);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  return search(nodes);
+}
+
+export {
+  collectTasks,
+  resolveTaskName,
+  calculateSchedule
+};
+//# sourceMappingURL=chunk-Z72XRXD4.js.map