ct-gantt-core 1.0.1

package/src/types/index.ts

@@ -0,0 +1,241 @@
+export type ViewMode = "day" | "week" | "month" | "quarter" | "year"
+
+export type LinkType = "FS" | "SS" | "FF" | "SF"
+export type LagUnit = "calendar" | "working"
+
+export type Result<T> =
+  | { ok: true; data: T }
+  | { ok: false; error: GanttError }
+
+export interface GanttError {
+  code:
+    | "CYCLE_DEPENDENCY"
+    | "INVALID_DATE"
+    | "MISSING_TASK"
+    | "ORPHAN_DEPENDENCY"
+    | "INVALID_DEPENDENCY"
+  message: string
+  details?: unknown
+}
+
+export interface DateRange {
+  start: string | Date
+  end: string | Date
+  progress?: number
+}
+
+export interface Dependency {
+  id?: string
+  predecessorId: string
+  type: LinkType
+  lag: number
+  lagUnit: LagUnit
+}
+
+export interface GanttTask {
+  id: string
+  name: string
+  type: "task" | "milestone" | "summary"
+  plan: DateRange
+  actual: Required<DateRange>
+  dependencies?: Dependency[]
+  parentId?: string | null
+  color?: string
+  planColor?: string
+  calendarId?: string
+  resources?: string[]
+  segments?: Array<{ start: string | Date; end: string | Date }>
+  constraint?: {
+    type: "SNET" | "SNLT" | "MSO" | "MFO" | "ASAP" | "ALAP"
+    date?: string | Date
+  }
+  schedulingMode?: "auto" | "manual"
+  duration?: number
+  custom?: Record<string, unknown>
+}
+
+export interface GanttMarker {
+  id: string
+  name: string
+  date: string | Date
+  color?: string
+}
+
+export interface GanttEditorField {
+  key: string
+  label: string
+  visible?: boolean
+  editable?: boolean
+  type?: "text" | "number" | "date" | "select"
+  options?: Array<{ label: string; value: string | number }>
+  placeholder?: string
+}
+
+export interface CustomColumn {
+  key: string
+  label: string
+  width?: number
+  visible?: boolean
+  align?: "left" | "center" | "right"
+  editable?: boolean
+  type?: "text" | "number" | "date" | "select"
+  options?: Array<{ label: string; value: string | number }>
+  placeholder?: string
+  editor?: Omit<GanttEditorField, "key" | "label">
+  formatter?: (value: unknown, task: GanttTask) => string
+  cellClass?: string | ((task: GanttTask) => string)
+  cellStyle?: Record<string, string | number> | ((task: GanttTask) => Record<string, string | number>)
+  render?: (task: GanttTask) => { text: string; className?: string }
+}
+
+export interface GanttConfig {
+  viewMode: ViewMode
+  rowHeight: number
+  columnWidth: number
+  headerHeight: number
+  taskListWidth: number
+  width?: string | number
+  height?: string | number
+  locale: string
+  firstDayOfWeek: 0 | 1
+  dateFormat: string
+  customColumns?: CustomColumn[]
+  columns?: CustomColumn[]
+  editorFields?: GanttEditorField[]
+  columnWidths?: Partial<Record<ViewMode, number>>
+  theme?: "light" | "dark" | string
+  visibleRange?: {
+    start: string | Date
+    end: string | Date
+  }
+  showPlanBar?: boolean
+  showActualBar?: boolean
+  showTimelineWhenEmpty?: boolean
+  builtInTaskEditor?: boolean
+  builtInMarkerEditor?: boolean
+  editablePlan?: boolean
+  editableActual?: boolean
+  enableLinkCreation?: boolean
+  showLinkRejectionNotice?: boolean
+  virtualScroll?: boolean
+  taskColors?: {
+    task?: string
+    summary?: string
+    milestone?: string
+    plan?: string
+    progress?: string
+  }
+  autoSchedule?: boolean
+  editable?: boolean
+}
+
+export interface GanttLink {
+  id: string
+  sourceId: string
+  targetId: string
+  type: LinkType
+  lag?: number
+  lagUnit?: LagUnit
+}
+
+export interface TaskLayout {
+  taskId: string
+  rowIndex: number
+  left: number
+  width: number
+  top: number
+  depth: number
+  isCritical: boolean
+}
+
+export interface FlatTask {
+  task: GanttTask
+  depth: number
+  rowIndex: number
+  hasChildren: boolean
+  collapsed: boolean
+}
+
+export interface Calendar {
+  id: string
+  workingDays: number[]
+  holidays: string[]
+  hours: [number, number][]
+}
+
+export interface TimeScale {
+  start: Date
+  end: Date
+  left: number
+  width: number
+}
+
+export interface Viewport {
+  scrollTop: number
+  scrollLeft: number
+  clientWidth: number
+  clientHeight: number
+  dpr: number
+}
+
+export interface AffectedTasks {
+  changed: Array<{
+    taskId: string
+    actualStart: string | Date
+    actualEnd: string | Date
+    rowIndex: number
+  }>
+  conflicts: Array<{
+    taskId: string
+    constraintType: string
+    message: string
+  }>
+}
+
+export interface PatchTask {
+  planStart?: string | Date
+  planEnd?: string | Date
+  actualStart?: string | Date
+  actualEnd?: string | Date
+  progress?: number
+  name?: string
+  type?: GanttTask["type"]
+  parentId?: string | null
+  color?: string
+  planColor?: string
+  duration?: number
+  schedulingMode?: "auto" | "manual"
+  resources?: string[]
+  calendarId?: string
+  custom?: Record<string, unknown>
+}
+
+export const defaultConfig: GanttConfig = {
+  viewMode: "month",
+  rowHeight: 44,
+  columnWidth: 30,
+  headerHeight: 50,
+  taskListWidth: 280,
+  locale: "zh-CN",
+  firstDayOfWeek: 0,
+  dateFormat: "YYYY-MM-DD",
+  showPlanBar: true,
+  showActualBar: true,
+  showTimelineWhenEmpty: false,
+  builtInTaskEditor: true,
+  builtInMarkerEditor: true,
+  editablePlan: false,
+  editableActual: true,
+  enableLinkCreation: true,
+  showLinkRejectionNotice: true,
+  virtualScroll: true,
+  taskColors: {
+    task: "#2563eb",
+    summary: "#475467",
+    milestone: "#d97706",
+    plan: "#cbd5e1",
+    progress: "#0f766e"
+  },
+  autoSchedule: true,
+  editable: true
+}

