@wise/dynamic-flow-client 5.9.1 → 5.9.2-logging-bf0bd22

package/build/controller/FlowController.js

@@ -1,368 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { createRootDomainComponent } from '../domain/components/RootDomainComponent';
-import { createSubflowDomainComponent } from '../domain/components/SubflowDomainComponent';
-import { normaliseRequestCache } from '../domain/features/prefetch/request-cache';
-import { modalToComponent } from '../domain/mappers/layout/modalToComponent';
-import { mapStepToComponent } from '../domain/mappers/mapStepToComponent';
-import { getSubflowCallbacks } from '../getSubflowCallbacks';
-import { analyseStep } from '../utils/analyse-step';
-import { executePoll } from './executePoll';
-import { executeRefresh } from './executeRefresh';
-import { executeSubmission } from './executeSubmission';
-import { getErrorMessage } from './getErrorMessage';
-import { getRequestAbortController } from './getRequestAbortController';
-import { getStepCounter } from './getStepCounter';
-const noop = () => { };
-export const createFlowController = (props) => {
-    const { flowId, initialAction, initialStep, backConfig, features, getErrorMessageFunctions, scrollToTop, httpClient, onChange, onCancellation, onCompletion, onCopy, onLink, onError, onEvent, onLog, onValueChange } = props, rest = __rest(props, ["flowId", "initialAction", "initialStep", "backConfig", "features", "getErrorMessageFunctions", "scrollToTop", "httpClient", "onChange", "onCancellation", "onCompletion", "onCopy", "onLink", "onError", "onEvent", "onLog", "onValueChange"]);
-    const rootComponent = createRootDomainComponent(onChange, scrollToTop, backConfig, normaliseRequestCache(rest.requestCache));
-    const stepCount = getStepCounter();
-    const abortController = getRequestAbortController();
-    const createStep = (newStep, etag) => {
-        // TODO remove, move to root domain component
-        if (rootComponent.hasStep()) {
-            stepCount.increment();
-        }
-        const component = createStepComponent(newStep, etag, null);
-        if (component) {
-            rootComponent.pushStep(component);
-            rootComponent.setLoadingState('idle');
-        }
-    };
-    const updateStep = (newStep, etag) => {
-        var _a;
-        const component = createStepComponent(newStep, etag, (_a = rootComponent.getLocalValue()) !== null && _a !== void 0 ? _a : null);
-        if (component) {
-            rootComponent.updateStep(component);
-            rootComponent.setLoadingState('idle');
-        }
-    };
-    const getMapperProps = () => ({
-        uid: `${rootComponent.uid}:${stepCount.current}`,
-        loadingState: 'idle',
-        onComponentUpdate: onChange,
-        flowRequestCache: rootComponent.requestCache,
-        getErrorMessageFunctions,
-        trackEvent,
-        logEvent,
-        features,
-        httpClient,
-        onBehavior,
-        onPoll,
-        onValueChange,
-    });
-    const createStepComponent = (newStep, etag, localValue) => {
-        rootComponent.stop();
-        analyseStep(newStep, logEvent);
-        try {
-            return mapStepToComponent(Object.assign({ stepLocalValue: localValue, step: newStep, etag }, getMapperProps()));
-        }
-        catch (error) {
-            closeWithError(error);
-        }
-    };
-    const getStep = () => {
-        var _a;
-        const stepComponent = rootComponent.getStep();
-        return (_a = stepComponent === null || stepComponent === void 0 ? void 0 : stepComponent.step) !== null && _a !== void 0 ? _a : initialStep;
-    };
-    const trackEvent = (eventName, properties) => {
-        var _a, _b;
-        const step = getStep();
-        const stepId = (_b = (_a = step === null || step === void 0 ? void 0 : step.id) !== null && _a !== void 0 ? _a : step === null || step === void 0 ? void 0 : step.key) !== null && _b !== void 0 ? _b : null;
-        const analytics = step === null || step === void 0 ? void 0 : step.analytics;
-        const metadata = Object.assign(Object.assign(Object.assign(Object.assign({ flowId, integrationId: flowId }, (step ? { stepCount: stepCount.current } : {})), (stepId !== null ? { stepId } : {})), analytics), properties);
-        try {
-            onEvent === null || onEvent === void 0 ? void 0 : onEvent(`Dynamic Flow - ${eventName}`, Object.assign({}, metadata));
-        }
-        catch (_c) { }
-    };
-    const logEvent = (level, message, properties) => {
-        var _a, _b;
-        const step = getStep();
-        const stepId = (_b = (_a = step === null || step === void 0 ? void 0 : step.id) !== null && _a !== void 0 ? _a : step === null || step === void 0 ? void 0 : step.key) !== null && _b !== void 0 ? _b : null;
-        try {
-            onLog === null || onLog === void 0 ? void 0 : onLog(level, message, Object.assign(Object.assign(Object.assign(Object.assign({}, properties), { flowId }), (stepId !== null ? { stepId } : {})), (rootComponent.hasStep() || initialStep ? { stepCount: stepCount.current } : {})));
-        }
-        catch (_c) { }
-    };
-    const closeWithError = (error, analytics, statusCode) => {
-        rootComponent.stop();
-        trackEvent('Failed', Object.assign({}, analytics));
-        logEvent('error', 'Dynamic Flow failed', { errorMessage: getErrorMessage(error), analytics });
-        onError(error, statusCode);
-    };
-    const closeWithCancellation = () => {
-        trackEvent('Cancelled');
-        onCancellation === null || onCancellation === void 0 ? void 0 : onCancellation();
-    };
-    const onBehavior = async (behavior) => {
-        var _a, _b, _c;
-        switch (behavior.type) {
-            case 'back': {
-                if (behavior.action) {
-                    onAction(behavior.action, null)
-                        .then(() => {
-                        rootComponent.clearStack();
-                    })
-                        .catch(() => { });
-                    break;
-                }
-                if (features.isEnabled('nativeBack')) {
-                    if (rootComponent.stepStack.length > 1) {
-                        rootComponent.navigateBack();
-                    }
-                    else {
-                        closeWithCancellation();
-                    }
-                    rootComponent.setLoadingState('idle');
-                }
-                break;
-            }
-            case 'action': {
-                if (rootComponent.isBusy()) {
-                    return { abort: () => { } };
-                }
-                rootComponent.dismissAllModals();
-                const { action } = behavior;
-                const skipValidation = action.method === 'GET' || Boolean(action.skipValidation);
-                const canSubmit = skipValidation || rootComponent.validate();
-                try {
-                    if (canSubmit) {
-                        rootComponent.setLoadingState('submitting');
-                        const model = await rootComponent.getSubmittableValue();
-                        void onAction(action, model);
-                    }
-                    else {
-                        rootComponent.setLoadingState('idle');
-                    }
-                }
-                catch (_d) {
-                    // It's ok to ignore errors here because when this only throw when persisting fails.
-                    // And when persisting fails, the UI is already showing an error.
-                    // If persisting succeeded before, then it would NOT FAIL now,
-                    // because we don't re-try persisting for successful fields when submitting.
-                    rootComponent.setLoadingState('idle');
-                }
-                break;
-            }
-            case 'copy': {
-                navigator.clipboard
-                    .writeText(behavior.content)
-                    .then(() => onCopy === null || onCopy === void 0 ? void 0 : onCopy(behavior.content))
-                    .catch(() => onCopy === null || onCopy === void 0 ? void 0 : onCopy(null));
-                break;
-            }
-            case 'non-merging-action': {
-                rootComponent.dismissAllModals();
-                const { action } = behavior;
-                rootComponent.setLoadingState('submitting');
-                void onAction(action, null);
-                break;
-            }
-            case 'refresh': {
-                rootComponent.dismissAllModals();
-                void onRefresh({ refreshUrl: behavior.url, analytics: behavior.analytics });
-                return {
-                    abort: () => {
-                        abortController.abort();
-                    },
-                };
-            }
-            case 'link': {
-                onLink(behavior.url);
-                break;
-            }
-            case 'modal': {
-                const currentStep = (_a = rootComponent.getStep()) === null || _a === void 0 ? void 0 : _a.step;
-                if (currentStep) {
-                    rootComponent.showModal(modalToComponent(rootComponent.uid, behavior, Object.assign(Object.assign({ step: currentStep, stepLocalValue: rootComponent.getLocalValue() }, getMapperProps()), { registerSubmissionBehavior: () => { } }), rootComponent.getSchemaComponents()));
-                }
-                rootComponent.setLoadingState('idle');
-                break;
-            }
-            case 'dismiss':
-                rootComponent.dismissModal();
-                break;
-            case 'subflow': {
-                rootComponent.setLoadingState('submitting');
-                const { launchConfig } = behavior;
-                const { request, presentation } = launchConfig;
-                const callbacks = getSubflowCallbacks({
-                    behavior,
-                    close: () => rootComponent.closeSubflow(),
-                    onBehavior,
-                    onError: closeWithError,
-                    onEvent: onEvent !== null && onEvent !== void 0 ? onEvent : noop,
-                    restart: () => {
-                        rootComponent.setLoadingState('idle');
-                        rootComponent.start();
-                    },
-                });
-                const component = createSubflowDomainComponent(Object.assign(Object.assign({}, callbacks), { initialRequest: request, requestCache: (_c = (_b = rootComponent.getStep()) === null || _b === void 0 ? void 0 : _b.requestCache) !== null && _c !== void 0 ? _c : rootComponent.requestCache, presentation }), onChange);
-                rootComponent.stop();
-                rootComponent.addSubflow(component);
-                break;
-            }
-            case 'none':
-                break;
-        }
-        return { abort: () => { } };
-    };
-    const onAction = async (action, model) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        try {
-            rootComponent.setLoadingState('submitting');
-            const command = await executeSubmission({
-                action,
-                model,
-                isInitial: !rootComponent.hasStep(),
-                requestCache: (_b = (_a = rootComponent.getStep()) === null || _a === void 0 ? void 0 : _a.requestCache) !== null && _b !== void 0 ? _b : rootComponent.requestCache,
-                httpClient,
-                trackEvent,
-                logEvent,
-            });
-            switch (command.type) {
-                case 'complete': {
-                    onCompletion(command.result);
-                    rootComponent.stop();
-                    trackEvent('Succeeded');
-                    break;
-                }
-                case 'replace-step': {
-                    const isFirstStep = !rootComponent.hasStep();
-                    rootComponent.closeSubflow();
-                    createStep(command.step, command.etag);
-                    trackEvent('Step Shown', { isFirstStep });
-                    break;
-                }
-                case 'error': {
-                    rootComponent.setLoadingState('idle');
-                    const genericErrorMessage = getErrorMessageFunctions().genericErrorWithRetry();
-                    const errors = (_d = (_c = command.body) === null || _c === void 0 ? void 0 : _c.errors) !== null && _d !== void 0 ? _d : { error: genericErrorMessage };
-                    const currentStep = rootComponent.getStep();
-                    if (currentStep) {
-                        updateStep(Object.assign(Object.assign({}, currentStep.step), { errors, // but with the new errors
-                            model, polling: undefined, external: undefined }), (_f = (_e = rootComponent.getStep()) === null || _e === void 0 ? void 0 : _e.etag) !== null && _f !== void 0 ? _f : null);
-                    }
-                    else {
-                        const errorMessage = ((_h = (_g = command.body) === null || _g === void 0 ? void 0 : _g.errors) === null || _h === void 0 ? void 0 : _h.error) || ((_j = command.httpError) === null || _j === void 0 ? void 0 : _j.message) || 'Initial request failed';
-                        closeWithError(new Error(errorMessage, {
-                            cause: `method: ${action.method}, url: ${action.url}`,
-                        }), {}, (_k = command.httpError) === null || _k === void 0 ? void 0 : _k.statusCode);
-                    }
-                    break;
-                }
-                case 'refresh': {
-                    const { refreshUrl, errors = {} } = command.body;
-                    void onRefresh({ refreshUrl, errorsOverride: errors });
-                    break;
-                }
-                case 'behavior': {
-                    void onBehavior(command.behavior);
-                    rootComponent.setLoadingState('idle');
-                    break;
-                }
-            }
-        }
-        catch (error) {
-            closeWithError(error);
-        }
-    };
-    const onRefresh = async ({ refreshUrl, errorsOverride, analytics, }) => {
-        var _a, _b, _c;
-        try {
-            rootComponent.setLoadingState('refreshing');
-            const model = rootComponent.getSubmittableValueSync();
-            const command = await executeRefresh({
-                abortSignal: abortController.abortAndGetNewSignal(),
-                url: (_a = refreshUrl !== null && refreshUrl !== void 0 ? refreshUrl : rootComponent.getRefreshUrl()) !== null && _a !== void 0 ? _a : '',
-                model,
-                etag: (_c = (_b = rootComponent.getStep()) === null || _b === void 0 ? void 0 : _b.etag) !== null && _c !== void 0 ? _c : null,
-                analytics,
-                httpClient,
-                trackEvent,
-                logEvent,
-            });
-            switch (command.type) {
-                case 'refresh-step':
-                    {
-                        const errors = errorsOverride !== null && errorsOverride !== void 0 ? errorsOverride : command.step.errors;
-                        updateStep(Object.assign(Object.assign({}, command.step), { errors }), command.etag);
-                    }
-                    break;
-                case 'noop':
-                    rootComponent.setLoadingState('idle');
-                    break;
-                case 'error': {
-                    closeWithError(new Error('Failed to refresh'), command.body.analytics, command.statusCode);
-                    break;
-                }
-            }
-        }
-        catch (error) {
-            // this should never happen. executeRefresh never throws
-            closeWithError(error, undefined);
-        }
-    };
-    const onPoll = async (url, errorBehavior, signal) => {
-        const command = await executePoll({
-            httpClient,
-            url,
-            errorBehavior,
-            signal,
-            trackEvent,
-        });
-        switch (command.type) {
-            case 'replace-step':
-                createStep(command.step, command.etag);
-                return true;
-            case 'behavior':
-                void onBehavior(command.behavior);
-                return true;
-            case 'complete':
-                onCompletion(command.result);
-                return true;
-            case 'continue':
-                return false;
-        }
-    };
-    let initState = 'initial';
-    if (initialStep) {
-        initState = 'created';
-        trackEvent('Initiated');
-        createStep(initialStep, null);
-        trackEvent('Step Shown', { isFirstStep: true });
-    }
-    const start = () => {
-        if (initState === 'initial' && initialAction) {
-            initState = 'created';
-            trackEvent('Initiated');
-            rootComponent.setLoadingState('submitting');
-            void onAction(Object.assign({ method: 'GET' }, initialAction), null).then(() => {
-                initState = 'started';
-                rootComponent.start();
-            });
-            return;
-        }
-        if (initState === 'created') {
-            initState = 'started';
-            rootComponent.start();
-        }
-    };
-    return {
-        rootComponent,
-        start,
-        cancel: closeWithCancellation,
-    };
-};

