@wise/dynamic-flow-client 5.25.1 → 5.25.2

package/build/domain/mappers/layout/paragraphLayoutToComponent.js

@@ -0,0 +1,12 @@
+import { createParagraphComponent } from '../../components/ParagraphComponent';
+import { mapLegacyAlign } from '../utils/legacy-utils';
+export const paragraphLayoutToComponent = (uid, { analyticsId, align, control, margin, size, tags, text }) => createParagraphComponent({
+    uid,
+    analyticsId,
+    text,
+    control,
+    align: mapLegacyAlign(align !== null && align !== void 0 ? align : 'left'),
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    tags,
+    size: size !== null && size !== void 0 ? size : 'md',
+});

package/build/domain/mappers/layout/progressLayoutToComponent.js

@@ -0,0 +1,15 @@
+import { createProgressComponent } from '../../components/ProgressComponent';
+import { mapLegacyContext } from '../utils/legacy-utils';
+export const progressLayoutToComponent = (uid, { analyticsId, context, control, description, help, margin, progress, progressText, tags, title, }) => createProgressComponent({
+    uid,
+    analyticsId,
+    context: mapLegacyContext(context !== null && context !== void 0 ? context : 'neutral'),
+    control,
+    description,
+    help: help === null || help === void 0 ? void 0 : help.markdown,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    progress,
+    progressText,
+    tags,
+    title,
+});

package/build/domain/mappers/layout/reviewLayoutToComponent.js

@@ -0,0 +1,49 @@
+import { createReviewComponent } from '../../components/ReviewComponent';
+import { getDomainLayerCallToAction } from '../utils/call-to-action-utils';
+import { getHrefWithTracking } from '../utils/getHrefWithTracking';
+import { getDomainLayerMedia } from '../utils/media-utils';
+import { mapTags } from '../utils/tags-utils';
+import { mapAdditionalInfo, mapInlineAlert } from '../utils/utils';
+export const reviewLayoutToComponent = (uid, { analyticsId, fields, title, callToAction, control, margin, tags, orientation, action, }, mapperProps) => createReviewComponent({
+    uid,
+    analyticsId,
+    callToAction: getCallToAction({ mapperProps, callToAction, action }),
+    control: getOrientationControl({ control, orientation }),
+    fields: fields.map((field) => mapReviewField(field, mapperProps)),
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    tags,
+    title,
+});
+const getCallToAction = ({ callToAction, action, mapperProps, }) => {
+    if (callToAction) {
+        return getDomainLayerCallToAction(callToAction, mapperProps);
+    }
+    // for legacy reasons, we need to support regular actions, and use the legacy action.title for the CTA title
+    if (action === null || action === void 0 ? void 0 : action.title) {
+        const behavior = { type: 'action', action, track: true };
+        const { onBehavior, trackEvent } = mapperProps;
+        return {
+            type: 'action',
+            title: action.title,
+            onClick: () => {
+                void onBehavior(behavior);
+            },
+            hrefWithTracking: getHrefWithTracking({ behavior, onBehavior, trackEvent }),
+        };
+    }
+    return undefined;
+};
+const getOrientationControl = ({ control, orientation, }) => {
+    if (control) {
+        return control;
+    }
+    // for legacy we support an orientation property, but this has been replaced by control
+    if (orientation) {
+        return orientation;
+    }
+    return undefined;
+};
+const mapReviewField = (field, mapperProps) => { var _a; return (Object.assign(Object.assign({}, field), { media: getDomainLayerMedia(field), help: (_a = field.help) === null || _a === void 0 ? void 0 : _a.markdown, inlineAlert: mapInlineAlert(field.inlineAlert), additionalInfo: mapAdditionalInfo(field.additionalInfo, mapperProps), callToAction: getCallToAction({
+        callToAction: field.callToAction,
+        mapperProps,
+    }), tags: mapTags(field) })); };

package/build/domain/mappers/layout/searchLayoutToComponent.js