package/src/utils/date.ts

@@ -0,0 +1,54 @@
+import type { Result } from "../types"
+
+export const DAY_MS = 24 * 60 * 60 * 1000
+
+export function toDate(value: string | Date): Date {
+  if (value instanceof Date) {
+    return startOfDay(value)
+  }
+
+  const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(value)
+  if (match) {
+    return new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]))
+  }
+
+  return startOfDay(new Date(value))
+}
+
+export function startOfDay(date: Date): Date {
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate())
+}
+
+export function addDays(date: string | Date, days: number): Date {
+  const next = toDate(date)
+  next.setDate(next.getDate() + days)
+  return startOfDay(next)
+}
+
+export function diffDays(start: string | Date, end: string | Date): number {
+  return Math.round((toDate(end).getTime() - toDate(start).getTime()) / DAY_MS)
+}
+
+export function inclusiveDays(start: string | Date, end: string | Date): number {
+  return Math.max(0, diffDays(start, end) + 1)
+}
+
+export function isValidDate(value: string | Date): boolean {
+  const date = value instanceof Date ? value : new Date(value)
+  return !Number.isNaN(date.getTime())
+}
+
+export function formatDate(date: string | Date): string {
+  const value = toDate(date)
+  const year = value.getFullYear()
+  const month = String(value.getMonth() + 1).padStart(2, "0")
+  const day = String(value.getDate()).padStart(2, "0")
+  return `${year}-${month}-${day}`
+}
+
+export function resultInvalidDate<T>(message: string, details?: unknown): Result<T> {
+  return {
+    ok: false,
+    error: { code: "INVALID_DATE", message, details }
+  }
+}

