@outbuild-company/schedule-core 1.24.0 → 1.26.0

package/dist/index.cjs

@@ -630,17 +630,19 @@ function createActivitiesApi(engine) {
 }
 function createCellsApi(engine) {
   return {
-    copy: (activityId, column, context = {}) => engine.dispatch({
+    copy: (activityId, column, copiedText, context = {}) => engine.dispatch({
       ...context,
       kind: DISPATCH_ACTION_KIND.CELL_COPY,
       activityId,
-      column
+      column,
+      ...copiedText === void 0 ? {} : { copiedText }
     }),
-    paste: (activityIds, column, context = {}) => engine.dispatch({
+    paste: (activityIds, column, clipboardText, context = {}) => engine.dispatch({
       ...context,
       kind: DISPATCH_ACTION_KIND.CELL_PASTE_COPIED,
       activityIds,
-      column
+      column,
+      ...clipboardText === void 0 ? {} : { clipboardText }
     }),
     clearClipboard: (context = {}) => engine.dispatch({
       ...context,
@@ -957,6 +959,7 @@ var REJECTION_REASON = {
   NO_ACTIVITY_SELECTION: "no_activity_selection",
   CLIPBOARD_EMPTY: "clipboard_empty",
   CLIPBOARD_SNAPSHOT_INVALID: "clipboard_snapshot_invalid",
+  CELL_PASTE_COLUMN_MISMATCH: "cell_paste_column_mismatch",
   ACTIVITY_PASTE_INVARIANT_FAILED: "activity_paste_invariant_failed",
   SOLE_SCHEDULE_ROOT: "sole_schedule_root",
   ANCHOR_SIBLING_CONFLICT: "anchor_sibling_conflict",
@@ -6287,7 +6290,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 +18021,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 +18029,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
@@ -19008,7 +19015,12 @@ function dispatchCellCopy(action, deps) {
     return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
   }
   const raw = action.column === COLUMN.DURATION ? canonicalValue / deps.hoursPerDay : cloneDomainValue(canonicalValue);
-  deps.clipboard.value = { kind: CELL_CLIPBOARD_KIND.FIELD, raw };
+  deps.clipboard.value = {
+    kind: CELL_CLIPBOARD_KIND.FIELD,
+    raw,
+    sourceColumn: action.column,
+    text: action.copiedText ?? null
+  };
   return emptyChangeSet(action);
 }
 function dispatchCellClipboardClear(action, clipboard) {
@@ -19017,6 +19029,39 @@ function dispatchCellClipboardClear(action, clipboard) {
 }
 
 // src/cell-copy-paste/paste.ts
+var RESTRICTED_CELL_COLUMNS = /* @__PURE__ */ new Set([
+  COLUMN.TAGS,
+  COLUMN.RESPONSABLES,
+  COLUMN.SUBCONTRACT_ID,
+  COLUMN.CONSTRAINT_TYPE,
+  COLUMN.CALENDAR_ID
+]);
+function isIncompatibleCellPaste(sourceColumn, targetColumn) {
+  if (sourceColumn === targetColumn) return false;
+  return RESTRICTED_CELL_COLUMNS.has(sourceColumn) || RESTRICTED_CELL_COLUMNS.has(targetColumn);
+}
+function resolveExternalPasteText(stashedField, clipboardText) {
+  if (clipboardText === void 0) return null;
+  const rawIsTrustworthy = stashedField !== null && (stashedField.text === null || stashedField.text === clipboardText);
+  return rawIsTrustworthy ? null : clipboardText;
+}
+function resolveFieldPasteValue(clipboard, column, clipboardText) {
+  const stashedField = clipboard !== null && clipboard.kind === CELL_CLIPBOARD_KIND.FIELD ? clipboard : null;
+  const externalText = resolveExternalPasteText(stashedField, clipboardText);
+  if (externalText !== null) {
+    return { ok: true, newValue: externalText };
+  }
+  if (clipboard !== null && clipboard.kind !== CELL_CLIPBOARD_KIND.FIELD) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  if (stashedField === null) {
+    return { ok: false, reason: REJECTION_REASON.CLIPBOARD_EMPTY };
+  }
+  if (isIncompatibleCellPaste(stashedField.sourceColumn, column)) {
+    return { ok: false, reason: REJECTION_REASON.CELL_PASTE_COLUMN_MISMATCH };
+  }
+  return { ok: true, newValue: stashedField.raw };
+}
 function toDiffPlaceholder(activityId) {
   return String(activityId);
 }
@@ -19049,11 +19094,45 @@ function linkOperationsForTarget(targetActivityId, isPredecessors, clipboard, de
   });
   return diff.operations;
 }
-async function dispatchCellPasteCopied(action, options, deps) {
-  const clipboard = deps.cellClipboard.value;
+async function dispatchCellPasteLinkColumn(action, clipboard, options, deps) {
   if (clipboard === null) {
     return { ok: false, reason: REJECTION_REASON.CLIPBOARD_EMPTY };
   }
+  if (clipboard.kind !== CELL_CLIPBOARD_KIND.LINKS) {
+    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+  }
+  const hasSelfReference = action.activityIds.some(
+    (activityId) => clipboard.specs.some(
+      (spec) => String(spec.otherActivityId) === String(activityId)
+    )
+  );
+  if (hasSelfReference) {
+    return { ok: false, reason: LINK_REJECTION_REASON.SELF_LINK };
+  }
+  const isPredecessors = action.column === COLUMN.CUSTOM_PREDECESSORS;
+  const operations = action.activityIds.flatMap(
+    (activityId) => linkOperationsForTarget(activityId, isPredecessors, clipboard, deps)
+  );
+  const createEntries = operations.filter(
+    (operation) => operation.kind === LINK_OPERATION_KIND.CREATE
+  ).map((operation) => ({
+    operation,
+    linkId: deps.linkIdGen.next()
+  }));
+  const creation = validateLinkCreateBatch(createEntries, {
+    port: deps.adapter,
+    rejectParentLinkMutations: options.rejectParentLinkMutations ?? false
+  });
+  if (!creation.applied) {
+    return {
+      ok: false,
+      reason: creation.rejected ?? REJECTION_REASON.INVALID
+    };
+  }
+  return dispatchLinkBatch(operations, action, options, deps);
+}
+async function dispatchCellPasteCopied(action, options, deps) {
+  const clipboard = deps.cellClipboard.value;
   if (action.activityIds.length === 0) {
     return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
   }
@@ -19064,53 +19143,25 @@ async function dispatchCellPasteCopied(action, options, deps) {
     return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
   }
   if (action.column === COLUMN.CUSTOM_PREDECESSORS || action.column === COLUMN.CUSTOM_SUCESSORS) {
-    if (clipboard.kind !== CELL_CLIPBOARD_KIND.LINKS) {
-      return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
-    }
-    const hasSelfReference = action.activityIds.some(
-      (activityId) => clipboard.specs.some(
-        (spec) => String(spec.otherActivityId) === String(activityId)
-      )
-    );
-    if (hasSelfReference) {
-      return { ok: false, reason: LINK_REJECTION_REASON.SELF_LINK };
-    }
-    const isPredecessors = action.column === COLUMN.CUSTOM_PREDECESSORS;
-    const operations = action.activityIds.flatMap(
-      (activityId) => linkOperationsForTarget(activityId, isPredecessors, clipboard, deps)
-    );
-    const createEntries = operations.filter(
-      (operation) => operation.kind === LINK_OPERATION_KIND.CREATE
-    ).map((operation) => ({
-      operation,
-      linkId: deps.linkIdGen.next()
-    }));
-    const creation = validateLinkCreateBatch(createEntries, {
-      port: deps.adapter,
-      rejectParentLinkMutations: options.rejectParentLinkMutations ?? false
-    });
-    if (!creation.applied) {
-      return {
-        ok: false,
-        reason: creation.rejected ?? REJECTION_REASON.INVALID
-      };
-    }
-    return dispatchLinkBatch(operations, action, options, deps);
-  }
-  if (clipboard.kind !== CELL_CLIPBOARD_KIND.FIELD) {
-    return { ok: false, reason: REJECTION_REASON.INVALID_VALUE };
+    return dispatchCellPasteLinkColumn(action, clipboard, options, deps);
   }
   if (!findPipelineForColumn(action.column)) {
     return { ok: false, reason: REJECTION_REASON.NO_PIPELINE_FOR_COLUMN };
   }
   const column = action.column;
+  const resolution = resolveFieldPasteValue(
+    clipboard,
+    column,
+    action.clipboardText
+  );
+  if (!resolution.ok) return resolution;
   const result = await dispatchBulkEdit(
     {
       kind: DISPATCH_ACTION_KIND.BULK_EDIT,
       edits: action.activityIds.map((activityId) => ({
         activityId,
         column,
-        newValue: clipboard.raw
+        newValue: resolution.newValue
       })),
       ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
     },
@@ -24828,12 +24879,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 +24926,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 +30160,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 +30306,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 +30362,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;
 }