@@ -0,0 +1,44 @@
+import { createSearchComponent, } from '../../components/searchComponent/SearchComponent';
+import { getPerformSearchFunction } from '../../features/search/getPerformSearchFunction';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+export const searchLayoutToComponent = (uid, { analyticsId, control, emptyMessage = '', initialState, hint, method, param, title, url, margin, tags, }, mapperProps) => {
+    const { httpClient, onBehavior, onComponentUpdate } = mapperProps;
+    const search = getPerformSearchFunction(httpClient, (layout, index) => mapLayoutToComponent(`${uid}-search-response-${index}`, layout, mapperProps, []), { method, param, url });
+    return createSearchComponent({
+        uid,
+        analyticsId,
+        control,
+        emptyMessage,
+        initialState: getInitialState(uid, initialState, mapperProps),
+        hint,
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        tags,
+        title,
+    }, search, onBehavior, onComponentUpdate);
+};
+const getInitialState = (uid, initialState, mapperProps) => {
+    if (!initialState) {
+        return emptyInitialState;
+    }
+    switch (initialState.type) {
+        case 'layout':
+            return {
+                type: 'layout',
+                content: initialState.content.map((layout, index) => mapLayoutToComponent(`${uid}-initial-${index}`, layout, mapperProps, [])),
+            };
+        case 'results':
+            return {
+                type: 'results',
+                results: initialState.results,
+            };
+        default: {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const exhaustiveCheck = initialState;
+            return emptyInitialState;
+        }
+    }
+};
+const emptyInitialState = {
+    type: 'layout',
+    content: [],
+};

package/build/domain/mappers/layout/sectionLayoutToComponent.js

@@ -0,0 +1,16 @@
+import { createSectionComponent } from '../../components/SectionComponent';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+import { getDomainLayerCallToAction } from '../utils/call-to-action-utils';
+export const sectionLayoutToComponent = (uid, { analyticsId, control, shortTitle, title, components, callToAction, margin, tags, }, mapperProps, schemaComponents) => {
+    return createSectionComponent({
+        uid,
+        analyticsId,
+        control,
+        title,
+        shortTitle,
+        components: components.map((component, index) => mapLayoutToComponent(`${uid}.section-${index}`, component, mapperProps, schemaComponents)),
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        callToAction: getDomainLayerCallToAction(callToAction, mapperProps),
+        tags,
+    });
+};

package/build/domain/mappers/layout/statusListLayoutToComponent.js

@@ -0,0 +1,15 @@
+import { createStatusListComponent } from '../../components/StatusListComponent';
+import { getDomainLayerCallToAction } from '../utils/call-to-action-utils';
+import { mapTags } from '../utils/tags-utils';
+export const statusListLayoutToComponent = (uid, { analyticsId, control, items, margin, tags, title }, mapperProps) => createStatusListComponent({
+    uid,
+    analyticsId,
+    control,
+    items: items.map((item) => {
+        const callToAction = getDomainLayerCallToAction(item.callToAction, mapperProps);
+        return Object.assign(Object.assign({}, item), { callToAction, tags: mapTags(item) });
+    }),
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    tags,
+    title,
+});

package/build/domain/mappers/layout/tabsLayoutToComponent.js

@@ -0,0 +1,16 @@
+import { createTabsComponent } from '../../components/TabsComponent';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+import { mapTags } from '../utils/tags-utils';
+export const tabsLayoutToComponent = (uid, { analyticsId, control, margin, tags, tabs }, mapperProps, schemaComponents) => createTabsComponent({
+    uid,
+    analyticsId,
+    control,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    tags,
+    tabs: mapTabs(tabs, uid, mapperProps, schemaComponents),
+});
+const mapTabs = (tabs, uid, mapperProps, schemaComponents) => tabs.map(({ components, tag, tags, title }, tabIndex) => ({
+    title,
+    tags: mapTags({ tag, tags }),
+    components: components.map((c, componentIndex) => mapLayoutToComponent(`${uid}.tabs-${tabIndex}-${componentIndex}`, c, mapperProps, schemaComponents)),
+}));

package/build/domain/mappers/layout/upsellLayoutToComponent.js