package/tests/core.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest"
+import {
+  checkCyclicDependency,
+  computeImpact,
+  computeLayout,
+  computeTimeScale,
+  flattenTasks,
+  formatDate,
+  normalizeLinks,
+  scheduleByDependencies,
+  type GanttConfig,
+  type GanttTask
+} from "../src"
+
+const baseConfig: Partial<GanttConfig> = {
+  viewMode: "day",
+  rowHeight: 36,
+  columnWidth: 40,
+  headerHeight: 50,
+  taskListWidth: 280,
+  firstDayOfWeek: 1
+}
+
+const tasks: GanttTask[] = [
+  {
+    id: "1",
+    name: "Design",
+    type: "task",
+    plan: { start: "2026-07-01", end: "2026-07-05", progress: 100 },
+    actual: { start: "2026-07-01", end: "2026-07-05", progress: 100 }
+  },
+  {
+    id: "2",
+    name: "Build",
+    type: "task",
+    plan: { start: "2026-07-06", end: "2026-07-12", progress: 50 },
+    actual: { start: "2026-07-06", end: "2026-07-12", progress: 50 },
+    dependencies: [{ predecessorId: "1", type: "FS", lag: 0, lagUnit: "calendar" }]
+  },
+  {
+    id: "3",
+    name: "Test",
+    type: "task",
+    plan: { start: "2026-07-13", end: "2026-07-15", progress: 0 },
+    actual: { start: "2026-07-13", end: "2026-07-15", progress: 0 },
+    dependencies: [{ predecessorId: "2", type: "FS", lag: 0, lagUnit: "calendar" }]
+  }
+]
+
+describe("ct-gantt-core", () => {
+  it("normalizes embedded dependencies and removes duplicates", () => {
+    const links = normalizeLinks(tasks, [
+      { id: "manual-duplicate", sourceId: "1", targetId: "2", type: "SS", lag: 2, lagUnit: "working" }
+    ])
+
+    expect(links).toHaveLength(2)
+    expect(links[0]).toMatchObject({
+      sourceId: "1",
+      targetId: "2",
+      type: "FS",
+      lag: 0,
+      lagUnit: "calendar"
+    })
+  })
+
+  it("keeps existing dependencies when a later link would create a cycle", () => {
+    const links = normalizeLinks(tasks.map((task) => ({ ...task, dependencies: [] })), [
+      { id: "a", sourceId: "1", targetId: "2", type: "FS" },
+      { id: "b", sourceId: "2", targetId: "3", type: "FS" },
+      { id: "cycle", sourceId: "3", targetId: "1", type: "FS" }
+    ])
+
+    expect(links.map((link) => link.id)).toEqual(["a", "b"])
+  })
+
+  it("detects cycles", () => {
+    const result = checkCyclicDependency([
+      { id: "a", sourceId: "1", targetId: "2", type: "FS" },
+      { id: "b", sourceId: "2", targetId: "1", type: "FS" }
+    ])
+
+    expect(result.hasCycle).toBe(true)
+    expect(result.cyclePath).toContain("1")
+  })
+
+  it("flattens task trees with collapsed summaries", () => {
+    const tree: GanttTask[] = [
+      { ...tasks[0], id: "root", type: "summary" },
+      { ...tasks[1], id: "child", parentId: "root", dependencies: [] }
+    ]
+
+    expect(flattenTasks(tree)).toHaveLength(2)
+    expect(flattenTasks(tree, new Set(["root"]))).toHaveLength(1)
+  })
+
+  it("computes a day scale and Appendix A layout", () => {
+    const scale = computeTimeScale(new Date(2026, 6, 1), new Date(2026, 6, 15), "day", 40, 1)
+    expect(scale).toHaveLength(21)
+    expect(formatDate(scale[0].start)).toBe("2026-06-29")
+    expect(formatDate(scale[20].end)).toBe("2026-07-19")
+
+    const layout = computeLayout(tasks, [], baseConfig)
+    expect(layout.ok).toBe(true)
+    if (layout.ok) {
+      expect(layout.data).toEqual([
+        { taskId: "1", rowIndex: 0, left: 0, width: 200, top: 50, depth: 0, isCritical: false },
+        { taskId: "2", rowIndex: 1, left: 200, width: 280, top: 86, depth: 0, isCritical: false },
+        { taskId: "3", rowIndex: 2, left: 480, width: 120, top: 122, depth: 0, isCritical: false }
+      ])
+    }
+  })
+
+  it("supports FS, SS, FF, and SF scheduling", () => {
+    const scheduled = scheduleByDependencies(
+      [
+        { ...tasks[0], id: "a", actual: { start: "2026-07-01", end: "2026-07-05", progress: 0 } },
+        { ...tasks[1], id: "b", actual: { start: "2026-07-01", end: "2026-07-03", progress: 0 }, dependencies: [] }
+      ],
+      [{ id: "ss", sourceId: "a", targetId: "b", type: "SS", lag: 2, lagUnit: "calendar" }]
+    )
+
+    expect(scheduled.ok).toBe(true)
+    if (scheduled.ok) {
+      expect(scheduled.data.find((task) => task.id === "b")?.actual.start).toEqual(new Date(2026, 6, 3))
+    }
+  })
+
+  it("computes downstream impact after dragging a task", () => {
+    const links = normalizeLinks(tasks)
+    const impact = computeImpact("1", { actualStart: "2026-07-03" }, tasks, links, baseConfig)
+
+    expect(impact.ok).toBe(true)
+    if (impact.ok) {
+      expect(impact.data.changed.map((item) => item.taskId)).toEqual(["1", "2", "3"])
+    }
+  })
+})

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["dist", "tests"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup"
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  target: "es2022"
+})

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["tests/**/*.test.ts"]
+  }
+})