@outbuild-company/schedule-core 1.20.0 → 1.21.0

package/dist/index.cjs

@@ -345,6 +345,7 @@ var DISPATCH_ACTION_KIND = {
   ACTIVITY_COPY: "activity-copy",
   CALENDAR_RECONCILE: "calendar-reconcile",
   ACTIVITY_PASTE_COPIED: "activity-paste-copied",
+  ACTIVITY_DUPLICATE: "activity-duplicate",
   PERSISTENCE_ACKNOWLEDGE: "persistence-acknowledge",
   BASELINE_APPLY: "baseline-apply",
   PONDERATOR_CRITERION_SET: "ponderator-criterion-set",
@@ -593,6 +594,11 @@ function createActivitiesApi(engine) {
       kind: DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED,
       destination: { afterSiblingId }
     }),
+    duplicate: (activityIds, context = {}) => engine.dispatch({
+      ...context,
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_DUPLICATE,
+      activityIds
+    }),
     clearClipboard: (context = {}) => engine.dispatch({
       ...context,
       kind: DISPATCH_ACTION_KIND.ACTIVITY_CLIPBOARD_CLEAR
@@ -919,6 +925,7 @@ var REJECTION_REASON = {
   NO_ACTIVITY_SELECTION: "no_activity_selection",
   CLIPBOARD_EMPTY: "clipboard_empty",
   ACTIVITY_PASTE_INVARIANT_FAILED: "activity_paste_invariant_failed",
+  SOLE_SCHEDULE_ROOT: "sole_schedule_root",
   ANCHOR_SIBLING_CONFLICT: "anchor_sibling_conflict",
   ANCHOR_SIBLING_NOT_FOUND: "anchor_sibling_not_found",
   ANCHOR_SIBLING_WRONG_PARENT: "anchor_sibling_wrong_parent",
@@ -11935,12 +11942,34 @@ function draftRemainingDuration(activity) {
 }
 
 // src/p6/inactive-drafts.ts
-function refreshUnimportedDataDateDrafts(state, input) {
+function trackInactiveDataDateDrafts(state, input) {
+  const p6Input = input ?? void 0;
+  const beforeInitialPasses = snapshotInactiveDataDateDrafts(state, p6Input);
+  return () => refreshInactiveDataDateDrafts(state, p6Input, beforeInitialPasses);
+}
+function snapshotInactiveDataDateDrafts(state, input) {
+  if (input === void 0 || hasActiveDataDate(input.settings)) {
+    return /* @__PURE__ */ new Map();
+  }
+  return new Map(
+    state.getAllActivities().filter(
+      (activity) => activity.p6 !== void 0 && Object.hasOwn(input.activities, activity.id)
+    ).map((activity) => [activity.id, structuredCloneActivity(activity)])
+  );
+}
+function refreshInactiveDataDateDrafts(state, input, beforeInitialPasses) {
   if (input === void 0 || hasActiveDataDate(input.settings)) return;
   for (const activity of state.getAllActivities()) {
-    if (Object.hasOwn(input.activities, activity.id)) continue;
-    const p6 = createOutbuildP6ActivityDraft(activity);
-    if (p6 !== void 0) state.setActivityField(activity.id, "p6", p6);
+    if (!Object.hasOwn(input.activities, activity.id)) {
+      const p6 = createOutbuildP6ActivityDraft(activity);
+      if (p6 !== void 0) state.setActivityField(activity.id, "p6", p6);
+      continue;
+    }
+    const before = beforeInitialPasses.get(activity.id);
+    if (before?.p6 === void 0 || activity.p6 === void 0) continue;
+    const patch = ordinaryInputChanges(before, activity);
+    if (Object.keys(patch).length === 0) continue;
+    state.setActivityField(activity.id, "p6", { ...activity.p6, ...patch });
   }
 }
 function synchronizeInactiveDataDateDrafts(state) {
@@ -18460,6 +18489,293 @@ async function dispatchActivityPasteCopied(action, options, deps) {
   };
 }
 
+// src/activity-copy-paste/duplicate.ts
+var CLONE_YIELD_EVERY_N = 200;
+var CREATE_OPTIONS = {
+  skipCorrelativeRecompute: true,
+  skipBeforeSnap: true,
+  skipCacheInvalidation: true,
+  skipRollupCascades: true
+};
+async function dispatchActivityDuplicate(action, options, deps) {
+  const resolved = resolveDuplicateRuns(action.activityIds, deps.adapter);
+  if (!resolved.ok) return resolved;
+  const frozenParent = firstFrozenRunParent(resolved.runs, deps.adapter);
+  if (frozenParent) {
+    return { ok: false, reason: REJECTION_REASON.PARENT_FROZEN_BY_SIR };
+  }
+  deps.scheduler.invalidateAllCaches();
+  const beforeSnapshot = await snapshotActivities(
+    deps.adapter,
+    /* @__PURE__ */ new Set()
+  );
+  const state = {
+    originalToNew: /* @__PURE__ */ new Map(),
+    createdIds: [],
+    createdParentIds: []
+  };
+  for (const run of resolved.runs) {
+    const lastOriginal = run.originals.at(-1);
+    if (!lastOriginal) continue;
+    let anchorId = lastOriginal.id;
+    for (const original of run.originals) {
+      anchorId = await cloneSubtree(
+        original,
+        run.parentId,
+        anchorId,
+        action,
+        deps,
+        state
+      );
+    }
+  }
+  recomputeCreatedParentRollups(state, deps);
+  const correlativeShifts = recomputeCorrelativeIds(deps.adapter);
+  const createdIdSet = new Set(state.createdIds.map(String));
+  const touched = /* @__PURE__ */ new Set();
+  seedJournalBeforeImages(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnapshot
+  );
+  foldCorrelativeShifts(
+    deps.adapter,
+    correlativeShifts,
+    createdIdSet,
+    beforeSnapshot,
+    touched
+  );
+  for (const createdId of state.createdIds) touched.add(String(createdId));
+  const applied = replicateInternalLinks(state, deps);
+  const { scheduledIds } = await runPostMutation(
+    {
+      adapter: deps.adapter,
+      scheduler: deps.scheduler,
+      sector: deps.sector,
+      defaultBaseCalendarId: deps.defaultBaseCalendarId
+    },
+    {
+      action,
+      autoscheduleFrom: state.createdIds.length > 0 ? AUTOSCHEDULE_SCOPE.ROOTS : null,
+      recomputeParentsFrom: state.createdIds,
+      preventSummaryTargetPullback: true,
+      now: deps.now,
+      options
+    }
+  );
+  return {
+    ok: true,
+    changes: await assembleChangeSet(deps.adapter, {
+      source: action,
+      beforeSnap: beforeSnapshot,
+      touchedIds: touched,
+      scheduledIds,
+      links: buildLinkChangesForBatch(
+        applied,
+        /* @__PURE__ */ new Map(),
+        deps.adapter
+      ),
+      hoursPerDay: deps.sector.hoursPerDay
+    })
+  };
+}
+function resolveDuplicateRuns(activityIds, adapter) {
+  if (activityIds.length === 0) {
+    return { ok: false, reason: REJECTION_REASON.ACTIVITY_IDS_EMPTY };
+  }
+  const requested = /* @__PURE__ */ new Set();
+  const originals = [];
+  for (const rawId of activityIds) {
+    const activityId = String(rawId);
+    if (requested.has(activityId)) continue;
+    const activity = adapter.getActivity(activityId);
+    if (!activity) {
+      return { ok: false, reason: REJECTION_REASON.ACTIVITY_NOT_FOUND };
+    }
+    requested.add(activityId);
+    originals.push(activity);
+  }
+  const roots = originals.filter(
+    (activity) => !hasAncestorInSet(activity.id, requested, adapter)
+  );
+  const duplicatesSoleScheduleRoot = adapter.getRootIds().length === 1 && roots.some((activity) => activity.parentId == null);
+  if (duplicatesSoleScheduleRoot) {
+    return { ok: false, reason: REJECTION_REASON.SOLE_SCHEDULE_ROOT };
+  }
+  return { ok: true, runs: groupIntoContiguousRuns(roots, adapter) };
+}
+function firstFrozenRunParent(runs, adapter) {
+  const checked = /* @__PURE__ */ new Set();
+  for (const run of runs) {
+    if (run.parentId === ROOT_PARENT_ID || checked.has(String(run.parentId))) {
+      continue;
+    }
+    checked.add(String(run.parentId));
+    const parent = adapter.getActivity(run.parentId);
+    if (parent && isFrozen(parent)) return parent;
+  }
+  return null;
+}
+function groupIntoContiguousRuns(roots, adapter) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const activity of roots) {
+    const parentKey = normalizeParentKey(activity.parentId);
+    const group = byParent.get(parentKey) ?? [];
+    group.push(activity);
+    byParent.set(parentKey, group);
+  }
+  const runs = [];
+  for (const [parentKey, group] of byParent) {
+    const parentId = parentKey === ROOT_PARENT_ID ? ROOT_PARENT_ID : parentKey;
+    const positions = new Map(
+      childrenInCorrelativeOrder(adapter, parentKey).map(
+        (sibling, index) => [String(sibling.id), index]
+      )
+    );
+    const positionOf = (activity) => positions.get(String(activity.id)) ?? -1;
+    const ordered = [...group].sort(
+      (left, right) => positionOf(left) - positionOf(right)
+    );
+    for (const originals of splitContiguous(ordered, positionOf)) {
+      runs.push({ parentId, originals });
+    }
+  }
+  return runs;
+}
+function splitContiguous(ordered, positionOf) {
+  const runs = [];
+  let previousPosition = null;
+  for (const activity of ordered) {
+    const position = positionOf(activity);
+    const lastRun = runs.at(-1);
+    if (lastRun && previousPosition !== null && position === previousPosition + 1) {
+      lastRun.push(activity);
+    } else {
+      runs.push([activity]);
+    }
+    previousPosition = position;
+  }
+  return runs;
+}
+function seedJournalBeforeImages(adapter, shifts, excludeIds, beforeSnap) {
+  const journal = adapter.peekWriteCapture();
+  if (!journal) return;
+  for (const shift of shifts) {
+    if (excludeIds.has(shift.activityId) || beforeSnap.has(shift.activityId)) {
+      continue;
+    }
+    const beforeImage = journal.before.get(shift.activityId);
+    if (beforeImage) beforeSnap.set(shift.activityId, beforeImage);
+  }
+}
+function childrenInCorrelativeOrder(adapter, parentKey) {
+  return collectSiblings(adapter, parentKey).sort((left, right) => {
+    const diff = readCorrelativeId(left) - readCorrelativeId(right);
+    return diff || String(left.id).localeCompare(String(right.id));
+  });
+}
+async function cloneSubtree(original, parentId, anchorId, action, deps, state) {
+  const root = await createActivityCore(
+    {
+      kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE,
+      parentId,
+      afterSiblingId: anchorId,
+      overrides: copyOverrides(original),
+      ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
+    },
+    deps,
+    { ...CREATE_OPTIONS, customIdReferenceId: original.id }
+  );
+  if (!root.ok) throw invariantViolation("create", root.reason);
+  registerCreated(state, original, root.newId, parentId);
+  await cloneDescendantsIteratively(original, root.newId, action, deps, state);
+  return root.newId;
+}
+async function cloneDescendantsIteratively(rootOriginal, rootNewParentId, action, deps, state) {
+  const pending = new Queue();
+  pending.enqueue({ original: rootOriginal, newParentId: rootNewParentId });
+  let processed = 0;
+  while (!pending.isEmpty()) {
+    const { original, newParentId } = pending.dequeue();
+    for (const child of childrenInCorrelativeOrder(
+      deps.adapter,
+      String(original.id)
+    )) {
+      const created = await createActivityCore(
+        {
+          kind: DISPATCH_ACTION_KIND.ACTIVITY_CREATE,
+          parentId: newParentId,
+          overrides: copyOverrides(child),
+          ...action.eventSource === void 0 ? {} : { eventSource: action.eventSource }
+        },
+        deps,
+        CREATE_OPTIONS
+      );
+      if (!created.ok) throw invariantViolation("create", created.reason);
+      registerCreated(state, child, created.newId, newParentId);
+      pending.enqueue({ original: child, newParentId: created.newId });
+      processed += 1;
+      if (processed % CLONE_YIELD_EVERY_N === 0) await yieldToBrowser();
+    }
+  }
+}
+function invariantViolation(step, reason) {
+  return new Error(
+    `[ScheduleCore] activity-duplicate: unexpected ${step} rejection after preflight passed (${reason})`
+  );
+}
+function registerCreated(state, original, newId, parentId) {
+  state.originalToNew.set(String(original.id), newId);
+  state.createdIds.push(newId);
+  state.createdParentIds.push(parentId);
+}
+function recomputeCreatedParentRollups(state, deps) {
+  const recomputed = /* @__PURE__ */ new Set();
+  for (const parentId of [...state.createdParentIds].reverse()) {
+    if (parentId === ROOT_PARENT_ID || recomputed.has(String(parentId))) {
+      continue;
+    }
+    recomputed.add(String(parentId));
+    recomputeRollupCascadesForParent(parentId, deps.adapter);
+  }
+}
+function replicateInternalLinks(state, deps) {
+  const applied = [];
+  for (const originalId of state.originalToNew.keys()) {
+    for (const linkId of deps.adapter.getOutgoingLinkIds(originalId)) {
+      const link = deps.adapter.getLink(linkId);
+      if (!link) continue;
+      const source = state.originalToNew.get(String(link.source));
+      const target = state.originalToNew.get(String(link.target));
+      if (source === void 0 || target === void 0) continue;
+      const operation = {
+        kind: LINK_OPERATION_KIND.CREATE,
+        source,
+        target,
+        type: link.type,
+        lag: link.lag
+      };
+      const result = applyLinkOperation(operation, {
+        port: deps.adapter,
+        newLinkId: deps.linkIdGen.next
+      });
+      if (!result.applied) {
+        throw invariantViolation(
+          "link",
+          result.rejected ?? REJECTION_REASON.INVALID
+        );
+      }
+      applied.push({
+        op: operation,
+        finalLinkId: result.linkId,
+        rejected: null
+      });
+    }
+  }
+  return applied;
+}
+
 // src/dispatch/dispatch.ts
 async function performDispatch(action, options, deps) {
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_COPY) {
@@ -18477,6 +18793,9 @@ async function performDispatch(action, options, deps) {
   if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_PASTE_COPIED) {
     return dispatchActivityPasteCopied(action, options, deps);
   }
+  if (action.kind === DISPATCH_ACTION_KIND.ACTIVITY_DUPLICATE) {
+    return dispatchActivityDuplicate(action, options, deps);
+  }
   if (action.kind === ACTIVITY_BATCH_ACTION_KIND) {
     return dispatchActivityBatch(action, options, deps);
   }
@@ -29781,13 +30100,14 @@ function initializeCore(input) {
       loadDiagnostics.record
     );
   }
+  const settleInactiveDrafts = trackInactiveDataDateDrafts(state, input.p6);
   const initPromise = runInitialPasses({
     state,
     sector,
     scheduler,
     skipAutoSchedule: input.skipInitialAutoSchedule === true,
     now: loadNow ?? void 0
-  }).then(() => refreshUnimportedDataDateDrafts(state, input.p6 ?? void 0));
+  }).then(settleInactiveDrafts);
   return {
     dataDateCapability: dataDate?.capability ?? null,
     sector,