@cohesivesystems/presentation-react 0.1.0-alpha.1

package/dist/projected-document-process-preview-action-runtime.js

@@ -0,0 +1,729 @@
+import { useMemo, useState } from 'react';
+import { useProjectedInputFormEndpointRuntime } from './input-form-endpoint-runtime.js';
+import { findPresentationFlow, findPresentationInputFormForView, findPresentationView, } from '@cohesivesystems/presentation-core';
+import { getPresentationViewProjectedActionPlacements, } from '@cohesivesystems/presentation-core';
+import { projectRequiredPresentationActionEndpointRequest, } from '@cohesivesystems/presentation-core';
+import { projectDocumentLocalActionEnablement, } from '@cohesivesystems/presentation-core';
+import { usePresentationActionExecutor, } from './presentation-action-runtime.js';
+import { advancePresentationFlowToStateKind, findPresentationFlowTransition, findPresentationFlowSurfaceState, isPresentationFlowSurfaceOpenForData, resolvePresentationActionPreparedFlow, } from './presentation-flow-runtime.js';
+import { findDocumentProcessPreviewAction, findInputFormActionPlacement, findPromptCommitAction, findPromptDismissAction, } from '@cohesivesystems/presentation-core';
+import { findPromptDocumentPreviewView, projectPromptDocumentPreviewData, } from '@cohesivesystems/presentation-core';
+import {} from '@cohesivesystems/presentation-core';
+import { projectProcessTaskActionEnablement, projectProcessTaskStartRegistration, projectProcessTaskSelector, } from '@cohesivesystems/presentation-core';
+import { flowStateKinds } from '@cohesivesystems/presentation-contracts';
+/**
+ * Generic runtime for document-scoped process-preview flows declared in the
+ * presentation IR.
+ *
+ * It resolves the preview flow, projects the prompt input form, executes the
+ * preview endpoint, manages prompt preview state, and starts the confirmed
+ * process. Product code supplies domain validation and process-result
+ * interpretation.
+ */
+export function useProjectedDocumentProcessPreviewActionRuntime({ actionId: runtimeActionId, actionPlacements, createProcessFlowData = createDefaultProcessFlowData, createProcessTaskStartRegistration, createStartInput, createStartFlowData = createDefaultStartFlowData, dataSourceId, dataSourceQueryKey, defaultValue, executeEndpoint, findActiveTask, flowId: runtimeFlowId, flowRegistry, createHref, inputStateKey, isActionAvailable = true, isPreviewBlocked = false, isStartBlocked = false, localActionEnablement, module, processStartResult, processTaskContext, processTaskSelectors = emptyProcessTaskSelectors, projectPreviewResource, projectPreviewValues, projectProcessTaskSelector: projectTaskSelector = projectProcessTaskSelector, preparePreviewRequest, prepareStartRequest, resource, resourceId, resourceKey, registerProcessTaskStart, unavailableMessage = 'This document does not expose a process preview action.', validatePreviewRequest, validateStartRequest, }) {
+    const [preview, setPreview] = useState(null);
+    const previewAction = useMemo(() => findDocumentProcessPreviewAction({
+        actionId: runtimeActionId,
+        actionPlacements,
+        dataSourceId,
+        flowId: runtimeFlowId,
+        module,
+    }), [actionPlacements, dataSourceId, module, runtimeActionId, runtimeFlowId]);
+    const actionFlow = useMemo(() => resolvePresentationActionPreparedFlow(previewAction), [previewAction]);
+    const flowId = runtimeFlowId ?? actionFlow?.flowId ?? '';
+    const flow = useMemo(() => findPresentationFlow(module, flowId), [flowId, module]);
+    const promptView = useMemo(() => {
+        const promptViewId = actionFlow?.promptViewId ??
+            findPresentationFlowSurfaceState(flow)?.ViewId;
+        return promptViewId
+            ? findPresentationView(module, promptViewId)
+            : null;
+    }, [actionFlow?.promptViewId, flow, module]);
+    const diagnosticActionPlacements = useMemo(() => getPresentationViewProjectedActionPlacements(promptView), [promptView]);
+    const inputForm = useMemo(() => findPresentationInputFormForView(module, promptView), [module, promptView]);
+    const previewDefinition = useMemo(() => findPromptDocumentPreviewView(module, promptView)?.PromptDocumentPreview ?? null, [module, promptView]);
+    const startAction = useMemo(() => findPromptCommitAction({ module, view: promptView }), [module, promptView]);
+    const dismissAction = useMemo(() => findPromptDismissAction({ module, view: promptView }), [module, promptView]);
+    const inputFormActionPlacement = useMemo(() => findInputFormActionPlacement(inputForm, previewAction), [inputForm, previewAction]);
+    const flowRuntime = flowRegistry.getRuntime(flowId);
+    const activePreview = resourceKey !== null && preview?.resourceKey === resourceKey
+        ? preview
+        : null;
+    const isPromptOpen = isPresentationFlowSurfaceOpenForData({
+        dataKey: 'resourceKey',
+        dataValue: resourceKey,
+        flowId,
+        runtime: flowRuntime,
+    });
+    const previewActionId = optionalActionId(previewAction, 'document-process-preview');
+    const startActionId = optionalActionId(startAction, 'document-process-start');
+    const dismissActionId = optionalActionId(dismissAction, 'document-process-dismiss');
+    const hasAction = Boolean(previewAction);
+    const processTaskActionEnablement = projectProcessTaskActionEnablement({
+        action: previewAction,
+        context: processTaskContext ?? {
+            resource,
+            resourceId,
+            route: { id: resourceId },
+        },
+        findActiveTask: findActiveTask ?? noActiveProcessTask,
+        projectSelector: projectTaskSelector,
+        selectors: processTaskSelectors,
+    });
+    const previewActionEnablement = projectDocumentLocalActionEnablement({
+        action: previewAction,
+        context: localActionEnablement,
+    });
+    const startActionEnablement = projectDocumentLocalActionEnablement({
+        action: startAction,
+        context: localActionEnablement,
+    });
+    const processStart = usePresentationActionExecutor({
+        actionId: startActionId,
+        dataSourceId,
+        dataSourceQueryKey,
+        executeEndpoint,
+        module,
+        prepareRequest: ({ action, actionId, endpointId, input, module: requestModule }) => {
+            if (!hasAction || !isActionAvailable || !resource) {
+                throw new Error(unavailableMessage);
+            }
+            if (startActionEnablement.isDisabled) {
+                throw new Error(startActionEnablement.message ?? unavailableMessage);
+            }
+            validateStartRequest?.();
+            return prepareStartRequest?.({
+                action,
+                actionId,
+                dataSourceId,
+                endpointId,
+                input,
+                module: requestModule,
+                resource,
+                resourceId,
+            }) ?? projectRequiredPresentationActionEndpointRequest({
+                action,
+                actionId,
+                dataSourceId,
+                endpointId,
+                sources: {
+                    input,
+                    resource,
+                    route: { id: resourceId },
+                },
+            });
+        },
+        processResult: (context) => {
+            const successContext = {
+                ...context,
+                preview: activePreview,
+            };
+            const registration = createProcessTaskStartRegistration?.({
+                ...successContext,
+                actionEnablement: processTaskActionEnablement,
+                selector: processTaskActionEnablement.selector,
+            }) ?? projectProcessTaskStartRegistration({
+                action: context.action,
+                context: {
+                    input: context.input,
+                    resource,
+                    resourceId,
+                    result: context.result,
+                    route: { id: resourceId },
+                },
+                createHref,
+                dataSourceQueryKey,
+                result: context.result,
+                selector: processTaskActionEnablement.selector,
+            });
+            if (registration) {
+                registerProcessTaskStart?.(registration);
+            }
+            processStartResult?.(successContext);
+            advancePresentationFlowToStateKind({
+                allowStateFallback: false,
+                data: createProcessFlowData(successContext),
+                flow,
+                runtime: flowRuntime,
+                stateKinds: [flowStateKinds.process],
+            });
+        },
+        onSuccess: () => {
+            setPreview(null);
+        },
+    });
+    const previewEndpoint = useProjectedInputFormEndpointRuntime({
+        dataSourceId,
+        defaultValue,
+        defaultValueSources: {
+            resource,
+            route: { id: resourceId },
+        },
+        executeEndpoint,
+        inputForm,
+        invalidateDataSourceIds: [],
+        module,
+        prepareRequest: (context) => {
+            if (!hasAction || !isActionAvailable || !resource || !resourceKey) {
+                throw new Error(unavailableMessage);
+            }
+            if (previewActionEnablement.isDisabled) {
+                throw new Error(previewActionEnablement.message ?? unavailableMessage);
+            }
+            validatePreviewRequest?.();
+            return preparePreviewRequest?.({
+                action: context.action,
+                actionContext: context.actionContext,
+                actionId: previewActionId,
+                dataSourceId,
+                endpointId: context.endpointId,
+                inputForm: context.inputForm,
+                module: context.module,
+                resource,
+                resourceId,
+                resourceKey,
+                value: context.value,
+            }) ?? projectRequiredPresentationActionEndpointRequest({
+                action: context.action,
+                actionId: previewActionId,
+                dataSourceId,
+                endpointId: context.endpointId,
+                sources: {
+                    input: context.value,
+                    resource,
+                    route: { id: resourceId },
+                },
+            });
+        },
+        onSuccess: ({ result, value }) => {
+            if (!resource || !resourceKey) {
+                return;
+            }
+            const projectedPreview = projectPromptDocumentPreviewData({
+                definition: previewDefinition,
+                request: value,
+                resource: projectPreviewResource?.({
+                    request: value,
+                    resource,
+                    resourceKey,
+                    response: result,
+                }) ?? undefined,
+                response: result,
+                values: {
+                    ...(projectPreviewValues?.({
+                        request: value,
+                        resource,
+                        resourceKey,
+                        response: result,
+                    }) ?? {}),
+                    resourceKey,
+                },
+            });
+            advancePresentationFlowToStateKind({
+                allowStateFallback: false,
+                data: projectedPreview,
+                flow,
+                runtime: flowRuntime,
+                stateKinds: [flowStateKinds.prompt],
+            });
+            setPreview(projectedPreview);
+        },
+        stateKey: inputStateKey ?? null,
+    });
+    const canStartPreviewTransition = Boolean(resourceKey &&
+        canStartFlowAction({
+            action: previewAction,
+            actionId: previewActionId,
+            data: { resourceKey },
+            flow,
+        }));
+    const previewDisabledReason = resolveProcessPreviewDisabledReason({
+        canStartPreviewTransition,
+        flow,
+        inputForm,
+        inputFormActionPlacement,
+        isActionAvailable,
+        previewAction,
+        previewActionEnablement,
+        previewDefinition,
+        previewEndpointId: previewEndpoint.endpointId,
+        processStartEndpointId: processStart.endpointId,
+        processTaskActionEnablement,
+        promptView,
+        resourceKey,
+    });
+    const activePreviewStartFlowData = activePreview
+        ? createStartFlowData(activePreview)
+        : null;
+    const canDispatchStartTransition = Boolean(activePreviewStartFlowData &&
+        canDispatchFlowAction({
+            action: startAction,
+            actionId: startActionId,
+            data: activePreviewStartFlowData,
+            flow,
+            runtime: flowRuntime,
+        }));
+    const startDisabledReason = resolveProcessStartDisabledReason({
+        activePreview,
+        canDispatchStartTransition,
+        isStartBlocked,
+        processStartEndpointId: processStart.endpointId,
+        processTaskActionEnablement,
+        startAction,
+        startActionEnablement,
+    });
+    const diagnostics = projectProcessPreviewRuntimeDiagnostics({
+        actionId: runtimeActionId,
+        dismissAction,
+        flow,
+        flowId,
+        inputForm,
+        inputFormActionPlacement,
+        previewAction,
+        previewDefinition,
+        previewEndpointId: previewEndpoint.endpointId,
+        promptView,
+        source: 'document-process-preview-action-runtime',
+        startAction,
+        startEndpointId: processStart.endpointId,
+    });
+    const canExecuteAction = previewDisabledReason === null;
+    const canAcceptPreview = Boolean(activePreview && startDisabledReason === null);
+    const inputRuntime = previewEndpoint.runtime
+        ? {
+            invokeAction: requestPreview,
+            setValue: previewEndpoint.runtime.setValue,
+            value: previewEndpoint.runtime.value,
+        }
+        : null;
+    function reset() {
+        processStart.reset();
+        previewEndpoint.reset();
+        flowRuntime.clearFlow();
+        setPreview(null);
+    }
+    function requestPreview(actionContext) {
+        if (!hasAction ||
+            !isActionAvailable ||
+            !canExecuteAction ||
+            !resource ||
+            !resourceKey ||
+            isPreviewBlocked ||
+            previewEndpoint.isPending ||
+            processStart.isPending) {
+            return;
+        }
+        processStart.reset();
+        previewEndpoint.resetExecution();
+        setPreview(null);
+        const started = flowRuntime.startFlow({
+            actionId: previewActionId,
+            data: { resourceKey },
+            flowId,
+        });
+        if (!started) {
+            return;
+        }
+        requestInputFormPreview(actionContext);
+    }
+    function cancelPrompt() {
+        previewEndpoint.reset();
+        if (!flowRuntime.dispatchAction(dismissActionId)) {
+            flowRuntime.clearFlow();
+            return;
+        }
+        flowRuntime.clearFlow();
+    }
+    function cancelPreview() {
+        processStart.reset();
+        if (!flowRuntime.dispatchAction(dismissActionId)) {
+            flowRuntime.clearFlow();
+            setPreview(null);
+            return;
+        }
+        flowRuntime.clearFlow();
+        setPreview(null);
+    }
+    function acceptPreview() {
+        if (processStart.isPending || !canAcceptPreview || !activePreview) {
+            return;
+        }
+        const startFlowData = createStartFlowData(activePreview);
+        if (!flowRuntime.dispatchAction(startActionId, { data: startFlowData })) {
+            return;
+        }
+        processStart.execute(createStartInput?.(activePreview) ??
+            projectDefaultProcessStartInput(activePreview));
+    }
+    function requestInputFormPreview(actionContext) {
+        if (!inputForm || !previewEndpoint.runtime) {
+            return;
+        }
+        if (!inputFormActionPlacement) {
+            return;
+        }
+        previewEndpoint.runtime.invokeAction(actionContext ?? {
+            action: previewAction,
+            choiceValuesByFieldId: Object.fromEntries(inputForm.Fields.map((field) => [field.Id, []])),
+            inputForm,
+            placement: inputFormActionPlacement,
+            target: {
+                stateId: inputForm.SharedStateId ??
+                    inputForm.Target.Id ??
+                    inputForm.StateDataSourceId,
+            },
+            value: previewEndpoint.value,
+        });
+    }
+    return {
+        actions: {
+            dismiss: dismissAction,
+            preview: previewAction,
+            start: processStart.action,
+        },
+        actionEnablement: {
+            preview: previewActionEnablement,
+            start: startActionEnablement,
+        },
+        actionIds: {
+            dismiss: dismissActionId,
+            preview: previewActionId,
+            start: startActionId,
+        },
+        acceptPreview,
+        activePreview,
+        canAcceptPreview,
+        canExecuteAction,
+        cancelPreview,
+        cancelPrompt,
+        diagnosticActionPlacements,
+        diagnostics,
+        disabledReasons: {
+            preview: previewDisabledReason,
+            start: startDisabledReason,
+        },
+        flow,
+        flowId,
+        flowRuntime,
+        hasAction,
+        input: {
+            form: inputForm,
+            runtime: inputRuntime,
+        },
+        isPromptOpen,
+        preview: {
+            endpointId: previewEndpoint.endpointId,
+            error: previewEndpoint.error,
+            isPending: previewEndpoint.isPending,
+            reset: previewEndpoint.reset,
+            resetExecution: previewEndpoint.resetExecution,
+        },
+        processTask: processTaskActionEnablement,
+        promptView,
+        requestPreview,
+        reset,
+        start: {
+            action: processStart.action,
+            endpointId: processStart.endpointId,
+            error: processStart.error,
+            isPending: processStart.isPending,
+            reset: processStart.reset,
+        },
+    };
+}
+function createDefaultStartFlowData(preview) {
+    return {
+        request: preview.request,
+        resourceKey: preview.resourceKey,
+        ...readRecord(preview.response),
+    };
+}
+function createDefaultProcessFlowData(context) {
+    return readRecord(context.result) ?? { result: context.result };
+}
+function readRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function projectDefaultProcessStartInput(preview) {
+    const response = readRecord(preview.response);
+    const startRequest = readCaseInsensitiveField(response, 'StartRequest') ??
+        readCaseInsensitiveField(response, 'Request');
+    return (startRequest ?? preview.request);
+}
+function readCaseInsensitiveField(record, field) {
+    if (!record) {
+        return undefined;
+    }
+    if (Object.prototype.hasOwnProperty.call(record, field)) {
+        return record[field];
+    }
+    const match = Object.keys(record).find((candidate) => candidate.toLowerCase() === field.toLowerCase());
+    return match ? record[match] : undefined;
+}
+function optionalActionId(action, fallback) {
+    return action?.Id ?? `missing:${fallback}`;
+}
+const emptyProcessTaskSelectors = [];
+function noActiveProcessTask() {
+    return null;
+}
+function resolveProcessPreviewDisabledReason({ canStartPreviewTransition, flow, inputForm, inputFormActionPlacement, isActionAvailable, previewAction, previewActionEnablement, previewDefinition, previewEndpointId, processStartEndpointId, processTaskActionEnablement, promptView, resourceKey, }) {
+    if (!previewAction || !isActionAvailable) {
+        return 'This document does not expose a process preview action.';
+    }
+    if (!flow) {
+        return `Action '${previewAction.Name}' does not resolve a preview flow.`;
+    }
+    if (!promptView) {
+        return `Preview flow '${flow.Name}' does not resolve a prompt view.`;
+    }
+    if (!inputForm) {
+        return `Prompt view '${promptView.Name}' does not resolve an input form.`;
+    }
+    if (!inputFormActionPlacement) {
+        return `Input form '${inputForm.Name}' does not place the preview action.`;
+    }
+    if (!previewDefinition) {
+        return `Prompt view '${promptView.Name}' does not declare a document preview surface.`;
+    }
+    if (!previewEndpointId) {
+        return `No preview endpoint is bound for action '${previewAction.Name}'.`;
+    }
+    if (!processStartEndpointId) {
+        return 'No process start endpoint is bound for the preview confirmation action.';
+    }
+    if (!resourceKey) {
+        return 'A loaded resource is required before previewing this process.';
+    }
+    if (!canStartPreviewTransition) {
+        return `Preview flow '${flow.Name}' cannot start from its initial state.`;
+    }
+    if (previewActionEnablement.isDisabled) {
+        return previewActionEnablement.message;
+    }
+    if (processTaskActionEnablement.isDisabled) {
+        return processTaskActionEnablement.message;
+    }
+    return null;
+}
+function resolveProcessStartDisabledReason({ activePreview, canDispatchStartTransition, isStartBlocked, processStartEndpointId, processTaskActionEnablement, startAction, startActionEnablement, }) {
+    if (!activePreview) {
+        return 'A preview is required before starting this process.';
+    }
+    if (!startAction) {
+        return 'The preview prompt does not declare a process start action.';
+    }
+    if (!processStartEndpointId) {
+        return `No process start endpoint is bound for action '${startAction.Name}'.`;
+    }
+    if (!canDispatchStartTransition) {
+        return 'The preview flow is not in a startable state.';
+    }
+    if (startActionEnablement.isDisabled) {
+        return startActionEnablement.message;
+    }
+    if (processTaskActionEnablement.isDisabled) {
+        return processTaskActionEnablement.message;
+    }
+    if (isStartBlocked) {
+        return 'Starting this process is currently blocked.';
+    }
+    return null;
+}
+function canDispatchFlowAction({ action, actionId, data, flow, runtime, }) {
+    const instance = runtime.activeInstance;
+    if (!flow || !instance || instance.flowId !== flow.Id) {
+        return false;
+    }
+    return Boolean(findPresentationFlowTransition({
+        actionId,
+        data: {
+            ...instance.data,
+            ...data,
+        },
+        event: action?.Binding.Id ?? actionId,
+        flow,
+        fromStateId: instance.stateId,
+    }));
+}
+function canStartFlowAction({ action, actionId, data, flow, }) {
+    if (!flow) {
+        return false;
+    }
+    return Boolean(findPresentationFlowTransition({
+        actionId,
+        data,
+        event: action?.Binding.Id ?? actionId,
+        flow,
+        fromStateId: flow.InitialStateId,
+    }));
+}
+function projectProcessPreviewRuntimeDiagnostics({ actionId, dismissAction, flow, flowId, inputForm, inputFormActionPlacement, previewAction, previewDefinition, previewEndpointId, promptView, source, startAction, startEndpointId, }) {
+    if (!actionId && !previewAction) {
+        return [];
+    }
+    return [
+        ...diagnoseProcessPreviewAction({ actionId, previewAction, source }),
+        ...diagnoseProcessPreviewFlow({
+            flow,
+            flowId,
+            inputForm,
+            inputFormActionPlacement,
+            previewAction,
+            previewDefinition,
+            previewEndpointId,
+            promptView,
+            source,
+            startAction,
+            startEndpointId,
+        }),
+        ...diagnoseProcessPreviewDismissAction({
+            dismissAction,
+            promptView,
+            source,
+        }),
+    ];
+}
+function diagnoseProcessPreviewAction({ actionId, previewAction, source, }) {
+    if (!actionId || previewAction) {
+        return [];
+    }
+    return [
+        createProcessPreviewRuntimeDiagnostic({
+            details: { actionId },
+            id: `process-preview.${actionId}.missing-action`,
+            message: `Document action runtime profile references process preview action '${actionId}', ` +
+                'but the action is not placed or cannot be interpreted as a document process preview.',
+            severity: 'error',
+            source,
+            subject: {
+                id: actionId,
+                kind: 'action',
+            },
+        }),
+    ];
+}
+function diagnoseProcessPreviewFlow({ flow, flowId, inputForm, inputFormActionPlacement, previewAction, previewDefinition, previewEndpointId, promptView, source, startAction, startEndpointId, }) {
+    if (!previewAction) {
+        return [];
+    }
+    const diagnostics = [];
+    if (!flow) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: previewAction.Id, flowId },
+            id: `process-preview.${previewAction.Id}.missing-flow`,
+            message: `Process preview action '${previewAction.Name}' references flow '${flowId}', ` +
+                'but that flow is not present in the presentation module.',
+            severity: 'error',
+            source,
+            subject: { id: previewAction.Id, kind: 'action', name: previewAction.Name },
+        }));
+        return diagnostics;
+    }
+    if (!promptView) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: previewAction.Id, flowId: flow.Id },
+            id: `process-preview.${previewAction.Id}.missing-prompt-view`,
+            message: `Process preview flow '${flow.Name}' does not resolve a prompt view for ` +
+                `action '${previewAction.Name}'.`,
+            severity: 'error',
+            source,
+            subject: { id: flow.Id, kind: 'flow', name: flow.Name },
+        }));
+    }
+    if (!inputForm) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: previewAction.Id, flowId: flow.Id, viewId: promptView?.Id },
+            id: `process-preview.${previewAction.Id}.missing-input-form`,
+            message: `Process preview prompt '${promptView?.Name ?? flow.Name}' does not resolve ` +
+                'an input form.',
+            severity: 'error',
+            source,
+            subject: { id: promptView?.Id ?? flow.Id, kind: promptView ? 'view' : 'flow' },
+        }));
+    }
+    if (inputForm && !inputFormActionPlacement) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: previewAction.Id, inputFormId: inputForm.Id },
+            id: `process-preview.${previewAction.Id}.missing-input-form-action`,
+            message: `Input form '${inputForm.Name}' does not place process preview action ` +
+                `'${previewAction.Name}'.`,
+            severity: 'error',
+            source,
+            subject: { id: inputForm.Id, kind: 'input-form', name: inputForm.Name },
+        }));
+    }
+    if (!previewDefinition) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: previewAction.Id, flowId: flow.Id, viewId: promptView?.Id },
+            id: `process-preview.${previewAction.Id}.missing-preview-surface`,
+            message: `Process preview prompt '${promptView?.Name ?? flow.Name}' does not declare ` +
+                'a document preview surface.',
+            severity: 'error',
+            source,
+            subject: { id: promptView?.Id ?? flow.Id, kind: promptView ? 'view' : 'flow' },
+        }));
+    }
+    if (!previewEndpointId) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: previewAction.Id, inputFormId: inputForm?.Id },
+            id: `process-preview.${previewAction.Id}.missing-preview-endpoint`,
+            message: `No endpoint binding is registered for process preview action ` +
+                `'${previewAction.Name}'.`,
+            severity: 'error',
+            source,
+            subject: { id: previewAction.Id, kind: 'action', name: previewAction.Name },
+        }));
+    }
+    if (!startAction) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: previewAction.Id, flowId: flow.Id, viewId: promptView?.Id },
+            id: `process-preview.${previewAction.Id}.missing-start-action`,
+            message: `Process preview prompt '${promptView?.Name ?? flow.Name}' does not declare ` +
+                'a process start action.',
+            severity: 'error',
+            source,
+            subject: { id: promptView?.Id ?? flow.Id, kind: promptView ? 'view' : 'flow' },
+        }));
+    }
+    else if (!startEndpointId) {
+        diagnostics.push(createProcessPreviewRuntimeDiagnostic({
+            details: { actionId: startAction.Id, flowId: flow.Id },
+            id: `process-preview.${startAction.Id}.missing-start-endpoint`,
+            message: `No endpoint binding is registered for process start action ` +
+                `'${startAction.Name}'.`,
+            severity: 'error',
+            source,
+            subject: { id: startAction.Id, kind: 'action', name: startAction.Name },
+        }));
+    }
+    return diagnostics;
+}
+function diagnoseProcessPreviewDismissAction({ dismissAction, promptView, source, }) {
+    if (!promptView || dismissAction) {
+        return [];
+    }
+    return [
+        createProcessPreviewRuntimeDiagnostic({
+            details: { viewId: promptView.Id },
+            id: `process-preview.${promptView.Id}.missing-dismiss-action`,
+            message: `Process preview prompt '${promptView.Name}' does not declare a dismiss action.`,
+            severity: 'warning',
+            source,
+            subject: { id: promptView.Id, kind: 'view', name: promptView.Name },
+        }),
+    ];
+}
+function createProcessPreviewRuntimeDiagnostic({ details, id, message, severity, source, subject, }) {
+    return {
+        details,
+        id,
+        message,
+        severity,
+        source,
+        subject,
+    };
+}
+//# sourceMappingURL=projected-document-process-preview-action-runtime.js.map