@@ -0,0 +1,18 @@
+import { createUpsellComponent } from '../../components/UpsellComponent';
+import { getDomainLayerCallToAction } from '../utils/call-to-action-utils';
+import { getDomainLayerMedia } from '../utils/media-utils';
+import { makeDismissHandler } from '../../handlers/dismissHandler';
+export const upsellLayoutToComponent = (uid, { analyticsId, callToAction, control, margin, media, onDismiss, tags, text }, mapperProps) => {
+    const { onComponentUpdate } = mapperProps;
+    return createUpsellComponent({
+        uid,
+        analyticsId,
+        callToAction: getDomainLayerCallToAction(callToAction, mapperProps),
+        control,
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        media: getDomainLayerMedia({ media }),
+        tags,
+        text,
+        dismiss: onDismiss ? makeDismissHandler(onDismiss, mapperProps) : undefined,
+    }, onComponentUpdate);
+};

package/build/domain/mappers/mapLayoutToComponent.js

@@ -0,0 +1,84 @@
+import { alertLayoutToComponent } from './layout/alertLayoutToComponent';
+import { boxLayoutToComponent } from './layout/boxLayoutToComponent';
+import { collectionLayoutToComponent } from './layout/collectionLayoutToComponent';
+import { buttonLayoutToComponent } from './layout/buttonLayoutToComponent';
+import { columnsLayoutToComponent } from './layout/columnsLayoutToComponent';
+import { decisionLayoutToComponent } from './layout/decisionLayoutToComponent';
+import { deprecatedListLayoutToComponent, isDeprecatedListLayout, } from './layout/deprecatedListLayoutToComponent';
+import { dividerLayoutToComponent } from './layout/dividerLayoutToComponent';
+import { formLayoutToComponent } from './layout/formLayoutToComponent';
+import { headingLayoutToComponent } from './layout/headingLayoutToComponent';
+import { imageLayoutToComponent } from './layout/imageLayoutToComponent';
+import { infoLayoutToComponent } from './layout/infoLayoutToComponent';
+import { instructionsLayoutToComponent } from './layout/instructionsLayoutToComponent';
+import { listLayoutToComponent } from './layout/listLayoutToComponent';
+import { loadingIndicatorLayoutToComponent } from './layout/loadingIndicatorLayoutToComponent';
+import { markdownLayoutToComponent } from './layout/markdownLayoutToComponent';
+import { mediaLayoutToComponent } from './layout/mediaLayoutToComponent';
+import { modalLayoutToComponent } from './layout/modalLayoutToComponent';
+import { paragraphLayoutToComponent } from './layout/paragraphLayoutToComponent';
+import { progressLayoutToComponent } from './layout/progressLayoutToComponent';
+import { reviewLayoutToComponent } from './layout/reviewLayoutToComponent';
+import { searchLayoutToComponent } from './layout/searchLayoutToComponent';
+import { sectionLayoutToComponent } from './layout/sectionLayoutToComponent';
+import { statusListLayoutToComponent } from './layout/statusListLayoutToComponent';
+import { tabsLayoutToComponent } from './layout/tabsLayoutToComponent';
+import { upsellLayoutToComponent } from './layout/upsellLayoutToComponent';
+export const mapLayoutToComponent = (uid, layout, mapperProps, schemaComponents) => {
+    switch (layout.type) {
+        case 'alert':
+            return alertLayoutToComponent(uid, layout, mapperProps);
+        case 'box':
+            return boxLayoutToComponent(uid, layout, mapperProps, schemaComponents);
+        case 'button':
+            return buttonLayoutToComponent(uid, layout, mapperProps);
+        case 'collection':
+            return collectionLayoutToComponent(uid, layout, mapperProps);
+        case 'columns':
+            return columnsLayoutToComponent(uid, layout, mapperProps, schemaComponents);
+        case 'decision':
+            return decisionLayoutToComponent(uid, layout, mapperProps);
+        case 'divider':
+            return dividerLayoutToComponent(uid, layout);
+        case 'form':
+            return formLayoutToComponent(uid, layout, schemaComponents);
+        case 'heading':
+            return headingLayoutToComponent(uid, layout);
+        case 'image':
+            return imageLayoutToComponent(uid, layout);
+        case 'info':
+            return infoLayoutToComponent(uid, layout);
+        case 'instructions':
+            return instructionsLayoutToComponent(uid, layout);
+        case 'list':
+            return isDeprecatedListLayout(layout)
+                ? deprecatedListLayoutToComponent(uid, layout)
+                : listLayoutToComponent(uid, layout, mapperProps);
+        case 'loading-indicator':
+            return loadingIndicatorLayoutToComponent(uid, layout);
+        case 'markdown':
+            return markdownLayoutToComponent(uid, layout);
+        case 'media':
+            return mediaLayoutToComponent(uid, layout);
+        case 'modal':
+            return modalLayoutToComponent(uid, layout, mapperProps, schemaComponents);
+        case 'paragraph':
+            return paragraphLayoutToComponent(uid, layout);
+        case 'progress':
+            return progressLayoutToComponent(uid, layout);
+        case 'review':
+            return reviewLayoutToComponent(uid, layout, mapperProps);
+        case 'search':
+            return searchLayoutToComponent(uid, layout, mapperProps);
+        case 'section':
+            return sectionLayoutToComponent(uid, layout, mapperProps, schemaComponents);
+        case 'status-list':
+            return statusListLayoutToComponent(uid, layout, mapperProps);
+        case 'tabs':
+            return tabsLayoutToComponent(uid, layout, mapperProps, schemaComponents);
+        case 'upsell':
+            return upsellLayoutToComponent(uid, layout, mapperProps);
+        default:
+            throw new Error(`Invalid layout type in ${JSON.stringify(layout)}`);
+    }
+};

