@outbuild-company/schedule-core 1.24.0 → 1.25.0

package/dist/index.cjs

@@ -6287,7 +6287,9 @@ var P6_PERCENT_COMPLETE_TYPE = {
 var P6_ACTIVITY_TYPE = {
   TASK: "task",
   LEVEL_OF_EFFORT: "level_of_effort",
-  START_MILESTONE: "start_milestone"};
+  START_MILESTONE: "start_milestone",
+  RESOURCE_DEPENDENT: "resource_dependent"
+};
 var P6_EXECUTION_STATUS = {
   NOT_STARTED: "not_started",
   IN_PROGRESS: "in_progress",
@@ -18016,6 +18018,7 @@ var LOAD_DIAGNOSTIC_SAMPLE_LIMIT = 10;
 var LOAD_DIAGNOSTIC_CODE = {
   INVALID_BASELINE_POINT: "invalid_baseline_point",
   UNKNOWN_CONSTRAINT: "unknown_constraint",
+  PROGRESS_OUT_OF_RANGE: "progress_out_of_range",
   ORPHAN_ACTIVITY: "orphan_activity",
   INVALID_LINK: "invalid_link",
   DUPLICATE_LINK: "duplicate_link"
@@ -18023,6 +18026,7 @@ var LOAD_DIAGNOSTIC_CODE = {
 var LOAD_DIAGNOSTIC_CODE_ORDER = [
   LOAD_DIAGNOSTIC_CODE.INVALID_BASELINE_POINT,
   LOAD_DIAGNOSTIC_CODE.UNKNOWN_CONSTRAINT,
+  LOAD_DIAGNOSTIC_CODE.PROGRESS_OUT_OF_RANGE,
   LOAD_DIAGNOSTIC_CODE.ORPHAN_ACTIVITY,
   LOAD_DIAGNOSTIC_CODE.INVALID_LINK,
   LOAD_DIAGNOSTIC_CODE.DUPLICATE_LINK
@@ -24828,12 +24832,21 @@ function normalizePersistedActivityId(rawId) {
   }
   return rawId;
 }
-function parseProgress(raw) {
+function parseProgress(raw, reporter, recordDiagnostic, activityId) {
   const progress = Number(raw);
-  if (!Number.isFinite(progress) || progress < NOT_STARTED_PROGRESS || progress > MAX_TOLERATED_PROGRESS) {
+  if (!Number.isFinite(progress)) {
     throw new TypeError(`invalid activity progress ${String(raw)}`);
   }
-  return progress;
+  const isBelowNotStarted = progress < NOT_STARTED_PROGRESS;
+  const isAboveCompleted = progress > MAX_TOLERATED_PROGRESS;
+  const isWithinRange = !isBelowNotStarted && !isAboveCompleted;
+  if (isWithinRange) return progress;
+  const clamped = isBelowNotStarted ? NOT_STARTED_PROGRESS : COMPLETED_PROGRESS;
+  recordDiagnostic(LOAD_DIAGNOSTIC_CODE.PROGRESS_OUT_OF_RANGE, activityId);
+  reporter.warn(
+    `[parseFromBackend] activity "${activityId}" progress ${String(raw)} is out of range \u2014 clamping to ${clamped}`
+  );
+  return clamped;
 }
 function parseCriticality(raw, reporter) {
   if (typeof raw.is_critical === "boolean") return raw.is_critical;
@@ -24866,7 +24879,12 @@ function parseActivity(raw, context) {
     context.defaultCalendarId
   );
   const inheritedDefaultCalendar = raw.calendarId == null || !context.knownCalendarIds.has(String(raw.calendarId));
-  const progress = parseProgress(raw.progress);
+  const progress = parseProgress(
+    raw.progress,
+    context.reporter,
+    context.recordDiagnostic,
+    String(raw.unique_id)
+  );
   const { constraintType, constraintDate } = resolveConstraint(
     raw,
     context.reporter,
@@ -30095,6 +30113,39 @@ function blockedActivities(code, message, activityIds, missingInputs = []) {
   };
 }
 
+// src/p6/rolled-expected-finish.ts
+var PINNABLE_ACTIVITY_TYPES = /* @__PURE__ */ new Set([
+  P6_ACTIVITY_TYPE.TASK,
+  P6_ACTIVITY_TYPE.RESOURCE_DEPENDENT
+]);
+var NO_ROLLED_EXPECTED_FINISHES = /* @__PURE__ */ new Map();
+function planRolledExpectedFinishes(input) {
+  const adoptsShownFinishes = input.settings.useExpectedFinishDates && rollsDataDateForward(input.previousSettings, input.settings);
+  if (!adoptsShownFinishes) return NO_ROLLED_EXPECTED_FINISHES;
+  const pinned = /* @__PURE__ */ new Map();
+  for (const [activityId, state] of input.activities) {
+    const shownFinish = state.remainingEarlyFinish;
+    if (shownFinish === null) continue;
+    if (!needsExpectedFinishPin(state)) continue;
+    pinned.set(activityId, new Date(shownFinish));
+  }
+  return pinned;
+}
+function rollsDataDateForward(previous, next) {
+  const previousDataDate = previous.dataDate;
+  const nextDataDate = next.dataDate;
+  if (previousDataDate === null || nextDataDate === null) return false;
+  return nextDataDate.getTime() > previousDataDate.getTime();
+}
+function needsExpectedFinishPin(state) {
+  return state.executionStatus === P6_EXECUTION_STATUS.IN_PROGRESS && state.expectedFinish === null && hasPinnableActivityType(state);
+}
+function hasPinnableActivityType(state) {
+  const { activityType } = state;
+  if (activityType === void 0) return true;
+  return PINNABLE_ACTIVITY_TYPES.has(activityType);
+}
+
 // src/p6/commands.ts
 function dataDateScheduleReadiness(input) {
   const preflight = getP6SchedulePreflight({
@@ -30208,8 +30259,17 @@ function prepareDataDateSchedule(input) {
     preflight.settings,
     beforeProjectState
   );
+  const rolledExpectedFinishes = planRolledExpectedFinishes({
+    previousSettings: preflight.previousSettings,
+    settings: preflight.settings,
+    activities: preflight.activities
+  });
   const calculated = calculateP6Schedule({
-    adapter: calculationState(input.state, preflight.activities),
+    adapter: calculationState(
+      input.state,
+      preflight.activities,
+      rolledExpectedFinishes
+    ),
     settings: preflight.settings,
     project: {
       projectId: String(input.sector.projectId),
@@ -30255,11 +30315,19 @@ function requireProjectState(projectState) {
     "P6 capability is not enabled for this Schedule"
   );
 }
-function calculationState(current, schedulableActivities) {
+function calculationState(current, schedulableActivities, rolledExpectedFinishes) {
   const state = current.fork();
   state.forEachActivity((activity) => {
-    if (schedulableActivities.has(activity.id)) return;
-    state.setActivityField(activity.id, "p6", void 0);
+    if (!schedulableActivities.has(activity.id)) {
+      state.setActivityField(activity.id, "p6", void 0);
+      return;
+    }
+    const rolledExpectedFinish = rolledExpectedFinishes.get(activity.id);
+    if (rolledExpectedFinish === void 0 || activity.p6 === void 0) return;
+    state.setActivityField(activity.id, "p6", {
+      ...activity.p6,
+      expectedFinish: rolledExpectedFinish
+    });
   });
   return state;
 }