ct-gantt-core 1.0.1

package/src/engines/computeImpact.ts

@@ -0,0 +1,98 @@
+import type { AffectedTasks, GanttConfig, GanttLink, GanttTask, PatchTask, Result } from "../types"
+import { flattenTasks } from "../services/flattenTasks"
+import { scheduleByDependencies, shiftTask } from "./scheduling"
+import { addDays, inclusiveDays, toDate } from "../utils/date"
+
+export function computeImpact(
+  taskId: string,
+  patch: PatchTask,
+  tasks: GanttTask[],
+  links: GanttLink[],
+  config: Partial<GanttConfig>
+): Result<AffectedTasks> {
+  const target = tasks.find((task) => task.id === taskId)
+  if (!target) {
+    return {
+      ok: false,
+      error: {
+        code: "MISSING_TASK",
+        message: `Task ${taskId} does not exist.`
+      }
+    }
+  }
+
+  const patchedTasks = tasks.map((task) => {
+    if (task.id !== taskId) {
+      return task
+    }
+
+    let next = { ...task, actual: { ...task.actual } }
+    if (patch.actualStart) {
+      next = shiftTask(next, patch.actualStart)
+    }
+    if (patch.actualEnd) {
+      next.actual.end = patch.actualEnd
+    }
+    if (typeof patch.progress === "number") {
+      next.actual.progress = patch.progress
+    }
+    if (patch.duration) {
+      next.duration = patch.duration
+      next.actual.end = addDays(toDate(next.actual.start), Math.max(0, patch.duration - 1))
+    }
+    if (patch.name) {
+      next.name = patch.name
+    }
+    if (patch.type) {
+      next.type = patch.type
+    }
+    if ("parentId" in patch) {
+      next.parentId = patch.parentId
+    }
+    if (patch.color) {
+      next.color = patch.color
+    }
+    if ("planColor" in patch) {
+      next.planColor = patch.planColor
+    }
+    if (patch.schedulingMode) {
+      next.schedulingMode = patch.schedulingMode
+    }
+    return next
+  })
+
+  const scheduled = config.autoSchedule === false
+    ? { ok: true as const, data: patchedTasks }
+    : scheduleByDependencies(patchedTasks, links)
+
+  if (!scheduled.ok) {
+    return scheduled
+  }
+
+  const rows = new Map(flattenTasks(scheduled.data).map((flat) => [flat.task.id, flat.rowIndex]))
+  const originalById = new Map(tasks.map((task) => [task.id, task]))
+  const changed = scheduled.data
+    .filter((task) => {
+      const original = originalById.get(task.id)
+      return original && (
+        String(original.actual.start) !== String(task.actual.start) ||
+        String(original.actual.end) !== String(task.actual.end)
+      )
+    })
+    .map((task) => ({
+      taskId: task.id,
+      actualStart: task.actual.start,
+      actualEnd: task.actual.end,
+      rowIndex: rows.get(task.id) ?? 0
+    }))
+
+  const conflicts = scheduled.data
+    .filter((task) => task.constraint?.date && inclusiveDays(task.actual.start, task.constraint.date) < 0)
+    .map((task) => ({
+      taskId: task.id,
+      constraintType: task.constraint!.type,
+      message: "Task violates its configured constraint date."
+    }))
+
+  return { ok: true, data: { changed, conflicts } }
+}

package/src/engines/computeLayout.ts