package/build/controller/executePoll.js

@@ -1,49 +0,0 @@
-import { getResponseTypeFromHeader } from './getResponseType';
-import { assertActionResponseBody, assertStepResponseBody, isActionResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
-export const executePoll = async (props) => {
-    const { errorBehavior, signal, url, httpClient, trackEvent } = props;
-    try {
-        const response = await httpClient(url !== null && url !== void 0 ? url : '', {
-            method: 'GET',
-            signal,
-        });
-        if (!response.ok) {
-            trackEvent('Polling Failed', { url, statusCode: response.status, variant: 'revamp' });
-            return { type: 'behavior', behavior: errorBehavior };
-        }
-        const responseType = getResponseTypeFromHeader(response.headers);
-        const body = await parseResponseBodyAsJsonElement(response);
-        try {
-            switch (responseType) {
-                case 'step': {
-                    const etag = response.headers.get('etag') || null;
-                    assertStepResponseBody(body);
-                    return { type: 'replace-step', step: body, etag };
-                }
-                case 'exit': {
-                    return { type: 'complete', result: body };
-                }
-                case 'action': {
-                    assertActionResponseBody(body);
-                    return { type: 'behavior', behavior: actionResponseBodyToBehavior(body) };
-                }
-                default: {
-                    if (isActionResponseBody(body)) {
-                        return { type: 'behavior', behavior: actionResponseBodyToBehavior(body) };
-                    }
-                    return { type: 'continue' };
-                }
-            }
-        }
-        catch (_a) {
-            return { type: 'behavior', behavior: errorBehavior };
-        }
-    }
-    catch (_b) {
-        return { type: 'continue' };
-    }
-};
-const actionResponseBodyToBehavior = (body) => ({
-    type: 'non-merging-action',
-    action: body.action,
-});

package/build/controller/executeRefresh.js

@@ -1,39 +0,0 @@
-import { getErrorMessage } from './getErrorMessage';
-import { assertStepResponseBody, isErrorResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
-export const executeRefresh = async (props) => {
-    const { abortSignal, url, model, etag, analytics, httpClient, trackEvent, logEvent } = props;
-    trackEvent('Refresh Triggered', analytics);
-    try {
-        const response = await httpClient(url !== null && url !== void 0 ? url : '', {
-            method: 'POST',
-            body: JSON.stringify(model),
-            headers: Object.assign({ 'Content-Type': 'application/json' }, (etag ? { 'If-None-Match': etag } : {})),
-            signal: abortSignal,
-        });
-        if (response.status === 304) {
-            trackEvent('Refresh Succeeded', analytics);
-            return { type: 'noop' };
-        }
-        if (!response.ok) {
-            const responseBody = await parseResponseBodyAsJsonElement(response).catch(() => ({}));
-            const body = isErrorResponseBody(responseBody) ? responseBody : {};
-            trackEvent('Refresh Failed', Object.assign(Object.assign(Object.assign({}, analytics), body.analytics), { statusCode: response.status }));
-            logEvent('error', 'Dynamic Flow - Refresh Failed', Object.assign(Object.assign({}, analytics), { statusCode: response.status }));
-            return { type: 'error', body, statusCode: response.status };
-        }
-        const newEtag = response.headers.get('etag') || null;
-        const body = await parseResponseBodyAsJsonElement(response);
-        assertStepResponseBody(body);
-        trackEvent('Refresh Succeeded', analytics);
-        return { type: 'refresh-step', step: body, etag: newEtag };
-    }
-    catch (error) {
-        if (error instanceof DOMException && error.name === 'AbortError') {
-            trackEvent('Refresh Aborted', analytics);
-            return { type: 'noop' };
-        }
-        trackEvent('Refresh Failed', analytics);
-        logEvent('error', 'Dynamic Flow - Refresh Failed', Object.assign(Object.assign({}, analytics), { errorMessage: getErrorMessage(error) }));
-        return { type: 'error', body: {} };
-    }
-};

package/build/controller/executeRequest.js

@@ -1,77 +0,0 @@
-import { handleErrorResponse } from './handleErrorResponse';
-import { getResponseType } from './getResponseType';
-import { assertActionResponseBody, assertModalResponseBody, assertStepResponseBody, assertSubflowResponseBody, parseResponseBodyAsJsonElement, } from './response-utils';
-import { makeSafeHttpClient } from './makeSafeHttpClient';
-import { normaliseBehavior } from '../domain/mappers/utils/behavior-utils';
-export const executeRequest = async (props) => {
-    const { exit, request, requestCache, httpClient, trackEvent, logEvent } = props;
-    const { url, method, body } = request;
-    const response = await getCachedOrFetch([
-        url,
-        {
-            method,
-            body: body ? JSON.stringify(body) : undefined,
-            headers: { 'Content-Type': 'application/json' },
-        },
-    ], requestCache, httpClient);
-    if (!response) {
-        const extra = { errorMessage: 'Network Error' };
-        trackEvent('Request Failed', extra);
-        logEvent('error', 'Dynamic Flow - Request Failed Unexpectedly', extra);
-        return { type: 'error' };
-    }
-    if (!response.ok) {
-        return handleErrorResponse(response, undefined, trackEvent);
-    }
-    const responseBody = await parseResponseBodyAsJsonElement(response);
-    const responseType = getResponseType(response.headers, responseBody);
-    if (exit) {
-        return { type: 'complete', result: responseBody };
-    }
-    switch (responseType) {
-        case 'step': {
-            const etag = response.headers.get('etag') || null;
-            assertStepResponseBody(responseBody);
-            return { type: 'replace-step', step: responseBody, etag };
-        }
-        case 'exit': {
-            return { type: 'complete', result: responseBody };
-        }
-        case 'action': {
-            assertActionResponseBody(responseBody);
-            return {
-                type: 'behavior',
-                behavior: {
-                    type: 'action',
-                    action: responseBody.action,
-                },
-            };
-        }
-        case 'subflow': {
-            assertSubflowResponseBody(responseBody);
-            return {
-                type: 'behavior',
-                behavior: Object.assign(Object.assign({}, responseBody), { type: 'subflow', onCompletion: responseBody.onCompletion
-                        ? normaliseBehavior(responseBody.onCompletion, [])
-                        : undefined, onError: responseBody.onError ? normaliseBehavior(responseBody.onError, []) : undefined }),
-            };
-        }
-        case 'modal': {
-            assertModalResponseBody(responseBody);
-            return { type: 'behavior', behavior: Object.assign(Object.assign({}, responseBody), { type: 'modal' }) };
-        }
-        default: {
-            throw new Error(`Unsupported response type: ${String(responseType)}`);
-        }
-    }
-};
-const getCachedOrFetch = async (requestParams, requestCache, httpClient) => {
-    const cachedPromise = requestCache.get(requestParams);
-    if (cachedPromise) {
-        const cachedResponse = await cachedPromise;
-        if (cachedResponse === null || cachedResponse === void 0 ? void 0 : cachedResponse.ok) {
-            return cachedResponse;
-        }
-    }
-    return makeSafeHttpClient(httpClient)(...requestParams);
-};

package/build/controller/executeSubmission.js

@@ -1,69 +0,0 @@
-import { recursiveMerge } from '../utils/recursiveMerge';
-import { getErrorMessage } from './getErrorMessage';
-import { executeRequest } from './executeRequest';
-export const executeSubmission = async (props) => {
-    const { httpClient, requestCache, trackEvent, logEvent } = props;
-    const triggerAction = async (action, model, isInitial) => {
-        var _a, _b;
-        const { exit, url, result = null, id: actionId } = action;
-        const trackSubmissionEvent = !isInitial ? trackEvent : () => { };
-        trackSubmissionEvent('Action Triggered', { actionId });
-        if (exit && !url) {
-            trackSubmissionEvent('Action Succeeded', { actionId });
-            return { type: 'complete', result };
-        }
-        try {
-            const command = await executeRequest({
-                exit,
-                request: createRequestFromAction(action, model),
-                requestCache,
-                httpClient,
-                trackEvent: (name, properties) => {
-                    trackSubmissionEvent(name, Object.assign(Object.assign({}, properties), { actionId }));
-                },
-                logEvent,
-            });
-            switch (command.type) {
-                case 'error': {
-                    trackSubmissionEvent('Action Failed', Object.assign({ actionId, statusCode: (_a = command.httpError) === null || _a === void 0 ? void 0 : _a.statusCode }, (_b = command.body) === null || _b === void 0 ? void 0 : _b.analytics));
-                    return command;
-                }
-                case 'behavior': {
-                    if (command.behavior.type === 'action') {
-                        trackSubmissionEvent('Action Succeeded', { actionId });
-                        return await executeSubmission({
-                            action: command.behavior.action,
-                            isInitial: false,
-                            model: null,
-                            requestCache,
-                            httpClient,
-                            trackEvent,
-                            logEvent,
-                        });
-                    }
-                    trackSubmissionEvent('Action Succeeded', { actionId });
-                    return command;
-                }
-                case 'complete': {
-                    trackSubmissionEvent('Action Succeeded', { actionId });
-                    return Object.assign(Object.assign({}, command), { result: recursiveMerge(command.result, result) });
-                }
-                default: {
-                    trackSubmissionEvent('Action Succeeded', { actionId });
-                    return command;
-                }
-            }
-        }
-        catch (error) {
-            const errorMessage = getErrorMessage(error);
-            trackSubmissionEvent('Action Failed', { actionId, errorMessage });
-            logEvent('error', 'Dynamic Flow - Action Failed Unexpectedly', { actionId, errorMessage });
-            throw error;
-        }
-    };
-    return triggerAction(props.action, props.model, props.isInitial);
-};
-export const createRequestFromAction = (action, model) => {
-    var _a, _b, _c;
-    return (Object.assign(Object.assign({}, action), { url: (_a = action.url) !== null && _a !== void 0 ? _a : '', method: (_b = action.method) !== null && _b !== void 0 ? _b : 'POST', body: action.method === 'GET' ? undefined : recursiveMerge(model, (_c = action.data) !== null && _c !== void 0 ? _c : null) }));
-};

package/build/controller/getErrorMessage.js

@@ -1,7 +0,0 @@
-export const getErrorMessage = (error) => {
-    return error instanceof Error
-        ? error.message
-        : typeof error === 'string'
-            ? error
-            : `Unknown Error: type is ${typeof error}`;
-};

package/build/controller/getRequestAbortController.js

@@ -1,13 +0,0 @@
-export const getRequestAbortController = () => {
-    let abortController = new AbortController();
-    return {
-        abortAndGetNewSignal() {
-            abortController.abort();
-            abortController = new AbortController();
-            return abortController.signal;
-        },
-        abort() {
-            abortController.abort();
-        },
-    };
-};

package/build/controller/getResponseType.js

@@ -1,35 +0,0 @@
-import { isObject } from '../utils/type-validators';
-const responseTypes = ['step', 'action', 'exit', 'modal', 'subflow'];
-/**
- * Returns either 'step', 'action', or 'exit' based on the response headers and body.
- * This function takes a response body parameter because, for legacy reasons, we still need to consider the body
- * to determine the response type, in cases where the response headers are not set.
- * Ideally it should just be a matter of checking the "X-Df-Response-Type" response header.
- */
-export const getResponseType = (headers, body) => {
-    const headerResponseType = getResponseTypeFromHeader(headers);
-    if (headerResponseType) {
-        return headerResponseType;
-    }
-    if (isObject(body) && body.action) {
-        // TODO: use Zod to validate the action object
-        return 'action';
-    }
-    return 'step';
-};
-export const getResponseTypeFromHeader = (headers) => {
-    if (headers === null || headers === void 0 ? void 0 : headers.has('X-Df-Response-Type')) {
-        const type = headers.get('X-Df-Response-Type');
-        assertDFResponseType(type);
-        return type;
-    }
-    if (headers === null || headers === void 0 ? void 0 : headers.has('X-Df-Exit')) {
-        return 'exit';
-    }
-    return undefined;
-};
-function assertDFResponseType(type) {
-    if (!responseTypes.includes(type)) {
-        throw new Error("Unsupported X-Df-Response-Type. Allowed values are 'step', 'action', 'exit', 'error', 'modal', 'subflow'.");
-    }
-}

package/build/controller/getSafeHttpClient.js

@@ -1,8 +0,0 @@
-export const getSafeHttpClient = (httpClient) => async (input, init) => {
-    try {
-        return await httpClient(input, init);
-    }
-    catch (_a) {
-        return null;
-    }
-};