construction-gantt 0.1.0 → 0.3.0

package/src/editing/dragLink.ts

@@ -0,0 +1,47 @@
+import type { Link, TaskId } from '../types.js';
+
+export type DragLinkState =
+  | { status: 'idle' }
+  | {
+      status: 'dragging';
+      sourceId: TaskId;
+      startX: number;
+      startY: number;
+      cursorX: number;
+      cursorY: number;
+    }
+  | { status: 'dropped'; sourceId: TaskId; targetId: TaskId };
+
+export const DRAG_INITIAL: DragLinkState = { status: 'idle' };
+
+export function startDrag(sourceId: TaskId, startX: number, startY: number): DragLinkState {
+  return { status: 'dragging', sourceId, startX, startY, cursorX: startX, cursorY: startY };
+}
+
+export function moveDrag(state: DragLinkState, cursorX: number, cursorY: number): DragLinkState {
+  if (state.status !== 'dragging') return state;
+  return { ...state, cursorX, cursorY };
+}
+
+export function completeDrop(state: DragLinkState, targetId: TaskId | null): DragLinkState {
+  if (state.status !== 'dragging') return DRAG_INITIAL;
+  if (targetId === null) return DRAG_INITIAL;
+  return { status: 'dropped', sourceId: state.sourceId, targetId };
+}
+
+export function cancelDrag(_state: DragLinkState): DragLinkState {
+  return DRAG_INITIAL;
+}
+
+export function isDragInvalid(
+  sourceId: TaskId,
+  targetId: TaskId,
+  existingLinks: Link[],
+  summaryIds: Set<TaskId>,
+): boolean {
+  if (String(sourceId) === String(targetId)) return true;
+  if ([...summaryIds].some((id) => String(id) === String(targetId))) return true;
+  return existingLinks.some(
+    (l) => String(l.source) === String(sourceId) && String(l.target) === String(targetId),
+  );
+}

package/src/editing/useEditState.ts

@@ -0,0 +1,98 @@
+import { useCallback, useRef, useState } from 'react';
+// biome-ignore lint/correctness/noUnusedImports: ScheduleMode is implicitly used in TaskEditPatch return type
+import type { ScheduleMode, Task, TaskId } from '../types.js';
+
+export type EditableField = 'text' | 'start' | 'end' | 'duration' | 'progress' | 'scheduleMode';
+
+export interface ActiveCell {
+  taskId: TaskId;
+  field: EditableField;
+}
+
+export type TaskEditPatch = Partial<
+  Pick<Task, 'text' | 'start' | 'end' | 'duration' | 'progress' | 'scheduleMode'>
+>;
+
+export interface EditState {
+  activeCell: ActiveCell | null;
+  dirtyValue: string;
+  activateCell(taskId: TaskId, field: EditableField, initialValue: string): void;
+  setValue(value: string): void;
+  commitCell(onTaskEdit?: (id: TaskId, patch: TaskEditPatch) => void): void;
+  cancelCell(): void;
+}
+
+export function parseFieldValue(field: EditableField, value: string): TaskEditPatch {
+  switch (field) {
+    case 'text':
+      return { text: value };
+    case 'start': {
+      const d = new Date(`${value}T08:00:00`);
+      if (Number.isNaN(d.getTime())) return {};
+      return { start: d };
+    }
+    case 'end': {
+      const d = new Date(`${value}T08:00:00`);
+      if (Number.isNaN(d.getTime())) return {};
+      return { end: d };
+    }
+    case 'duration': {
+      const n = Number(value);
+      if (!Number.isFinite(n) || n < 0) return {};
+      return { duration: Math.round(n * 8 * 60) };
+    }
+    case 'progress': {
+      const n = Number(value);
+      if (!Number.isFinite(n)) return {};
+      return { progress: Math.min(100, Math.max(0, n)) };
+    }
+    case 'scheduleMode': {
+      if (value !== 'auto' && value !== 'manual') return {};
+      return { scheduleMode: value };
+    }
+  }
+}
+
+interface EditStateInternal {
+  activeCell: ActiveCell | null;
+  dirtyValue: string;
+}
+
+export function useEditState(): EditState {
+  const [state, setState] = useState<EditStateInternal>({
+    activeCell: null,
+    dirtyValue: '',
+  });
+  // stateRef lets commitCell read the latest state without stale closures.
+  const stateRef = useRef(state);
+  stateRef.current = state;
+
+  const activateCell = useCallback((taskId: TaskId, field: EditableField, initialValue: string) => {
+    setState({ activeCell: { taskId, field }, dirtyValue: initialValue });
+  }, []);
+
+  const setValue = useCallback((value: string) => {
+    setState((prev) => ({ ...prev, dirtyValue: value }));
+  }, []);
+
+  const commitCell = useCallback((onTaskEdit?: (id: TaskId, patch: TaskEditPatch) => void) => {
+    const { activeCell, dirtyValue } = stateRef.current;
+    if (activeCell === null) return;
+    const patch = parseFieldValue(activeCell.field, dirtyValue);
+    onTaskEdit?.(activeCell.taskId, patch);
+    setState({ activeCell: null, dirtyValue: '' });
+  }, []);
+
+  const cancelCell = useCallback(() => {
+    setState({ activeCell: null, dirtyValue: '' });
+  }, []);
+
+  return {
+    activeCell: state.activeCell,
+    dirtyValue: state.dirtyValue,
+    activateCell,
+    setValue,
+    commitCell,
+    cancelCell,
+  };
+}