@@ -0,0 +1,73 @@
+import type { GanttConfig, GanttLink, GanttTask, Result, TaskLayout, Viewport } from "../types"
+import { defaultConfig } from "../types"
+import { flattenTasks } from "../services/flattenTasks"
+import { normalizeLinks } from "../services/normalizeLinks"
+import { scheduleByDependencies } from "./scheduling"
+import { diffDays, inclusiveDays, isValidDate, toDate } from "../utils/date"
+
+export function computeLayout(
+  tasks: GanttTask[],
+  links: GanttLink[],
+  config: Partial<GanttConfig>,
+  collapsedIds: Set<string> = new Set(),
+  viewport?: Viewport
+): Result<TaskLayout[]> {
+  const mergedConfig = { ...defaultConfig, ...config }
+
+  for (const task of tasks) {
+    if (!isValidDate(task.actual.start) || !isValidDate(task.actual.end)) {
+      return {
+        ok: false,
+        error: {
+          code: "INVALID_DATE",
+          message: `Task ${task.id} has invalid actual dates.`
+        }
+      }
+    }
+  }
+
+  const normalizedLinks = normalizeLinks(tasks, links)
+  const scheduled = mergedConfig.autoSchedule === false
+    ? { ok: true as const, data: tasks }
+    : scheduleByDependencies(tasks, normalizedLinks)
+
+  if (!scheduled.ok) {
+    return scheduled
+  }
+
+  const flatTasks = flattenTasks(scheduled.data, collapsedIds)
+  const firstDate = mergedConfig.visibleRange
+    ? toDate(mergedConfig.visibleRange.start)
+    : minDate(scheduled.data.map((task) => toDate(task.actual.start)))
+
+  const visibleStart = viewport
+    ? Math.max(0, Math.floor(viewport.scrollTop / mergedConfig.rowHeight) - 8)
+    : 0
+  const visibleEnd = viewport
+    ? Math.ceil((viewport.scrollTop + viewport.clientHeight) / mergedConfig.rowHeight) + 8
+    : Number.POSITIVE_INFINITY
+
+  const layouts = flatTasks
+    .filter((flat) => flat.rowIndex >= visibleStart && flat.rowIndex <= visibleEnd)
+    .map<TaskLayout>((flat) => {
+      const start = toDate(flat.task.actual.start)
+      const end = toDate(flat.task.actual.end)
+      const duration = flat.task.type === "milestone" ? 0 : inclusiveDays(start, end)
+
+      return {
+        taskId: flat.task.id,
+        rowIndex: flat.rowIndex,
+        left: diffDays(firstDate, start) * mergedConfig.columnWidth,
+        width: Math.max(flat.task.type === "milestone" ? mergedConfig.columnWidth / 2 : mergedConfig.columnWidth, duration * mergedConfig.columnWidth),
+        top: mergedConfig.headerHeight + flat.rowIndex * mergedConfig.rowHeight,
+        depth: flat.depth,
+        isCritical: false
+      }
+    })
+
+  return { ok: true, data: layouts }
+}
+
+function minDate(dates: Date[]): Date {
+  return new Date(Math.min(...dates.map((date) => date.getTime())))
+}

package/src/engines/scheduling.ts

