@outbuild-company/schedule-core 1.9.1 → 1.9.2

package/dist/index.js

@@ -3287,6 +3287,84 @@ function roundProgressPerLevel(value) {
   return Number(value.toFixed(2));
 }
 
+// src/propagations/upward/progress-rollup.ts
+function recomputeAllProgressRollup(adapter) {
+  for (const parentId of parentsDeepestFirst(adapter)) {
+    rollupParent(parentId, adapter);
+  }
+}
+function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
+  for (const parentId of parentIdsDeepestFirst) {
+    rollupParent(parentId, adapter);
+  }
+}
+function parentsDeepestFirst(adapter) {
+  const parents = /* @__PURE__ */ new Set();
+  adapter.forEachActivity((_activity, id) => {
+    if (adapter.getChildren(id).length > 0) parents.add(id);
+  });
+  const depthById = /* @__PURE__ */ new Map();
+  for (const id of parents) depthById.set(id, depthOf(id, adapter));
+  return [...parents].sort(
+    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
+  );
+}
+function depthOf(id, adapter) {
+  let depth = 0;
+  let current = id;
+  while (current && current !== "0") {
+    if (!adapter.getActivity(current)) break;
+    depth += 1;
+    current = adapter.getParentId(current);
+  }
+  return depth;
+}
+function rollupParent(parentId, adapter) {
+  const childIds = adapter.getChildren(parentId);
+  if (childIds.length === 0) return;
+  const children = [];
+  for (const childId of childIds) {
+    const child = adapter.getActivity(childId);
+    if (!child) continue;
+    children.push({
+      progress: Number(child.progress ?? 0),
+      ponderator: Number(child.ponderator ?? 0)
+    });
+  }
+  applyWeightedProgressRollup(parentId, children, adapter);
+}
+function applyWeightedProgressRollup(parentId, children, adapter) {
+  const parent = adapter.getActivity(parentId);
+  if (!parent) return;
+  const rollup = computeWeightedProgressRollup(children);
+  if (rollup === null) {
+    const fallback = adapter.getProgressFallback(parentId);
+    if (fallback !== null) {
+      adapter.setActivityField(parentId, COLUMN.PROGRESS, fallback);
+    }
+    return;
+  }
+  if (adapter.getProgressFallback(parentId) === null) {
+    adapter.setProgressFallback(parentId, Number(parent.progress ?? 0));
+  }
+  adapter.setActivityField(
+    parentId,
+    COLUMN.PROGRESS,
+    roundProgressPerLevel(rollup)
+  );
+}
+function setExplicitSummaryProgressFallbacks(activityId, progress, adapter) {
+  const pending = [activityId];
+  while (pending.length > 0) {
+    const currentId = pending.pop();
+    if (currentId === void 0) continue;
+    const children = adapter.getChildren(currentId);
+    if (children.length === 0) continue;
+    adapter.setProgressFallback(currentId, progress);
+    pending.push(...children);
+  }
+}
+
 // src/columns/real-work/compute.ts
 function computeLeafRealWork(workHours, progress) {
   return (Number(workHours) || 0) * (Number(progress) || 0) / 100;
@@ -3402,16 +3480,8 @@ function recomputeParentFromChildren(parentId, adapter, progressMode = "freeze-w
   adapter.setActivityField(parentId, "startDate", newStart);
   adapter.setActivityField(parentId, "endDate", newEnd);
   adapter.setActivityField(parentId, "durationHours", durationHours);
-  const progressRollup = computeWeightedProgressRollup(
-    aggregate.weightedChildren
-  );
-  const shouldWriteProgress = progressMode !== "skip" && (progressRollup !== null || progressMode === "zero-when-no-contribution");
-  if (shouldWriteProgress) {
-    adapter.setActivityField(
-      parentId,
-      "progress",
-      roundProgressPerLevel(progressRollup ?? 0)
-    );
+  if (progressMode !== "skip") {
+    applyWeightedProgressRollup(parentId, aggregate.weightedChildren, adapter);
   }
   if (recomputeRealWork) {
     adapter.setActivityField(parentId, "realWorkHours", aggregate.realWorkSum);
@@ -3434,10 +3504,10 @@ function collectParentIds(adapter) {
 }
 function computeDepths(ids, adapter) {
   const depths = /* @__PURE__ */ new Map();
-  for (const id of ids) depths.set(id, depthOf(id, adapter));
+  for (const id of ids) depths.set(id, depthOf2(id, adapter));
   return depths;
 }
-function depthOf(id, adapter) {
+function depthOf2(id, adapter) {
   let depth = 0;
   let current = id;
   while (current && !isRootParent(current)) {
@@ -3920,6 +3990,7 @@ function buildAncestorRollupCascade(activity, newValue, hierarchy) {
   const mutations = [];
   for (const id of chain) {
     const rollup = computeWeightedProgress(id, overlay, hierarchy);
+    if (rollup === null) continue;
     overlay.set(id, rollup);
     mutations.push({
       activityId: id,
@@ -3933,7 +4004,8 @@ function computeWeightedProgress(parentId, overlay, hierarchy) {
     progress: overlay.has(child.id) ? overlay.get(child.id) : child.progress,
     ponderator: child.ponderator ?? 0
   }));
-  return Number((computeWeightedProgressRollup(children) ?? 0).toFixed(2));
+  const rollup = computeWeightedProgressRollup(children);
+  return rollup === null ? null : Number(rollup.toFixed(2));
 }
 function buildRecursiveTrackingEvents(activity, newValue) {
   return [
@@ -9884,24 +9956,82 @@ function resolveDerivedPasses(action, autoSchedule, options) {
 
 // src/dispatch/shared/post-mutation.ts
 async function runPostMutation(deps, args) {
-  const passes = resolvePasses(args);
+  const progressInvalidation = resolveProgressInvalidation(deps.adapter);
+  const passes = resolvePasses(args, progressInvalidation);
   if (passes.has(DERIVED_PASS.AUTOSCHEDULE)) {
     await refreshMutatedParentBounds(deps.adapter, args);
   }
   const schedule = passes.has(DERIVED_PASS.AUTOSCHEDULE) ? await runAutoschedule(deps, args.autoscheduleFrom) : emptySchedule();
-  await rollUpParentBounds(deps.adapter, args, schedule.scheduledIds, passes);
+  await rollUpParentBounds(
+    deps.adapter,
+    args,
+    schedule.scheduledIds,
+    passes,
+    progressInvalidation
+  );
   await runDerivedRecomputes(deps, passes, args.now);
   return schedule;
 }
-function resolvePasses(args) {
+function resolvePasses(args, progressInvalidation) {
   const requested = args.autoscheduleFrom !== null;
   const ran = !args.options.skipAutoSchedule && requested;
   const passes = new Set(
     resolveDerivedPasses(args.action, { ran }, args.options)
   );
-  if (args.recomputeParentProgress) passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  if (args.recomputeParentProgress || progressInvalidation.affectedParents.size > 0) {
+    passes.add(DERIVED_PASS.PARENT_PROGRESS);
+  }
   return passes;
 }
+function resolveProgressInvalidation(adapter) {
+  const affectedParents = /* @__PURE__ */ new Set();
+  const dirtySeeds = /* @__PURE__ */ new Set();
+  const journal = adapter.peekWriteCapture();
+  if (!journal) return { affectedParents, dirtySeeds };
+  const affectParent = (parentId) => {
+    if (parentId === null || isRootParent(parentId)) return;
+    const normalized2 = String(parentId);
+    affectedParents.add(normalized2);
+    const childId = adapter.getChildren(normalized2)[0];
+    if (childId !== void 0) dirtySeeds.add(childId);
+  };
+  collectStructuralProgressInvalidations(adapter, journal.ops, affectParent);
+  collectFieldProgressInvalidations(
+    adapter,
+    journal.before,
+    dirtySeeds,
+    affectParent
+  );
+  return { affectedParents, dirtySeeds };
+}
+function collectStructuralProgressInvalidations(adapter, operations, affectParent) {
+  for (const operation of operations) {
+    if (operation.kind === "insert") {
+      const inserted = adapter.getActivity(operation.activityId);
+      if (inserted) affectParent(inserted.parentId);
+    } else if (operation.kind === "remove") {
+      affectParent(operation.before.parentId);
+    }
+  }
+}
+function collectFieldProgressInvalidations(adapter, beforeById, dirtySeeds, affectParent) {
+  for (const [activityId, before] of beforeById) {
+    const after = adapter.getActivity(activityId);
+    if (!after) continue;
+    const progressChanged = !Object.is(before.progress, after.progress);
+    const ponderatorChanged = !Object.is(before.ponderator, after.ponderator);
+    const parentChanged = !Object.is(before.parentId, after.parentId);
+    if (progressChanged || ponderatorChanged) {
+      affectParent(after.parentId);
+      dirtySeeds.add(String(activityId));
+    }
+    if (parentChanged) {
+      affectParent(before.parentId);
+      affectParent(after.parentId);
+      dirtySeeds.add(String(activityId));
+    }
+  }
+}
 async function runAutoschedule(deps, autoscheduleFrom) {
   const options = autoscheduleFrom === "roots" ? {} : { triggerId: autoscheduleFrom };
   const result = await deps.scheduler.schedule(options);
@@ -9929,18 +10059,36 @@ async function refreshMutatedParentBounds(adapter, args) {
   if (mutated.size === 0) return;
   await updateParentBoundsFromChildren(adapter, mutated, false);
 }
-async function rollUpParentBounds(adapter, args, scheduledIds, passes) {
+async function rollUpParentBounds(adapter, args, scheduledIds, passes, progressInvalidation) {
+  if (passes.has(DERIVED_PASS.PARENT_PROGRESS)) {
+    restoreDemotedProgressFallbacks(
+      adapter,
+      progressInvalidation.affectedParents
+    );
+  }
   const dirty = args.collectDirty ? args.collectDirty(scheduledIds) : collectDirtyForStructural(args.recomputeParentsFrom, scheduledIds);
+  for (const activityId of progressInvalidation.dirtySeeds) {
+    dirty.add(activityId);
+  }
   await updateParentBoundsFromChildren(
     adapter,
     dirty,
     passes.has(DERIVED_PASS.PARENT_PROGRESS),
     {
       recomputeRealWork: passes.has(DERIVED_PASS.REAL_WORK),
-      progressMode: args.recomputeParentProgress ? "zero-when-no-contribution" : "freeze-when-no-contribution"
+      progressMode: "freeze-when-no-contribution"
     }
   );
 }
+function restoreDemotedProgressFallbacks(adapter, affectedParents) {
+  for (const parentId of affectedParents) {
+    if (adapter.hasChildren(parentId)) continue;
+    const fallback = adapter.getProgressFallback(parentId);
+    if (fallback === null) continue;
+    adapter.setActivityField(parentId, "progress", fallback);
+    adapter.setProgressFallback(parentId, null);
+  }
+}
 async function runDerivedRecomputes(deps, passes, now) {
   if (passes.has(DERIVED_PASS.EXPECTED_PROGRESS) && now !== null) {
     if (hasActiveBaseline(deps.adapter)) {
@@ -11169,7 +11317,6 @@ function buildParentMutations(input) {
     if ((input.promotionSource ?? "create") === "create") {
       fields.constraintType = CONSTRAINT_TYPE.ASAP;
       fields.constraintDate = null;
-      fields.progress = 0;
     }
   }
   return {
@@ -12322,60 +12469,6 @@ function dispatchSirSync(action, deps) {
   };
 }
 
-// src/propagations/upward/progress-rollup.ts
-function recomputeAllProgressRollup(adapter) {
-  for (const parentId of parentsDeepestFirst(adapter)) {
-    rollupParent(parentId, adapter);
-  }
-}
-function recomputeProgressRollupForParents(parentIdsDeepestFirst, adapter) {
-  for (const parentId of parentIdsDeepestFirst) {
-    rollupParent(parentId, adapter);
-  }
-}
-function parentsDeepestFirst(adapter) {
-  const parents = /* @__PURE__ */ new Set();
-  adapter.forEachActivity((_activity, id) => {
-    if (adapter.getChildren(id).length > 0) parents.add(id);
-  });
-  const depthById = /* @__PURE__ */ new Map();
-  for (const id of parents) depthById.set(id, depthOf2(id, adapter));
-  return [...parents].sort(
-    (a, b) => (depthById.get(b) ?? 0) - (depthById.get(a) ?? 0)
-  );
-}
-function depthOf2(id, adapter) {
-  let depth = 0;
-  let current = id;
-  while (current && current !== "0") {
-    if (!adapter.getActivity(current)) break;
-    depth += 1;
-    current = adapter.getParentId(current);
-  }
-  return depth;
-}
-function rollupParent(parentId, adapter) {
-  const childIds = adapter.getChildren(parentId);
-  if (childIds.length === 0) return;
-  const children = [];
-  for (const childId of childIds) {
-    const child = adapter.getActivity(childId);
-    if (!child) continue;
-    children.push({
-      progress: Number(child.progress ?? 0),
-      ponderator: Number(child.ponderator ?? 0)
-    });
-  }
-  const rollup = computeWeightedProgressRollup(children);
-  if (rollup !== null) {
-    adapter.setActivityField(
-      parentId,
-      COLUMN.PROGRESS,
-      roundProgressPerLevel(rollup)
-    );
-  }
-}
-
 // src/dispatch/handlers/persistence-acknowledge.ts
 function persistedOwnersOf(entities) {
   const owners = /* @__PURE__ */ new Map();
@@ -13442,6 +13535,11 @@ async function dispatchActivitySetProgress(action, options, deps) {
   const touchedIds = collectTouchedIds(action.activityId, changes);
   const beforeSnap = await snapshotActivities(adapter, touchedIds);
   applyFieldChanges(adapter, action.activityId, changes);
+  setExplicitSummaryProgressFallbacks(
+    action.activityId,
+    action.newValue,
+    adapter
+  );
   runPostProcessorsOnAdapter(
     action.activityId,
     changes.postProcessors ?? [],
@@ -17305,7 +17403,8 @@ var WriteCapture = class {
       ops: [],
       linkFieldCaptured: /* @__PURE__ */ new Set(),
       correlativeBefore: /* @__PURE__ */ new Map(),
-      scheduledBefore: /* @__PURE__ */ new Map()
+      scheduledBefore: /* @__PURE__ */ new Map(),
+      progressFallbackBefore: /* @__PURE__ */ new Map()
     };
   }
   peek() {
@@ -17368,6 +17467,11 @@ var WriteCapture = class {
       before: cloneLink(current)
     });
   }
+  noteProgressFallback(activityId, current) {
+    const journal = this._journal;
+    if (!journal || journal.progressFallbackBefore.has(activityId)) return;
+    journal.progressFallbackBefore.set(activityId, current);
+  }
 };
 function cloneLink(link) {
   return { ...link };
@@ -17613,6 +17717,7 @@ var ScheduleState = class _ScheduleState {
   _activities = /* @__PURE__ */ new Map();
   _lastStartDate = /* @__PURE__ */ new Map();
   _promotionSnapshot = /* @__PURE__ */ new Map();
+  _progressFallback = /* @__PURE__ */ new Map();
   _links = /* @__PURE__ */ new Map();
   _outgoing = /* @__PURE__ */ new Map();
   _incoming = /* @__PURE__ */ new Map();
@@ -17673,6 +17778,7 @@ var ScheduleState = class _ScheduleState {
         cloneDomainValue(snapshot)
       ])
     );
+    fork._progressFallback = new Map(this._progressFallback);
     fork._flags = cloneDomainValue(this._flags);
     fork._filterProjection = cloneDomainValue(this._filterProjection);
     return fork;
@@ -17726,6 +17832,17 @@ var ScheduleState = class _ScheduleState {
     this._capturePromotionSnapshotOnce();
     this._promotionSnapshot.set(String(activityId), snapshot);
   }
+  getProgressFallback(activityId) {
+    return this._progressFallback.get(String(activityId)) ?? null;
+  }
+  setProgressFallback(activityId, value) {
+    const key = String(activityId);
+    const current = this._progressFallback.get(key) ?? null;
+    if (Object.is(current, value)) return;
+    this._writeCapture.noteProgressFallback(key, current);
+    if (value === null) this._progressFallback.delete(key);
+    else this._progressFallback.set(key, value);
+  }
   _capturePromotionSnapshotOnce() {
     if (this._writeCapture.peek() === null) return;
     if (this._promotionSnapshotBefore === null) {
@@ -17976,6 +18093,7 @@ var ScheduleState = class _ScheduleState {
     const activity = this.getActivity(activityId);
     if (activity) this._writeCapture.noteRemove(String(activityId), activity);
     const key = String(activityId);
+    this.setProgressFallback(key, null);
     if (this._viewState.isChecked(key) || !this._viewState.isVisible(key)) {
       this._captureViewStateOnce();
     }
@@ -18000,7 +18118,13 @@ var ScheduleState = class _ScheduleState {
   restoreFromCapture() {
     const journal = this._writeCapture.peek();
     if (!journal) return;
-    const { ops, before, correlativeBefore, scheduledBefore } = journal;
+    const {
+      ops,
+      before,
+      correlativeBefore,
+      scheduledBefore,
+      progressFallbackBefore
+    } = journal;
     this._undoLinkAdds(ops);
     this._undoInserts(ops);
     this._reInsertRemovedActivities(ops);
@@ -18009,6 +18133,7 @@ var ScheduleState = class _ScheduleState {
     this._restoreCorrelatives(correlativeBefore);
     this._restoreActivityFields(scheduledBefore);
     this._restoreActivityFields(before);
+    this._restoreProgressFallbacks(progressFallbackBefore);
     if (this._viewStateBefore !== null) {
       this._viewState.restore(this._viewStateBefore);
       this._filterProjection = null;
@@ -18024,6 +18149,12 @@ var ScheduleState = class _ScheduleState {
     this._cache.visualOrderIds = null;
     this._hierarchy.markDirty();
   }
+  _restoreProgressFallbacks(before) {
+    for (const [activityId, value] of before) {
+      if (value === null) this._progressFallback.delete(activityId);
+      else this._progressFallback.set(activityId, value);
+    }
+  }
   _restoreCorrelatives(correlativeBefore) {
     for (const [id, before] of correlativeBefore) {
       const live = this._activities.get(id);
@@ -18237,13 +18368,15 @@ function buildHistoryChangeSet(changes) {
     links: linksWithoutAfter
   });
 }
-function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks) {
+function buildUndoEntry(changeSet, beforeSnap, beforeLinks, afterSnap, afterLinks, progressFallbackBefore, progressFallbackAfter) {
   return {
     changeSet,
     beforeSnap,
     beforeLinks: resetDerivedLinkSnapshots(beforeLinks),
     afterSnap,
-    afterLinks: resetDerivedLinkSnapshots(afterLinks)
+    afterLinks: resetDerivedLinkSnapshots(afterLinks),
+    progressFallbackBefore,
+    progressFallbackAfter
   };
 }
 function resetDerivedLinkSnapshots(snapshots) {
@@ -18546,6 +18679,10 @@ function applyChangeSetSide(state, entry, side) {
       );
     }
   }
+  const progressFallbacks = side === "before" ? entry.progressFallbackBefore : entry.progressFallbackAfter;
+  for (const [activityId, value] of progressFallbacks ?? []) {
+    state.setProgressFallback(activityId, value);
+  }
 }
 
 // src/dispatch/undo/undo-recorder.ts
@@ -20437,6 +20574,7 @@ async function runInitialPasses(deps) {
   normalizeLoadedConstraintDates(state);
   recomputeCanonicalRealWork(state);
   if (skipAutoSchedule) {
+    recomputeAllProgressRollup(state);
     if (now) {
       applyExpectedProgressLive(state, now);
       applyStatusPass(state, sector.statusCriteria);
@@ -20448,6 +20586,7 @@ async function runInitialPasses(deps) {
   normalizeMilestoneConstraintDatesForDisplay(state);
   recomputeSkippedLeafEnds(state);
   await updateParentBoundsFromChildren(state, void 0, false);
+  recomputeAllProgressRollup(state);
   if (now) {
     applyExpectedProgressLive(state, now);
     applyStatusPass(state, sector.statusCriteria);
@@ -21282,6 +21421,7 @@ var ScheduleCore = class _ScheduleCore {
     this.coreRuntime.state.beginWriteCapture();
     this.coreRuntime.customIdTracker.beginCustomIdTransaction();
     let result;
+    let progressFallbackBefore;
     try {
       result = await performDispatch(action, options, {
         adapter: this.coreRuntime.state,
@@ -21302,6 +21442,10 @@ var ScheduleCore = class _ScheduleCore {
         )?.id ?? null,
         now: this.coreRuntime.clock ? endOfLocalDay(this.coreRuntime.clock()) : null
       });
+      const fallbackBefore = this.coreRuntime.state.peekWriteCapture()?.progressFallbackBefore;
+      if (fallbackBefore && fallbackBefore.size > 0) {
+        progressFallbackBefore = new Map(fallbackBefore);
+      }
       if (!result.ok) this._rollback(generatorSnapshot);
     } catch (error) {
       this._rollback(generatorSnapshot);
@@ -21315,13 +21459,21 @@ var ScheduleCore = class _ScheduleCore {
         this.coreRuntime.state,
         result.changes
       );
+      const progressFallbackAfter = progressFallbackBefore ? new Map(
+        Array.from(progressFallbackBefore.keys(), (activityId) => [
+          activityId,
+          this.coreRuntime.state.getProgressFallback(activityId)
+        ])
+      ) : void 0;
       this._undo.record(
         buildUndoEntry(
           buildHistoryChangeSet(result.changes),
           result.__beforeSnap,
           result.__beforeLinks,
           created.afterSnap,
-          created.afterLinks
+          created.afterLinks,
+          progressFallbackBefore,
+          progressFallbackAfter
         ),
         computeCoalesceKey(action),
         Date.now()