@acorex/platform 21.0.0-next.64 → 21.0.0-next.67

package/fesm2022/acorex-platform-workflow.mjs

@@ -1303,6 +1303,80 @@ function isWorkflowContinuationSuppressed(userInput) {
 }
 //#endregion
 
+//#region ----   Inline frontend classification   ----
+/**
+ * Frontend step executed inline (dialog/popup), not suspended on the task board.
+ * Derived from execution mode and task-board activity types — no per-activity hardcoding.
+ */
+function axpIsWorkflowInlineFrontendTask(task) {
+    if (!task) {
+        return false;
+    }
+    if (axpIsWorkflowTaskBoardActivityType(task.activityType)) {
+        return false;
+    }
+    return task.executionMode === 'frontend' || task.executionMode === 'both';
+}
+/** @deprecated Use {@link axpIsWorkflowInlineFrontendTask}. */
+function axpIsWorkflowInteractiveFrontendTask(task) {
+    return axpIsWorkflowInlineFrontendTask(task);
+}
+//#endregion
+//#region ----   Continuation metadata on tasks   ----
+/** Resolved before-interactive behavior from task metadata (set by engine from activity definition). */
+function axpResolveWorkflowContinuationBeforeInteractive(task) {
+    return task?.continuation?.beforeInteractive ?? 'default';
+}
+/**
+ * Whether to skip the pre-interactive "continue?" prompt based on activity metadata.
+ * Assignee-specific rules are applied in workflow-management (needs session).
+ */
+function axpShouldSkipBeforeInteractiveFromMetadata(behavior, completedWasHumanTask) {
+    return behavior === 'skip-when-chained-from-human-task' && completedWasHumanTask;
+}
+/**
+ * Whether to show a "continue?" prompt before running inline frontend activities.
+ * Skips when the user already resumed a task-board step (primary action / resume).
+ */
+function axpShouldOfferBeforeInteractiveFlow(context) {
+    return !context.completedActivityId;
+}
+//#endregion
+//#region ----   Step advancement gate   ----
+/** Resume outcomes that do not advance the workflow graph (draft save, cancel, loop back). */
+const NON_ADVANCING_RESUME_OUTCOMES = new Set(['saved', 'cancelled', 'cancel', 'save', 'draft']);
+/**
+ * Whether the workflow advanced enough to consider a continuation prompt.
+ * Includes pending interactive steps when inbox bookmarks are already consumed.
+ */
+function axpShouldOfferWorkflowContinuationAfterStep(context, activeBookmarkActivityIds) {
+    const outcome = context.resumeOutcome?.trim().toLowerCase();
+    if (outcome && NON_ADVANCING_RESUME_OUTCOMES.has(outcome)) {
+        return false;
+    }
+    const pendingActivityId = context.pendingNextTask?.activityId;
+    const completedActivityId = context.completedActivityId;
+    if (pendingActivityId && completedActivityId && pendingActivityId === completedActivityId) {
+        return false;
+    }
+    if (activeBookmarkActivityIds.length === 0) {
+        const pending = context.pendingNextTask;
+        if (completedActivityId && pending && pending.activityId !== completedActivityId) {
+            if (axpIsWorkflowInlineFrontendTask(pending) ||
+                axpIsWorkflowTaskBoardActivityType(pending.activityType)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** No continuation on bare workflow start (bookmarks exist before any step completes). */
+    if (!completedActivityId) {
+        return false;
+    }
+    return activeBookmarkActivityIds.some((id) => id !== completedActivityId);
+}
+//#endregion
+
 //#endregion
 /**
  * Workflow Manager - Facade for workflow lifecycle orchestration.
@@ -1412,9 +1486,22 @@ class AXPWorkflowManager {
                 const nextInteractive = (completeResponse.nextTask.executionMode === 'frontend' || completeResponse.nextTask.executionMode === 'both') &&
                     !axpIsWorkflowTaskBoardActivityType(completeResponse.nextTask.activityType);
                 if (!nextInteractive) {
+                    const humanTaskNext = completeResponse.nextTask;
+                    let boundaryContinuationOffer;
+                    if (humanTaskNext &&
+                        axpIsWorkflowTaskBoardActivityType(humanTaskNext.activityType)) {
+                        boundaryContinuationOffer =
+                            (await this.continuationHook?.offerAfterWorkflowStep?.({
+                                instanceId,
+                                completedActivityId: currentTask.activityId,
+                                resumeOutcome: execResult.outcome,
+                                pendingNextTask: humanTaskNext,
+                            })) ?? 'not-offered';
+                    }
                     return {
-                        nextTask: completeResponse.nextTask,
+                        nextTask: humanTaskNext,
                         state: currentState,
+                        boundaryContinuationOffer,
                     };
                 }
                 // Continue with next interactive frontend task
@@ -1437,6 +1524,69 @@ class AXPWorkflowManager {
             state: currentState,
         };
     }
+    /**
+     * Runs inline interactive activities when allowed, with an optional pre-flow continuation prompt.
+     */
+    async runInteractiveFlowWithContinuation(instanceId, pendingTask, state, continuationContext, suppressContinuation, activityOutputs) {
+        let continuationOffer = 'not-offered';
+        if (!suppressContinuation &&
+            axpShouldOfferBeforeInteractiveFlow(continuationContext) &&
+            axpIsWorkflowInlineFrontendTask(pendingTask) &&
+            this.continuationHook?.offerBeforeInteractiveFlow) {
+            continuationOffer =
+                (await this.continuationHook.offerBeforeInteractiveFlow({
+                    ...continuationContext,
+                    instanceId,
+                    pendingNextTask: pendingTask,
+                })) ?? 'not-offered';
+            if (continuationOffer === 'declined') {
+                await this.revertResumeAfterDeclinedInteractiveContinuation(instanceId, continuationContext, pendingTask);
+                const revertedState = this.stateCache.get(instanceId) ?? state;
+                return { nextTask: null, state: revertedState, continuationOffer };
+            }
+        }
+        const interactiveResult = await this.executeInteractiveFlow(instanceId, pendingTask, state, activityOutputs);
+        const boundaryOffer = interactiveResult.boundaryContinuationOffer;
+        if (boundaryOffer && boundaryOffer !== 'not-offered') {
+            continuationOffer = boundaryOffer;
+        }
+        return { ...interactiveResult, continuationOffer };
+    }
+    async invokeWorkflowContinuationAfterStep(context, priorOffer, suppressContinuation = false) {
+        if (suppressContinuation || priorOffer === 'declined') {
+            return;
+        }
+        if (priorOffer && priorOffer !== 'not-offered') {
+            return;
+        }
+        await this.continuationHook?.offerAfterWorkflowStep?.(context);
+    }
+    /**
+     * Restores the suspended task-board step when the user declines a pre-interactive continuation prompt.
+     */
+    async revertResumeAfterDeclinedInteractiveContinuation(instanceId, context, abortedTask) {
+        const suspendedStepId = context.completedActivityId;
+        if (!suspendedStepId) {
+            return;
+        }
+        const revert = this.workflowEngine.revertResumeAfterDeclinedInteractiveContinuation?.bind(this.workflowEngine);
+        if (!revert) {
+            return;
+        }
+        const result = await revert({
+            instanceId,
+            suspendedStepId,
+            abortedStepId: abortedTask.activityId,
+            bookmarkId: context.completedBookmarkId,
+        });
+        if (result.success && result.state) {
+            let normalizedState = { ...result.state };
+            if (normalizedState.lastUpdated && !(normalizedState.lastUpdated instanceof Date)) {
+                normalizedState.lastUpdated = new Date(normalizedState.lastUpdated);
+            }
+            this.stateCache.set(instanceId, normalizedState);
+        }
+    }
     /**
      * Start a new workflow instance.
      *
@@ -1479,31 +1629,23 @@ class AXPWorkflowManager {
             if (pendingTask &&
                 (pendingTask.executionMode === 'frontend' || pendingTask.executionMode === 'both') &&
                 !axpIsWorkflowTaskBoardActivityType(pendingTask.activityType)) {
-                const interactiveResult = await this.executeInteractiveFlow(response.instanceId, pendingTask, startNormalizedState, response.activityOutputs || response.state.activityOutputs);
+                const interactiveResult = await this.runInteractiveFlowWithContinuation(response.instanceId, pendingTask, startNormalizedState, { instanceId: response.instanceId, pendingNextTask: pendingTask }, isWorkflowContinuationSuppressed(input), (response.activityOutputs ?? response.state.activityOutputs));
                 finalNextTask = interactiveResult.nextTask;
                 startNormalizedState = interactiveResult.state;
-                if (interactiveResult.output !== undefined) {
+                if (interactiveResult.output != null) {
                     finalOutput = interactiveResult.output;
                 }
-                // Update cache with final state
                 this.stateCache.set(response.instanceId, startNormalizedState);
             }
             // If backend returned null or non-executable task, return it as-is
             // Backend already decided workflow status (suspended, completed, etc.)
-            const startResult = {
+            return {
                 success: true,
                 instanceId: response.instanceId,
                 state: startNormalizedState,
                 nextTask: finalNextTask,
                 output: finalOutput,
             };
-            if (!isWorkflowContinuationSuppressed(input)) {
-                await this.continuationHook?.offerAfterWorkflowStep?.({
-                    instanceId: response.instanceId,
-                    pendingNextTask: finalNextTask,
-                });
-            }
-            return startResult;
         }
         catch (error) {
             console.error('[AXPWorkflowManager] ❌ Error starting workflow:', error);
@@ -1552,16 +1694,26 @@ class AXPWorkflowManager {
             let finalNextTask = response.nextTask || null;
             let finalOutput = response.output;
             const nextTask = response.nextTask;
+            let resumeContinuationOffer;
             if (nextTask &&
                 (nextTask.executionMode === 'frontend' || nextTask.executionMode === 'both') &&
                 !axpIsWorkflowTaskBoardActivityType(nextTask.activityType)) {
-                const interactiveResult = await this.executeInteractiveFlow(instanceId, nextTask, normalizedState, normalizedState?.activityOutputs);
+                const completedBookmarkId = typeof userInput === 'object' && userInput != null && 'bookmarkId' in userInput
+                    ? String(userInput.bookmarkId ?? '')
+                    : undefined;
+                const interactiveResult = await this.runInteractiveFlowWithContinuation(instanceId, nextTask, normalizedState, {
+                    instanceId,
+                    completedActivityId: stepId,
+                    completedBookmarkId: completedBookmarkId || undefined,
+                    resumeOutcome: outcome,
+                    pendingNextTask: nextTask,
+                }, isWorkflowContinuationSuppressed(userInput), normalizedState?.activityOutputs);
                 finalNextTask = interactiveResult.nextTask;
                 normalizedState = interactiveResult.state;
-                if (interactiveResult.output !== undefined) {
+                resumeContinuationOffer = interactiveResult.continuationOffer;
+                if (interactiveResult.output != null) {
                     finalOutput = interactiveResult.output;
                 }
-                // Update cache with final state
                 this.stateCache.set(instanceId, normalizedState);
             }
             // If backend returned null or non-executable task, return it as-is
@@ -1573,18 +1725,16 @@ class AXPWorkflowManager {
                 nextTask: finalNextTask,
                 output: finalOutput,
             };
-            const completedBookmarkId = typeof userInput === 'object' && userInput != null && 'bookmarkId' in userInput
+            const completedBookmarkIdForContinuation = typeof userInput === 'object' && userInput != null && 'bookmarkId' in userInput
                 ? String(userInput.bookmarkId ?? '')
                 : undefined;
-            if (!isWorkflowContinuationSuppressed(userInput)) {
-                await this.continuationHook?.offerAfterWorkflowStep?.({
-                    instanceId,
-                    completedActivityId: stepId,
-                    completedBookmarkId: completedBookmarkId || undefined,
-                    resumeOutcome: outcome,
-                    pendingNextTask: finalNextTask,
-                });
-            }
+            await this.invokeWorkflowContinuationAfterStep({
+                instanceId,
+                completedActivityId: stepId,
+                completedBookmarkId: completedBookmarkIdForContinuation || undefined,
+                resumeOutcome: outcome,
+                pendingNextTask: finalNextTask,
+            }, resumeContinuationOffer, isWorkflowContinuationSuppressed(userInput));
             return resumeResult;
         }
         catch (error) {
@@ -2671,5 +2821,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowEngineError, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_ERROR_CODES, AXP_WORKFLOW_PROVIDER, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES, ActivityExecutor, WorkflowExpressionScopeService, axpIsWorkflowTaskBoardActivityType, createWorkFlowEvent, getWorkflowEngineErrorCode, getWorkflowEngineErrorInfo, isWorkflowContinuationSuppressed, ofType };
+export { AXPActivityDefinitionService, AXPWorkflowAction, AXPWorkflowContext, AXPWorkflowDefinitionService, AXPWorkflowEngineError, AXPWorkflowError, AXPWorkflowEventService, AXPWorkflowFunction, AXPWorkflowLocalEngine, AXPWorkflowManager, AXPWorkflowModule, AXPWorkflowRegistryService, AXPWorkflowService, AXP_ACTIVITY_CATEGORY_PROVIDER, AXP_ACTIVITY_PROVIDER, AXP_WORKFLOW_CATEGORY_PROVIDER, AXP_WORKFLOW_CONTINUATION_HOOK, AXP_WORKFLOW_ENGINE, AXP_WORKFLOW_ERROR_CODES, AXP_WORKFLOW_PROVIDER, AXP_WORKFLOW_SUPPRESS_CONTINUATION_INPUT_KEY, AXP_WORKFLOW_TASK_BOARD_ACTIVITY_TYPES, ActivityExecutor, WorkflowExpressionScopeService, axpIsWorkflowInlineFrontendTask, axpIsWorkflowInteractiveFrontendTask, axpIsWorkflowTaskBoardActivityType, axpResolveWorkflowContinuationBeforeInteractive, axpShouldOfferBeforeInteractiveFlow, axpShouldOfferWorkflowContinuationAfterStep, axpShouldSkipBeforeInteractiveFromMetadata, createWorkFlowEvent, getWorkflowEngineErrorCode, getWorkflowEngineErrorInfo, isWorkflowContinuationSuppressed, ofType };
 //# sourceMappingURL=acorex-platform-workflow.mjs.map