@@ -0,0 +1,155 @@
+import type { GanttLink, GanttTask, LinkType, Result } from "../types"
+import { addDays, diffDays, inclusiveDays, toDate } from "../utils/date"
+import { checkCyclicDependency } from "../services/checkCyclicDependency"
+
+export function scheduleByDependencies(tasks: GanttTask[], links: GanttLink[]): Result<GanttTask[]> {
+  const cycle = checkCyclicDependency(links)
+  if (cycle.hasCycle) {
+    return {
+      ok: false,
+      error: {
+        code: "CYCLE_DEPENDENCY",
+        message: "Dependency graph contains a cycle.",
+        details: cycle.cyclePath
+      }
+    }
+  }
+
+  const taskMap = new Map(tasks.map((task) => [task.id, cloneTask(task)]))
+  const incoming = new Map<string, GanttLink[]>()
+  const outgoing = new Map<string, GanttLink[]>()
+
+  for (const link of links) {
+    const source = taskMap.get(link.sourceId)
+    const target = taskMap.get(link.targetId)
+    if (!source || !target) {
+      return {
+        ok: false,
+        error: {
+          code: "ORPHAN_DEPENDENCY",
+          message: `Dependency ${link.id} references a missing task.`
+        }
+      }
+    }
+    incoming.set(link.targetId, [...(incoming.get(link.targetId) ?? []), link])
+    outgoing.set(link.sourceId, [...(outgoing.get(link.sourceId) ?? []), link])
+  }
+
+  const ordered = topologicalOrder(tasks.map((task) => task.id), links)
+
+  for (const taskId of ordered) {
+    const task = taskMap.get(taskId)
+    if (!task || task.schedulingMode === "manual") {
+      continue
+    }
+
+    const linksToTask = incoming.get(taskId) ?? []
+    let start = toDate(task.actual.start)
+    let end = toDate(task.actual.end)
+    const duration = Math.max(0, task.duration ?? inclusiveDays(start, end))
+
+    for (const link of linksToTask) {
+      const source = taskMap.get(link.sourceId)
+      if (!source) {
+        continue
+      }
+
+      const candidate = applyDependency(source, start, end, duration, link.type, link.lag ?? 0)
+      if (candidate.start.getTime() > start.getTime()) {
+        start = candidate.start
+      }
+      if (candidate.end.getTime() > end.getTime()) {
+        end = candidate.end
+      }
+    }
+
+    const normalizedEnd = task.type === "milestone" ? start : addDays(start, Math.max(0, duration - 1))
+    task.actual = {
+      ...task.actual,
+      start,
+      end: normalizedEnd
+    }
+  }
+
+  return { ok: true, data: tasks.map((task) => taskMap.get(task.id) ?? task) }
+}
+
+function applyDependency(
+  source: GanttTask,
+  currentStart: Date,
+  currentEnd: Date,
+  duration: number,
+  type: LinkType,
+  lag: number
+): { start: Date; end: Date } {
+  const sourceStart = toDate(source.actual.start)
+  const sourceEnd = toDate(source.actual.end)
+  const span = Math.max(0, duration - 1)
+
+  if (type === "FS") {
+    const start = addDays(sourceEnd, lag + 1)
+    return { start, end: addDays(start, span) }
+  }
+
+  if (type === "SS") {
+    const start = addDays(sourceStart, lag)
+    return { start, end: addDays(start, span) }
+  }
+
+  if (type === "FF") {
+    const end = addDays(sourceEnd, lag)
+    return { start: addDays(end, -span), end }
+  }
+
+  const end = addDays(sourceStart, lag)
+  return { start: addDays(end, -span), end: end.getTime() > currentEnd.getTime() ? end : currentEnd }
+}
+
+function topologicalOrder(ids: string[], links: GanttLink[]): string[] {
+  const indegree = new Map(ids.map((id) => [id, 0]))
+  const outgoing = new Map<string, string[]>()
+
+  for (const link of links) {
+    indegree.set(link.targetId, (indegree.get(link.targetId) ?? 0) + 1)
+    outgoing.set(link.sourceId, [...(outgoing.get(link.sourceId) ?? []), link.targetId])
+  }
+
+  const queue = ids.filter((id) => (indegree.get(id) ?? 0) === 0)
+  const ordered: string[] = []
+
+  while (queue.length) {
+    const current = queue.shift()!
+    ordered.push(current)
+    for (const target of outgoing.get(current) ?? []) {
+      indegree.set(target, (indegree.get(target) ?? 1) - 1)
+      if (indegree.get(target) === 0) {
+        queue.push(target)
+      }
+    }
+  }
+
+  return ordered.length === ids.length ? ordered : ids
+}
+
+function cloneTask(task: GanttTask): GanttTask {
+  return {
+    ...task,
+    plan: { ...task.plan },
+    actual: { ...task.actual },
+    dependencies: task.dependencies?.map((dependency) => ({ ...dependency }))
+  }
+}
+
+export function shiftTask(task: GanttTask, start: string | Date): GanttTask {
+  const currentStart = toDate(task.actual.start)
+  const nextStart = toDate(start)
+  const delta = diffDays(currentStart, nextStart)
+  return {
+    ...task,
+    actual: {
+      ...task.actual,
+      start: nextStart,
+      end: addDays(toDate(task.actual.end), delta)
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./types"
+export * from "./services/checkCyclicDependency"
+export * from "./services/normalizeLinks"
+export * from "./services/flattenTasks"
+export * from "./services/computeTimeScale"
+export * from "./engines/computeLayout"
+export * from "./engines/computeImpact"
+export * from "./engines/scheduling"
+export * from "./utils/date"

package/src/services/checkCyclicDependency.ts

@@ -0,0 +1,54 @@
+import type { GanttLink } from "../types"
+
+export function checkCyclicDependency(
+  links: GanttLink[]
+): { hasCycle: boolean; cyclePath?: string[] } {
+  const graph = new Map<string, string[]>()
+
+  for (const link of links) {
+    const targets = graph.get(link.sourceId) ?? []
+    targets.push(link.targetId)
+    graph.set(link.sourceId, targets)
+    if (!graph.has(link.targetId)) {
+      graph.set(link.targetId, [])
+    }
+  }
+
+  const visiting = new Set<string>()
+  const visited = new Set<string>()
+  const path: string[] = []
+
+  const dfs = (node: string): string[] | undefined => {
+    if (visiting.has(node)) {
+      const start = path.indexOf(node)
+      return [...path.slice(start), node]
+    }
+    if (visited.has(node)) {
+      return undefined
+    }
+
+    visiting.add(node)
+    path.push(node)
+
+    for (const next of graph.get(node) ?? []) {
+      const cycle = dfs(next)
+      if (cycle) {
+        return cycle
+      }
+    }
+
+    path.pop()
+    visiting.delete(node)
+    visited.add(node)
+    return undefined
+  }
+
+  for (const node of graph.keys()) {
+    const cyclePath = dfs(node)
+    if (cyclePath) {
+      return { hasCycle: true, cyclePath }
+    }
+  }
+
+  return { hasCycle: false }
+}

package/src/services/computeTimeScale.ts

@@ -0,0 +1,71 @@
+import type { TimeScale, ViewMode } from "../types"
+import { addDays, diffDays, startOfDay } from "../utils/date"
+
+export function computeTimeScale(
+  start: Date,
+  end: Date,
+  viewMode: ViewMode,
+  columnWidth: number,
+  firstDayOfWeek: 0 | 1
+): TimeScale[] {
+  const rangeStart = alignStart(start, viewMode, firstDayOfWeek)
+  const endDate = startOfDay(end)
+  const rangeEnd = viewMode === "day"
+    ? addDays(endDate, (firstDayOfWeek + 6 - endDate.getDay() + 7) % 7)
+    : endDate
+  const scale: TimeScale[] = []
+  let cursor = rangeStart
+  let left = 0
+
+  while (cursor.getTime() <= rangeEnd.getTime()) {
+    const next = nextUnit(cursor, viewMode)
+    const unitEnd = addDays(next, -1)
+    const width = Math.max(1, diffDays(cursor, next)) * columnWidth
+
+    scale.push({
+      start: cursor,
+      end: unitEnd,
+      left,
+      width
+    })
+
+    left += width
+    cursor = next
+  }
+
+  return scale
+}
+
+function alignStart(date: Date, viewMode: ViewMode, firstDayOfWeek: 0 | 1): Date {
+  const start = startOfDay(date)
+  if (viewMode === "day" || viewMode === "week") {
+    const delta = (start.getDay() - firstDayOfWeek + 7) % 7
+    return addDays(start, -delta)
+  }
+  if (viewMode === "month") {
+    return new Date(start.getFullYear(), start.getMonth(), 1)
+  }
+  if (viewMode === "quarter") {
+    return new Date(start.getFullYear(), Math.floor(start.getMonth() / 3) * 3, 1)
+  }
+  if (viewMode === "year") {
+    return new Date(start.getFullYear(), 0, 1)
+  }
+  return start
+}
+
+function nextUnit(date: Date, viewMode: ViewMode): Date {
+  if (viewMode === "week") {
+    return addDays(date, 7)
+  }
+  if (viewMode === "month") {
+    return new Date(date.getFullYear(), date.getMonth() + 1, 1)
+  }
+  if (viewMode === "quarter") {
+    return new Date(date.getFullYear(), date.getMonth() + 3, 1)
+  }
+  if (viewMode === "year") {
+    return new Date(date.getFullYear() + 1, 0, 1)
+  }
+  return addDays(date, 1)
+}

package/src/services/flattenTasks.ts

@@ -0,0 +1,38 @@
+import type { FlatTask, GanttTask } from "../types"
+
+export function flattenTasks(tasks: GanttTask[], collapsedIds: Set<string> = new Set()): FlatTask[] {
+  const children = new Map<string | null, GanttTask[]>()
+
+  for (const task of tasks) {
+    const parentId = task.parentId ?? null
+    const bucket = children.get(parentId) ?? []
+    bucket.push(task)
+    children.set(parentId, bucket)
+  }
+
+  const flattened: FlatTask[] = []
+  const visit = (task: GanttTask, depth: number) => {
+    const childTasks = children.get(task.id) ?? []
+    const collapsed = collapsedIds.has(task.id)
+
+    flattened.push({
+      task,
+      depth,
+      rowIndex: flattened.length,
+      hasChildren: childTasks.length > 0,
+      collapsed
+    })
+
+    if (!collapsed) {
+      for (const child of childTasks) {
+        visit(child, depth + 1)
+      }
+    }
+  }
+
+  for (const root of children.get(null) ?? []) {
+    visit(root, 0)
+  }
+
+  return flattened
+}

package/src/services/normalizeLinks.ts

@@ -0,0 +1,69 @@
+import type { GanttLink, GanttTask } from "../types"
+
+export function normalizeLinks(tasks: GanttTask[], standaloneLinks: GanttLink[] = []): GanttLink[] {
+  const taskIds = new Set(tasks.map((task) => task.id))
+  const byTaskPair = new Map<string, GanttLink>()
+  const outgoing = new Map<string, Set<string>>()
+
+  const createsCycle = (sourceId: string, targetId: string): boolean => {
+    const pending = [targetId]
+    const visited = new Set<string>()
+    while (pending.length > 0) {
+      const current = pending.pop()!
+      if (current === sourceId) {
+        return true
+      }
+      if (visited.has(current)) {
+        continue
+      }
+      visited.add(current)
+      pending.push(...(outgoing.get(current) ?? []))
+    }
+    return false
+  }
+
+  const append = (link: GanttLink) => {
+    if (
+      !taskIds.has(link.sourceId)
+      || !taskIds.has(link.targetId)
+      || link.sourceId === link.targetId
+    ) {
+      return
+    }
+
+    const normalized: GanttLink = {
+      ...link,
+      id: link.id || `link-${link.sourceId}-${link.targetId}`,
+      lag: link.lag ?? 0,
+      lagUnit: link.lagUnit ?? "calendar"
+    }
+    const pairKey = `${normalized.sourceId}|${normalized.targetId}`
+    if (byTaskPair.has(pairKey) || createsCycle(normalized.sourceId, normalized.targetId)) {
+      return
+    }
+
+    byTaskPair.set(pairKey, normalized)
+    const targets = outgoing.get(normalized.sourceId) ?? new Set<string>()
+    targets.add(normalized.targetId)
+    outgoing.set(normalized.sourceId, targets)
+  }
+
+  for (const task of tasks) {
+    for (const dependency of task.dependencies ?? []) {
+      append({
+        id: dependency.id || `link-${dependency.predecessorId}-${task.id}`,
+        sourceId: dependency.predecessorId,
+        targetId: task.id,
+        type: dependency.type,
+        lag: dependency.lag,
+        lagUnit: dependency.lagUnit
+      })
+    }
+  }
+
+  for (const link of standaloneLinks) {
+    append(link)
+  }
+
+  return [...byTaskPair.values()]
+}