@masterteam/work-center 0.0.81 → 0.0.82

package/fesm2022/masterteam-work-center.mjs

@@ -3142,48 +3142,18 @@ class WorkCenterFormValidationError extends Error {
     }
 }
 
-const FORM_VALIDATION_WARNINGS = 'FormValidationWarnings';
-/** Handles the process action validation handshake owned by Work Center. */
+/**
+ * Renders what a process action's validation has to say, before it runs and
+ * after it fails.
+ *
+ * Actions do not negotiate over warnings. A Work Center action is one HTTP
+ * request: the `process-submit/validate` pre-flight asks about non-blocking
+ * failures up front (`confirmWarnings`), and whatever the action itself answers
+ * is final — a failure is reported, never acknowledged and retried.
+ */
 class WorkCenterActionValidationHandler {
     modal = inject(ModalService);
-    runner = inject(RuntimeActionRunner);
     transloco = inject(TranslocoService);
-    async recover(action, error, submittedPayload, defaultAfterSuccess, 
-    /**
-     * The user already answered this action's warning prompt in the
-     * `process-submit/validate` pre-flight, against the same values. The
-     * backend still raises them, because the first request carried no token —
-     * so complete the handshake silently rather than asking again.
-     */
-    warningsAlreadyAcknowledged = false) {
-        const validationError = readProcessActionValidationError(error);
-        if (validationError?.kind !== FORM_VALIDATION_WARNINGS ||
-            !validationError.requiresAcknowledgement ||
-            !validationError.validationWarningsToken) {
-            return null;
-        }
-        const confirmed = warningsAlreadyAcknowledged ||
-            (await this.confirmWarnings(this.resolveValidationMessages(validationError)));
-        if (!confirmed) {
-            return {
-                status: 'cancelled',
-                actionKey: action.actionKey,
-                afterSuccess: null,
-            };
-        }
-        const retryPayload = {
-            ...(submittedPayload ?? {}),
-            validationWarningsToken: validationError.validationWarningsToken,
-        };
-        // This descriptor is intentionally ephemeral. A later action rebuilds its
-        // payload from the current form and therefore cannot reuse this token.
-        return this.runner.execute({
-            ...action,
-            needConfirmation: false,
-            payloadKeys: Object.keys(retryPayload),
-            payloadTemplate: retryPayload,
-        }, { defaultAfterSuccess, silent: true });
-    }
     /**
      * One entry per failing rule, so the footer can list them instead of
      * rendering one newline-joined blob. A single-entry array is the normal
@@ -3222,8 +3192,10 @@ class WorkCenterActionValidationHandler {
         return messages;
     }
     /**
-     * Shared by the backend-driven acknowledgement handshake above and by the
-     * `process-submit/validate` pre-flight in `WorkCenterActionFormValidator`.
+     * The one place a Work Center action prompts about warnings: the
+     * `process-submit/validate` pre-flight in `WorkCenterActionFormValidator`,
+     * before the action runs. Nothing on the action's own response path opens
+     * this dialog.
      *
      * Uses the client form's own warnings dialog so an approver sees the exact
      * same prompt the normal submit path raises — same layout, same wording
@@ -3271,8 +3243,6 @@ function readProcessActionValidationError(error) {
         : [];
     return {
         kind,
-        requiresAcknowledgement: details?.['requiresAcknowledgement'] === true,
-        validationWarningsToken: readNonEmptyString$1(details?.['validationWarningsToken']),
         message: readNonEmptyString$1(errors?.['message']),
         results,
     };
@@ -3319,10 +3289,7 @@ function readNonEmptyString$1(value) {
     return normalized.length ? normalized : null;
 }
 
-const PROCEED = {
-    status: 'proceed',
-    warningsAcknowledged: false,
-};
+const PROCEED = { status: 'proceed' };
 /** The payload key carrying the edited client-form values. */
 const FORM_VALUES_PAYLOAD_KEY = 'values';
 /**
@@ -3335,9 +3302,9 @@ const FORM_VALUES_PAYLOAD_KEY = 'values';
  * client-form submit ceremony — blocking failures stop the action, warnings
  * raise the acknowledge-and-continue prompt — without submitting anything.
  *
- * It is advisory only. The action endpoint stays authoritative, and the
- * backend-driven `FormValidationWarnings` handshake in
- * `WorkCenterActionValidationHandler` keeps working untouched on top of it.
+ * It is advisory only — the action endpoint stays authoritative — but it is the
+ * single place a Work Center action ever asks about warnings. Nothing is
+ * negotiated afterwards: the action runs once and its answer stands.
  */
 class WorkCenterActionFormValidator {
     api = inject(ClientFormApiService);
@@ -3377,9 +3344,7 @@ class WorkCenterActionFormValidator {
             return PROCEED;
         }
         const confirmed = await this.warnings.confirmWarnings(this.resolveMessages(failures));
-        return confirmed
-            ? { status: 'proceed', warningsAcknowledged: true }
-            : { status: 'cancelled' };
+        return confirmed ? PROCEED : { status: 'cancelled' };
     }
     async runValidation(context, fields) {
         const response = await firstValueFrom(this.api
@@ -3460,12 +3425,19 @@ function readNonEmptyString(value) {
     return normalized.length ? normalized : null;
 }
 
-/** Executes Work Center actions while preserving form payloads for validation retries. */
+/**
+ * Runs a Work Center footer action as **one** HTTP request.
+ *
+ * Everything negotiable happens before that request: the
+ * `process-submit/validate` pre-flight blocks the action or takes the
+ * acknowledgement, then the reason/note dialog collects its fields. Whatever
+ * the action endpoint answers is final — the footer refreshes on success or
+ * lists the failure.
+ */
 class WorkCenterRuntimeActionExecutor {
     runner = inject(RuntimeActionRunner);
     actionContext = inject(RuntimeActionContextStore);
     modal = inject(ModalService);
-    validation = inject(WorkCenterActionValidationHandler);
     formValidation = inject(WorkCenterActionFormValidator);
     confirmDialogClass = inject(RUNTIME_ACTION_CONFIRM_DIALOG, {
         optional: true,
@@ -3490,31 +3462,20 @@ class WorkCenterRuntimeActionExecutor {
                 error: preflight.error,
             };
         }
-        const warningsAcknowledged = preflight.warningsAcknowledged;
         if (action.needConfirmation &&
             hasActionFormFields(action) &&
             this.confirmDialogClass) {
-            return this.executeFormAction(action, defaultAfterSuccess, warningsAcknowledged);
+            return this.executeFormAction(action, defaultAfterSuccess);
         }
-        let submittedPayload;
-        let result = await this.runner.execute(action, {
+        return this.runner.execute(action, {
             defaultAfterSuccess,
             silent: true,
             externalPayloadResolvers: {
                 values: () => this.actionContext.resolveFormValues(),
             },
-            transformPayload: (payload) => {
-                submittedPayload = payload;
-                return payload;
-            },
         });
-        if (result.status === 'error') {
-            result =
-                (await this.validation.recover(action, result.error, submittedPayload, defaultAfterSuccess, warningsAcknowledged)) ?? result;
-        }
-        return result;
     }
-    executeFormAction(action, defaultAfterSuccess, warningsAcknowledged) {
+    executeFormAction(action, defaultAfterSuccess) {
         return new Promise((resolve) => {
             let pendingRun = null;
             let finalResult = null;
@@ -3525,27 +3486,19 @@ class WorkCenterRuntimeActionExecutor {
                 inputValues: {
                     action,
                     onSubmit: async (formValue) => {
-                        const submittedPayload = buildActionPayload(action, formValue, {
+                        const executablePayload = buildActionPayload(action, formValue, {
                             values: () => this.actionContext.resolveFormValues(),
-                        });
-                        const executablePayload = submittedPayload ?? {};
+                        }) ?? {};
                         const executableAction = {
                             ...action,
                             needConfirmation: false,
                             payloadKeys: Object.keys(executablePayload),
                             payloadTemplate: executablePayload,
                         };
-                        pendingRun = (async () => {
-                            let result = await this.runner.execute(executableAction, {
-                                defaultAfterSuccess,
-                                silent: true,
-                            });
-                            if (result.status === 'error') {
-                                result =
-                                    (await this.validation.recover(action, result.error, submittedPayload, defaultAfterSuccess, warningsAcknowledged)) ?? result;
-                            }
-                            return result;
-                        })();
+                        pendingRun = this.runner.execute(executableAction, {
+                            defaultAfterSuccess,
+                            silent: true,
+                        });
                         finalResult = await pendingRun;
                         // Every backend outcome leaves the action dialog. The footer then
                         // refreshes on success or displays the actionable validation error.