트리 헬퍼

import {
  buildTaskTree,
  collectSubtreeIds,
  moveTask,
  rollUpTasks,
  sortTasksBySequence,
  validateMove,
  type GanttMoveOptions,
  type GanttMoveRejection,
  type GanttTaskMove,
  type GanttTaskMoveChange,
  type TaskTree,
} from '@jaeungkim/gantt-chart';

/**
 * parentId로 만든 정규화된 트리
 *
 * 고아(데이터에 없는 부모 id), 자기 참조, 순환 체인은 모두 부모 링크가 끊기고 루트가 돼요.
 * 그래서 나오는 parentOf/childIds는 언제나 비순환이에요. 아래 함수들과 렌더는 무한 루프
 * 걱정 없이 위아래로 걸어 다닐 수 있어요.
 */
export interface TaskTree {
  /** 부모 id -> 자식 id 목록(입력 순서) */
  childIds: Map<string, string[]>;
  /** 작업 id -> 정규화된 부모 id(루트, 고아, 순환이면 null) */
  parentOf: Map<string, string | null>;
  /** 작업 id -> 루트로부터의 깊이 */
  depthOf: Map<string, number>;
  /** 루트 id 목록, 입력 순서 - childIds에 키가 없는 형제 목록이에요 */
  rootIds: string[];
}

export function buildTaskTree(tasks: TaskNode[]): TaskTree

/**
 * 루트 자신을 포함한 하위 트리의 id 목록(너비 우선)
 * 트리에 없는 id는 빈 배열을 돌려줘요
 */
export function collectSubtreeIds(
  tasks: TaskNode[],
  rootId: string,
  tree: TaskTree = buildTaskTree(tasks)
): string[]

collectSubtreeIds(tasks, 'root'); // ['root', 'a', 'b', 'a1', 'a2']
collectSubtreeIds(tasks, 'a');    // ['a', 'a1', 'a2']
collectSubtreeIds(tasks, 'a1');   // ['a1']

/**
 * 모든 부모를 요약 행으로 다시 계산한 작업 목록
 *
 * 시작과 끝은 데이터에 적힌 값이 아니라 언제나 자식에서 나와요
 * (min(자식 start)..max(자식 end)).
 * 깊은 쪽부터 처리해서, 손자의 이동이 부모를 거쳐 조부모까지 올라가요.
 * 명시된 progress는 그대로 두고, 빠진 것만 자식에서 롤업해요.
 */
export function rollUpTasks(
  tasks: Task[],
  tree: TaskTree = buildTaskTree(tasks)
): Task[]

/** 작업을 sequence 계층 순으로 정렬해요 - 행 순서는 오직 여기서 나와요 */
export function sortTasksBySequence<T extends Pick<Task, "sequence">>(
  tasks: T[]
): T[]

export interface GanttTaskMove {
  taskId: string;
  /** 새 부모, 최상위면 null */
  toParentId: string | null;
  /** 새 부모의 자식들 사이의 자리 - 이동 뒤의 목록을 기준으로 세요 */
  toIndex: number;
}

export interface GanttTaskMoveChange extends GanttTaskMove {
  fromParentId: string | null;
  fromIndex: number;
  /** 이제 뒤따르는 형제 - 첫 자식이 되면 null */
  afterId: string | null;
  /** 이제 앞서는 형제 - 마지막 자식이 되면 null */
  beforeId: string | null;
}

export interface GanttMoveOptions {
  hierarchy: boolean;
  canReorder?: (task: Task) => boolean;
}

export type GanttMoveRejection =
  | "unknown-task"
  | "unknown-parent"
  | "read-only"
  | "cycle"
  | "reparent-disabled"
  | "no-op";

/**
 * 이동을 적용할 수 있는지, 없다면 왜 없는지
 */
export function validateMove(
  tasks: Task[],
  move: GanttTaskMove,
  options: GanttMoveOptions
): GanttMoveRejection | null

/**
 * 이동을 적용하고, 그 결과로 나온 행 순서에서 모든 sequence를 다시 매겨요
 */
export function moveTask(
  tasks: Task[],
  move: GanttTaskMove,
  options: GanttMoveOptions
): { tasks: Task[]; change: GanttTaskMoveChange } | null

import {
  buildTaskTree,
  collectSubtreeIds,
  moveTask,
  rollUpTasks,
} from '@jaeungkim/gantt-chart';
import type { Task } from '@jaeungkim/gantt-chart';

const tasks: Task[] = [
  {
    id: 'p', name: 'Phase 1', parentId: null, sequence: '1',
    startDate: '2025-03-01', endDate: '2025-03-02',
  },
  {
    id: 'c1', name: 'Design', parentId: 'p', sequence: '1.1',
    startDate: '2025-01-01', endDate: '2025-01-11', progress: 100,
  },
  {
    id: 'c2', name: 'Build', parentId: 'p', sequence: '1.2',
    startDate: '2025-01-11', endDate: '2025-02-10', progress: 0,
  },
];

const tree = buildTaskTree(tasks);
tree.depthOf.get('c1');              // 1
tree.childIds.get('p');              // ['c1', 'c2']
tree.rootIds;                        // ['p']
collectSubtreeIds(tasks, 'p', tree); // ['p', 'c1', 'c2']

const rolled = rollUpTasks(tasks, tree);
rolled[0].startDate;                 // '2025-01-01T00:00:00.000Z'
rolled[0].endDate;                   // '2025-02-10T00:00:00.000Z'
rolled[0].progress;                  // 25

const moved = moveTask(tasks, { taskId: 'c2', toParentId: null, toIndex: 0 }, {
  hierarchy: true,
});
moved!.tasks.map((t) => `${t.id} ${t.sequence}`); // ['p 2', 'c1 2.1', 'c2 1']
moved!.change.beforeId;                           // 'p' - c2가 그 위로 들어갔어요