package/src/editing/usePreviewEngine.ts

@@ -0,0 +1,47 @@
+import { useEffect, useRef, useState } from 'react';
+import { schedule } from '../schedule.js';
+import type { Project } from '../types.js';
+import { type ActiveCell, parseFieldValue } from './useEditState.js';
+
+export function usePreviewEngine(
+  committed: Project,
+  activeCell: ActiveCell | null,
+  dirtyValue: string,
+  debounceMs = 80,
+): Project | null {
+  const [ghostProject, setGhostProject] = useState<Project | null>(null);
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(() => {
+    const CPM_IRRELEVANT_FIELDS = new Set(['text', 'progress', 'scheduleMode']);
+    if (activeCell === null || CPM_IRRELEVANT_FIELDS.has(activeCell.field)) {
+      setGhostProject(null);
+      return;
+    }
+
+    if (timerRef.current !== null) clearTimeout(timerRef.current);
+
+    timerRef.current = setTimeout(() => {
+      const patch = parseFieldValue(activeCell.field, dirtyValue);
+      if (Object.keys(patch).length === 0) {
+        setGhostProject(null); // invalid input — suppress ghost
+        return;
+      }
+      const patchedTasks = committed.tasks.map((t) =>
+        t.id === activeCell.taskId ? { ...t, ...patch } : t,
+      );
+      setGhostProject(schedule({ ...committed, tasks: patchedTasks }));
+    }, debounceMs);
+
+    return () => {
+      if (timerRef.current !== null) clearTimeout(timerRef.current);
+    };
+  }, [committed, activeCell, dirtyValue, debounceMs]);
+
+  // Clear immediately when cell deactivates (don't wait for debounce timeout).
+  useEffect(() => {
+    if (activeCell === null) setGhostProject(null);
+  }, [activeCell]);
+
+  return ghostProject;
+}

package/src/export/offscreen.tsx

@@ -14,6 +14,7 @@ export type OffscreenGanttProps = Pick<
   | 'cellHeight'
   | 'markers'
   | 'baselineIndex'
+  | 'baselineIndices'
   | 'showBaselineBars'
   | 'columns'
   | 'height'