package/build/domain/mappers/mapSchemaToComponent.js

@@ -0,0 +1,65 @@
+import { numberSchemaToComponent } from './schema/numberSchemaToComponent';
+import { isAllOfSchema, isArraySchema, isBlobSchema, isBooleanSchema, isConstSchema, isDateSchema, isIntegerSchema, isNumberSchema, isObjectSchema, isOneOfSchema, isSchemaWithPersistAsync, isStringSchema, } from '../../utils/type-utils';
+import { allOfSchemaToComponent } from './schema/allOfSchemaToComponent';
+import { arraySchemaToComponent } from './schema/arraySchemaToComponent/arraySchemaToComponent';
+import { blobSchemaToComponent } from './schema/blobSchemaToComponent';
+import { booleanSchemaToComponent } from './schema/booleanSchemaToComponent';
+import { constSchemaToComponent } from './schema/constSchemaToComponent';
+import { dateSchemaToComponent } from './schema/dateSchemaToComponent';
+import { integerSchemaToComponent } from './schema/integerSchemaToComponent';
+import { objectSchemaToFormattedValueComponent } from './schema/objectSchemaToComponent/objectSchemaToFormattedValueComponent';
+import { objectSchemaToMoneyInputComponent } from './schema/objectSchemaToComponent/objectSchemaToMoneyInputComponent';
+import { objectSchemaToObjectComponent } from './schema/objectSchemaToComponent/objectSchemaToObjectComponent';
+import { oneOfSchemaToComponent } from './schema/oneOfSchemaToComponent/oneOfSchemaToComponent';
+import { persistAsyncSchemaToComponent } from './schema/persistAsyncSchemaToComponent';
+import { stringSchemaToComponent } from './schema/stringSchemaToComponent/stringSchemaToComponent';
+export const mapSchemaToComponent = (schemaMapperProps, mapperProps) => {
+    const { uid, schema } = schemaMapperProps;
+    if (isConstSchema(schema)) {
+        return constSchemaToComponent(uid, Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isSchemaWithPersistAsync(schema)) {
+        return persistAsyncSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isAllOfSchema(schema)) {
+        return allOfSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isOneOfSchema(schema)) {
+        return oneOfSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isBooleanSchema(schema)) {
+        return booleanSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isDateSchema(schema)) {
+        return dateSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isObjectSchema(schema)) {
+        const { format } = schema;
+        if (format === 'money') {
+            return objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+        }
+        if (format != null && Object.keys(schema.properties).length === 0) {
+            return objectSchemaToFormattedValueComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: Object.assign(Object.assign({}, schema), { format }) }), mapperProps);
+        }
+        return objectSchemaToObjectComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isIntegerSchema(schema)) {
+        return integerSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isNumberSchema(schema)) {
+        return numberSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isStringSchema(schema)) {
+        return stringSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isArraySchema(schema)) {
+        return arraySchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    if (isBlobSchema(schema)) {
+        if (!schemaMapperProps.onPersistAsync) {
+            throw new Error('Blob schemas can only be used as the schema of a persist async configuration.');
+        }
+        return blobSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    throw new Error('Not yet supported');
+};

package/build/domain/mappers/mapSchemaToComponent.test.js

@@ -0,0 +1,116 @@
+import { getMockMapperProps, getMockSchemaMapperProps } from './schema/tests/test-utils';
+import { mapSchemaToComponent } from './mapSchemaToComponent';
+describe('mapSchemaToComponents', () => {
+    it('maps a date schema to a date input component', () => {
+        const component = mapSchemaToComponent(getMockSchemaMapperProps({ schema: { type: 'date' }, model: null }), getMockMapperProps());
+        expect(component.type).toBe('date');
+    });
+    describe('when no alert is given', () => {
+        it('returns a StepComponent for the schema', () => {
+            const schema = {
+                type: 'string',
+            };
+            const component = mapSchemaToComponent(getMockSchemaMapperProps({ schema, model: null }), getMockMapperProps());
+            expect(component.type).toBe('text');
+        });
+    });
+    describe('when const schemas are given', () => {
+        const constSchemas = {
+            $id: '#schema',
+            type: 'object',
+            title: 'Object Schema',
+            displayOrder: ['cbs', 'cns', 'css', 'cos', 'cas'],
+            properties: {
+                cbs: {
+                    title: 'Const boolean schema',
+                    const: true,
+                },
+                cns: {
+                    title: 'Const number schema',
+                    const: 42,
+                },
+                css: {
+                    title: 'Const string schema',
+                    const: 'Hello World!',
+                },
+                cos: {
+                    title: 'Const object schema',
+                    const: {
+                        name: 'John Doe',
+                    },
+                },
+                cas: {
+                    title: 'Const array schema',
+                    const: ['Hello', 'World!'],
+                },
+            },
+        };
+        describe('when the getValue function is called', () => {
+            it('returns the const values', async () => {
+                const component = mapSchemaToComponent(getMockSchemaMapperProps({ schema: constSchemas, model: null }), getMockMapperProps());
+                expect(await component.getSubmittableValue()).toStrictEqual({
+                    cbs: true,
+                    cns: 42,
+                    css: 'Hello World!',
+                    cos: { name: 'John Doe' },
+                    cas: ['Hello', 'World!'],
+                });
+            });
+        });
+    });
+    describe('when hidden schemas are given', () => {
+        const hiddenSchemas = {
+            $id: '#schema',
+            type: 'object',
+            title: 'Object Schema',
+            displayOrder: ['hbs', 'hns', 'hss'],
+            properties: {
+                hbs: {
+                    type: 'boolean',
+                    title: 'Hidden boolean schema',
+                    hidden: true,
+                    default: true,
+                },
+                hns: {
+                    type: 'number',
+                    title: 'Hidden number schema',
+                    hidden: true,
+                    default: 42,
+                },
+                hss: {
+                    type: 'string',
+                    title: 'Hidden string schema',
+                    hidden: true,
+                    default: 'Hello World!',
+                },
+            },
+        };
+        describe('when model is null', () => {
+            describe('and the getValue function is called', () => {
+                it('returns the default values', async () => {
+                    const component = mapSchemaToComponent(getMockSchemaMapperProps({ schema: hiddenSchemas, model: null }), getMockMapperProps());
+                    expect(await component.getSubmittableValue()).toStrictEqual({
+                        hbs: true,
+                        hns: 42,
+                        hss: 'Hello World!',
+                    });
+                });
+            });
+        });
+        describe('when model is not null', () => {
+            describe('and the getValue function is called', () => {
+                it('prefers to return the model values over the default values', async () => {
+                    const component = mapSchemaToComponent(getMockSchemaMapperProps({
+                        schema: hiddenSchemas,
+                        model: { hbs: false, hns: 0, hss: 'Hello' },
+                    }), getMockMapperProps());
+                    expect(await component.getSubmittableValue()).toStrictEqual({
+                        hbs: false,
+                        hns: 0,
+                        hss: 'Hello',
+                    });
+                });
+            });
+        });
+    });
+});

package/build/domain/mappers/mapStepSchemas.js

@@ -0,0 +1,14 @@
+import { mapSchemaToComponent } from './mapSchemaToComponent';
+const noop = () => { };
+export const mapStepSchemas = (uid, step, stepLocalValue, mapperProps) => {
+    return step.schemas.map((schema, i) => { var _a; var _b; return mapSchemaToComponent({
+        uid: `${uid}.schemas-${i}.${schema.$id}`,
+        schemaId: schema.$id,
+        schema,
+        model: (_b = step.model) !== null && _b !== void 0 ? _b : null,
+        localValue: stepLocalValue,
+        validationErrors: (_a = step.errors) === null || _a === void 0 ? void 0 : _a.validation,
+        required: true,
+        onValueChange: noop,
+    }, mapperProps); });
+};

package/build/domain/mappers/mapStepToComponent.js

@@ -0,0 +1,143 @@
+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 { createExternalConfirmation, } from '../components/step/ExternalConfirmationComponent';
+import { createStepComponent } from '../components/step/StepDomainComponent';
+import { getStepPolling } from '../features/polling/getStepPolling';
+import { getStepPrefetch } from '../features/prefetch/getStepPrefetch';
+import { getStepRefreshAfter } from '../features/refreshAfter/getStepRefreshAfter';
+import { mapLayoutToComponent } from './mapLayoutToComponent';
+import { mapStepSchemas } from './mapStepSchemas';
+import { mapToolbarToComponent } from './mapToolbarToComponent';
+import { groupLayoutByPinned } from './utils/groupLayoutByPinned';
+import { normaliseMarginInLastComponent } from './utils/layout-utils';
+import { getDomainLayerBehavior } from './utils/behavior-utils';
+import { safeParseLink } from '../../utils/safe-parse-link';
+export const mapStepToComponent = (_a) => {
+    var _b, _c;
+    var { uid: rootUid, loadingState, features, trackEvent, onPoll, onBehavior } = _a, restProps = __rest(_a, ["uid", "loadingState", "features", "trackEvent", "onPoll", "onBehavior"]);
+    const { etag, step, stepLocalValue, flowRequestCache, logEvent, onComponentUpdate } = restProps;
+    const { id, control, description, errors, external, key, navigation, polling, refreshAfter, title, tags, } = step;
+    const submissionBehaviors = [];
+    const registerSubmissionBehavior = (behavior) => {
+        // eslint-disable-next-line functional/immutable-data
+        submissionBehaviors.push(behavior);
+    };
+    const mapperProps = Object.assign(Object.assign({}, restProps), { features,
+        trackEvent,
+        onBehavior,
+        registerSubmissionBehavior });
+    const back = mapBackNavigation(navigation, onBehavior, features.isEnabled('nativeBack'));
+    const stepId = id || key;
+    if (stepId === undefined) {
+        throw new Error('Step must have an id or a key');
+    }
+    const uid = `${rootUid}.${stepId !== null && stepId !== void 0 ? stepId : 'step'}`;
+    const stepPolling = polling
+        ? getStepPolling({
+            pollingConfig: polling,
+            logEvent,
+            onBehavior,
+            onPoll,
+            registerSubmissionBehavior,
+        })
+        : undefined;
+    const stepRefreshAfter = refreshAfter
+        ? getStepRefreshAfter({ refreshAfter, logEvent, onBehavior })
+        : undefined;
+    const stepPrefetch = getStepPrefetch(restProps.httpClient, flowRequestCache, submissionBehaviors);
+    const onLoadBehavior = getDomainLayerBehavior({ behavior: step.onLoad }, (_b = step.actions) !== null && _b !== void 0 ? _b : [], registerSubmissionBehavior);
+    const stepOnLoad = onLoadBehavior && onLoadBehavior.type !== 'link'
+        ? () => {
+            void onBehavior(onLoadBehavior);
+        }
+        : undefined;
+    const externalConfirmation = getExternalConfiguration(uid, external, onLoadBehavior, mapperProps);
+    const referencedSchemaIds = getReferencedSchemaId(step);
+    const schemaComponents = mapStepSchemas(uid, step, stepLocalValue, mapperProps);
+    const { layout, footer } = getLayoutAndFooter(step, features);
+    const layoutComponents = layout.map((layoutComponent, index) => mapLayoutToComponent(`${uid}.layout-${index}`, layoutComponent, mapperProps, schemaComponents));
+    const footerComponents = normaliseMarginInLastComponent(footer).map((footerComponent, index) => mapLayoutToComponent(`${uid}.footer-${index}`, footerComponent, mapperProps, schemaComponents));
+    const toolbar = mapToolbarToComponent(uid, step.toolbar, mapperProps);
+    const stepComponent = createStepComponent({
+        uid,
+        back,
+        etag,
+        toolbar,
+        layoutComponents,
+        schemaComponents,
+        footerComponents,
+        control,
+        description,
+        error: errors === null || errors === void 0 ? void 0 : errors.error,
+        externalConfirmation,
+        loadingState,
+        stepPolling,
+        stepRefreshAfter,
+        title,
+        tags,
+        stackBehavior: (_c = navigation === null || navigation === void 0 ? void 0 : navigation.stackBehavior) !== null && _c !== void 0 ? _c : 'default',
+        stepPrefetch,
+        step,
+        referencedSchemaIds,
+        features,
+        onComponentUpdate,
+        trackEvent,
+        logEvent,
+        onBehavior,
+        onLoad: stepOnLoad,
+    });
+    return stepComponent;
+};
+const getReferencedSchemaId = (step) => {
+    const { schemas, layout, footer } = step;
+    const stringifiedLayout = JSON.stringify({ layout, footer });
+    return schemas
+        .filter((schema) => stringifiedLayout.includes(`"schemaId":"${schema.$id}"`) ||
+        stringifiedLayout.includes(`"schema":{"$ref":"${schema.$id}"`))
+        .map((schema) => schema.$id)
+        .filter((schemaId) => schemaId !== undefined);
+};
+const mapBackNavigation = (navigation, onBehavior, isNativeBackEnabled) => {
+    var _a;
+    const backNavigation = (_a = navigation === null || navigation === void 0 ? void 0 : navigation.back) !== null && _a !== void 0 ? _a : navigation === null || navigation === void 0 ? void 0 : navigation.backButton;
+    const backBehavior = { type: 'back', action: backNavigation === null || backNavigation === void 0 ? void 0 : backNavigation.action, track: false };
+    return backNavigation || isNativeBackEnabled
+        ? {
+            title: backNavigation === null || backNavigation === void 0 ? void 0 : backNavigation.title,
+            onClick: () => {
+                void onBehavior(backBehavior);
+            },
+        }
+        : undefined;
+};
+const getExternalConfiguration = (uid, external, onLoad, mapperProps) => {
+    if (onLoad.type === 'link') {
+        return createExternalConfirmation(`${uid}-external-confirmation`, safeParseLink(onLoad.url), mapperProps.onLink, mapperProps.onComponentUpdate);
+    }
+    if ((external === null || external === void 0 ? void 0 : external.url) && onLoad.type === 'none') {
+        return createExternalConfirmation(`${uid}-external-confirmation`, safeParseLink(external.url), mapperProps.onLink, mapperProps.onComponentUpdate);
+    }
+    return undefined;
+};
+const getLayoutAndFooter = (step, features) => {
+    var _a;
+    if (step.footer) {
+        const { layout = [], footer = [] } = step;
+        return { layout, footer };
+    }
+    if (features.isEnabled('pinnedButtons')) {
+        const { pinned: footer, nonPinned: layout } = groupLayoutByPinned((_a = step.layout) !== null && _a !== void 0 ? _a : []);
+        return { layout, footer };
+    }
+    const { layout = [] } = step;
+    return { layout, footer: [] };
+};