construction-gantt 0.2.0 → 0.3.0

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/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';