@@ -50,6 +51,7 @@ export async function renderOffscreen(args: {
       cellHeight={ganttProps.cellHeight}
       markers={ganttProps.markers}
       baselineIndex={ganttProps.baselineIndex}
+      baselineIndices={ganttProps.baselineIndices}
       showBaselineBars={ganttProps.showBaselineBars}
       columns={ganttProps.columns}
       visibleTaskIds={ganttProps.visibleTaskIds}

package/src/export/pdf.ts

@@ -13,6 +13,7 @@ export async function exportPDF(args: {
     | 'cellHeight'
     | 'markers'
     | 'baselineIndex'
+    | 'baselineIndices'
     | 'showBaselineBars'
     | 'columns'
     | 'height'

package/src/export/png.ts

@@ -12,6 +12,7 @@ export async function exportPNG(args: {
     | 'cellHeight'
     | 'markers'
     | 'baselineIndex'
+    | 'baselineIndices'
     | 'showBaselineBars'
     | 'columns'
     | 'height'

package/src/index.ts

@@ -33,6 +33,7 @@ export {
 } from './editing/factories.js';
 export type { EditableProject } from './editing/use-editable-project.js';
 export { useEditableProject } from './editing/use-editable-project.js';
+export type { EditableField, TaskEditPatch } from './editing/useEditState.js';
 export type {
   GanttHandle,
   PdfExportOptions,

package/src/mspdi/parse.ts

@@ -40,6 +40,7 @@ const KNOWN_TASK_FIELDS = new Set([
   'Finish',
   'Duration',
   'ConstraintType',
+  'ConstraintDate',
   'Milestone',
   'Summary',
   'OutlineLevel',
@@ -238,6 +239,7 @@ export function parseMspdi(xml: string): MspdiParseResult {
 
   const tasks: Task[] = [];
   const links: Link[] = [];
+  const outlineStack: TaskId[] = [];
   // Per-task baseline snapshots, keyed by baseline Number (BaselineIndex).
   // Flattened into project.baselines below.
   const baselineAccum = new Map<BaselineIndex, Map<TaskId, BaselineTaskSnapshot>>();
@@ -263,8 +265,11 @@ export function parseMspdi(xml: string): MspdiParseResult {
     const isMilestone = String(raw.Milestone ?? '0') === '1';
     const isSummary = String(raw.Summary ?? '0') === '1';
     const taskType: TaskType = isSummary ? 'summary' : isMilestone ? 'milestone' : 'task';
+    const outlineLevel = Math.max(1, Number(raw.OutlineLevel ?? '1'));
+    const parentId = outlineLevel > 1 ? outlineStack[outlineLevel - 2] : undefined;
+    const constraint = parseConstraint(raw);
 
-    tasks.push({
+    const parsedTask: Task = {
       id: uid,
       text: name,
       type: taskType,
@@ -272,8 +277,14 @@ export function parseMspdi(xml: string): MspdiParseResult {
       duration,
       start,
       end,
-      progress: 0,
-    });
+      progress: Number(raw.PercentComplete ?? '0'),
+    };
+    if (parentId !== undefined) parsedTask.parent = parentId;
+    if (constraint !== undefined) parsedTask.constraint = constraint;
+    tasks.push(parsedTask);
+
+    outlineStack[outlineLevel - 1] = uid;
+    outlineStack.length = outlineLevel;
 
     // Walk predecessor links nested inside the task.
     const preds: unknown[] = Array.isArray(raw.PredecessorLink)
@@ -705,10 +716,33 @@ const MSPDI_TYPE_TO_DEPENDENCY: Record<number, DependencyType> = {
   3: 'SS',
 };
 
+const MSPDI_CONSTRAINT_TO_INTERNAL = {
+  0: 'ASAP',
+  1: 'ALAP',
+  2: 'MSO',
+  3: 'MFO',
+  4: 'SNET',
+  5: 'SNLT',
+  6: 'FNET',
+  7: 'FNLT',
+} as const;
+
 function mspdiTypeToDependencyType(t: number): DependencyType {
   return MSPDI_TYPE_TO_DEPENDENCY[t] ?? 'FS';
 }
 
+function parseConstraint(raw: Record<string, unknown>): Task['constraint'] {
+  const value = Number(raw.ConstraintType ?? '0');
+  const type = MSPDI_CONSTRAINT_TO_INTERNAL[value as keyof typeof MSPDI_CONSTRAINT_TO_INTERNAL];
+  if (!type || type === 'ASAP') return undefined;
+
+  const constraint: NonNullable<Task['constraint']> = { type };
+  if (raw.ConstraintDate !== undefined && raw.ConstraintDate !== '') {
+    constraint.date = parseMspdiDate(String(raw.ConstraintDate));
+  }
+  return constraint;
+}
+
 function parseMspdiDate(s: string): Date {
   // MSPDI emits ISO 8601 like `2026-01-05T08:00:00` (no timezone in
   // practice; MS Project writes local time). We treat it as local.

package/src/mspdi/serialize.ts

@@ -8,10 +8,12 @@ import type {
   Baseline,
   Calendar,
   CalendarException,
+  ConstraintType,
   DependencyType,
   Link,
   Project,
   Resource,
+  Task,
   WorkInterval,
 } from '../types.js';
 import type { MspdiSerializeOptions } from './types.js';
@@ -37,9 +39,11 @@ interface MspdiTaskOut {
   Finish: string;
   Duration: string;
   ConstraintType: number;
+  ConstraintDate?: string;
   Milestone: number;
   Summary: number;
   OutlineLevel: number;
+  PercentComplete: number;
   PredecessorLink?: MspdiPredecessorLinkOut[];
   Baseline?: MspdiTaskBaselineOut[];
 }
@@ -112,6 +116,7 @@ export function serializeMspdi(project: Project, options: MspdiSerializeOptions
   // Group baselines by taskId. Each task may have one snapshot per baseline
   // (0-10), emitted as <Baseline> children nested inside the task.
   const baselinesByTask = buildBaselinesByTask(project.baselines);
+  const outlineLevelByTask = buildOutlineLevels(project.tasks);
 
   const tasksOut: MspdiTaskOut[] = project.tasks.map((t, idx) => {
     const taskOut: MspdiTaskOut = {
@@ -121,11 +126,15 @@ export function serializeMspdi(project: Project, options: MspdiSerializeOptions
       Start: formatMspdiDate(t.start),
       Finish: formatMspdiDate(t.end),
       Duration: formatMspdiDuration(t.duration),
-      ConstraintType: 0, // ASAP, the MSPDI default
+      ConstraintType: constraintTypeToMspdi(t.constraint?.type),
       Milestone: t.type === 'milestone' ? 1 : 0,
       Summary: t.type === 'summary' ? 1 : 0,
-      OutlineLevel: 1,
+      OutlineLevel: outlineLevelByTask.get(t.id) ?? 1,
+      PercentComplete: t.progress,
     };
+    if (t.constraint?.date) {
+      taskOut.ConstraintDate = formatMspdiDate(t.constraint.date);
+    }
 
     const incoming = linksByTarget.get(String(t.id));
     if (incoming?.length) {
@@ -199,6 +208,45 @@ function dependencyTypeToMspdi(t: DependencyType): number {
   }
 }
 
+function constraintTypeToMspdi(t: ConstraintType | undefined): number {
+  switch (t) {
+    case undefined:
+    case 'ASAP':
+      return 0;
+    case 'ALAP':
+      return 1;
+    case 'MSO':
+      return 2;
+    case 'MFO':
+      return 3;
+    case 'SNET':
+      return 4;
+    case 'SNLT':
+      return 5;
+    case 'FNET':
+      return 6;
+    case 'FNLT':
+      return 7;
+  }
+}
+
+function buildOutlineLevels(tasks: Task[]): Map<Task['id'], number> {
+  const parentById = new Map(tasks.map((t) => [t.id, t.parent]));
+  const cache = new Map<Task['id'], number>();
+
+  function depth(taskId: Task['id']): number {
+    const cached = cache.get(taskId);
+    if (cached !== undefined) return cached;
+
+    const parentId = parentById.get(taskId);
+    const value = parentId === undefined ? 1 : depth(parentId) + 1;
+    cache.set(taskId, value);
+    return value;
+  }
+
+  return new Map(tasks.map((t) => [t.id, depth(t.id)]));
+}
+
 function formatMspdiDate(d: Date): string {
   // MSPDI emits local time without timezone (e.g. `2026-01-05T08:00:00`).
   const pad = (n: number): string => String(n).padStart(2, '0');

package/src/visibility.ts

@@ -5,11 +5,9 @@
 // This is the canonical example: the engine always runs on the full task
 // set; the visibility filter applies only to the rendered output.
 //
-// Direct lift from the CM domain rule (FrappeGanttView.tsx:366-371 in
-// Bode-Builds): "Hiding a predecessor would otherwise make a dependent
-// task's early-start collapse to 0, which is wrong." We honour the rule
-// by structure — the filter sits AFTER schedule() in the pipeline, so
-// computed fields on the visible tasks reflect the full schedule.
+// The filter sits AFTER schedule() in the pipeline so computed fields on
+// the visible tasks reflect the full schedule — hiding a predecessor must
+// not cause a dependent task's early-start to collapse to 0.
 
 import type { Task, TaskId } from './types.js';