@wise/dynamic-flow-client 5.25.2-experimental-a8a898e → 5.25.2

package/build/domain/features/validationAsync/getPerformValidationAsync.js

@@ -0,0 +1,46 @@
+import { isObject, isString } from '../../../utils/type-validators';
+import { constructPayload } from '../utils/http-utils';
+import { getAnalyticsFromErrorResponse } from '../utils/response-utils';
+/**
+ * Takes an httpClient and schema validation async config and returns a function that can
+ * execute a validation async request.
+ */
+export const getPerformValidationAsync = ({ httpClient, validationAsyncConfig, schemaId, trackEvent, }) => {
+    const { method, param, url } = validationAsyncConfig;
+    const trackFailure = (json) => {
+        const analytics = getAnalyticsFromErrorResponse(json);
+        trackEvent('ValidationAsync Failed', Object.assign({ schema: schemaId }, analytics));
+    };
+    return async function performValidationAsync({ value, signal }) {
+        let response;
+        trackEvent('ValidationAsync Triggered', { schema: schemaId });
+        try {
+            response = await httpClient(url, constructPayload({ value, signal, requestConfig: { method, param } }));
+        }
+        catch (error) {
+            trackFailure();
+            throw error;
+        }
+        const json = (await response.json().catch(() => null));
+        const message = getValidationMessage(json);
+        if (response.ok) {
+            trackEvent('ValidationAsync Succeeded', { schema: schemaId });
+            return message;
+        }
+        if (response.status === 422) {
+            if (message) {
+                trackEvent('ValidationAsync Succeeded', { schema: schemaId });
+                throw new Error(message);
+            }
+        }
+        trackFailure(json);
+        return null;
+    };
+};
+const getValidationMessage = (json) => {
+    if (!isObject(json)) {
+        return null;
+    }
+    const { message } = json;
+    return isString(message) ? message : null;
+};

package/build/domain/features/validationAsync/getPerformValidationAsync.test.js

@@ -0,0 +1,162 @@
+import { vi } from 'vitest';
+import { getMockHttpClient, respondWith } from '../../../test-utils';
+import { getPerformValidationAsync } from './getPerformValidationAsync';
+describe('getPerformValidationAsync', () => {
+    const trackEvent = vi.fn();
+    const { signal } = new AbortController();
+    const validationAsyncConfig = {
+        method: 'POST',
+        param: 'param',
+        url: '/validate',
+    };
+    it('should make the request using the specified parameter', async () => {
+        const spyHttpClient = vi.fn().mockResolvedValue(respondWith({ message: 'Validation failed' }));
+        const spyTrackEvent = vi.fn();
+        const performValidationAsync = getPerformValidationAsync({
+            httpClient: spyHttpClient,
+            trackEvent: spyTrackEvent,
+            validationAsyncConfig,
+            schemaId: 'schemaId',
+        });
+        await performValidationAsync({ value: 'value', signal });
+        expect(spyHttpClient).toHaveBeenCalledWith('/validate', {
+            body: '{"param":"value"}',
+            headers: { 'Content-Type': 'application/json' },
+            method: 'POST',
+            signal,
+        });
+        expect(spyTrackEvent).toHaveBeenCalledWith('ValidationAsync Triggered', expect.objectContaining({ schema: 'schemaId' }));
+    });
+    it('should wrap blobs in form data before submitting', async () => {
+        const spyHttpClient = vi.fn().mockResolvedValue(respondWith({ message: 'Validation failed' }));
+        const performValidationAsync = getPerformValidationAsync({
+            httpClient: spyHttpClient,
+            trackEvent,
+            validationAsyncConfig,
+        });
+        const file = new File(['file'], 'file.txt');
+        await performValidationAsync({ value: file, signal });
+        expect(spyHttpClient).toHaveBeenCalledWith('/validate', {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            body: expect.any(FormData),
+            headers: {},
+            method: 'POST',
+            signal,
+        });
+    });
+    describe('when the response is ok', () => {
+        it('should respond with message if response includes one', async () => {
+            const httpClient = getMockHttpClient({
+                '/validate': async () => respondWith({ message: 'Validation succeeded' }),
+            });
+            const spyTrackEvent = vi.fn();
+            const performValidationAsync = getPerformValidationAsync({
+                httpClient,
+                trackEvent: spyTrackEvent,
+                validationAsyncConfig,
+                schemaId: 'schemaId',
+            });
+            const result = await performValidationAsync({ value: 'value', signal });
+            expect(result).toBe('Validation succeeded');
+            expect(spyTrackEvent).toHaveBeenLastCalledWith('ValidationAsync Succeeded', expect.objectContaining({ schema: 'schemaId' }));
+        });
+        it('should respond with null if response does not include a message', async () => {
+            const httpClient = getMockHttpClient({
+                '/validate': async () => respondWith({}, { status: 200 }),
+            });
+            const spyTrackEvent = vi.fn();
+            const performValidationAsync = getPerformValidationAsync({
+                httpClient,
+                trackEvent: spyTrackEvent,
+                validationAsyncConfig,
+                schemaId: 'schemaId',
+            });
+            const result = await performValidationAsync({ value: 'value', signal });
+            expect(result).toBeNull();
+            expect(spyTrackEvent).toHaveBeenLastCalledWith('ValidationAsync Succeeded', expect.objectContaining({ schema: 'schemaId' }));
+        });
+    });
+    describe('when the response is 422', () => {
+        it('should throw if the response includes a message', async () => {
+            const httpClient = getMockHttpClient({
+                '/validate': async () => respondWith({ message: 'error with this field' }, { status: 422 }),
+            });
+            const spyTrackEvent = vi.fn();
+            const performValidationAsync = getPerformValidationAsync({
+                httpClient,
+                trackEvent: spyTrackEvent,
+                validationAsyncConfig,
+                schemaId: 'schemaId',
+            });
+            await expect(performValidationAsync({ value: 'value', signal })).rejects.toThrow('error with this field');
+            expect(spyTrackEvent).toHaveBeenLastCalledWith('ValidationAsync Succeeded', expect.objectContaining({ schema: 'schemaId' }));
+        });
+        it('should respond with null if response does not include a message', async () => {
+            const httpClient = getMockHttpClient({
+                '/validate': async () => respondWith({}, { status: 422 }),
+            });
+            const spyTrackEvent = vi.fn();
+            const performValidationAsync = getPerformValidationAsync({
+                httpClient,
+                trackEvent: spyTrackEvent,
+                validationAsyncConfig,
+                schemaId: 'schemaId',
+            });
+            const result = await performValidationAsync({ value: 'value', signal });
+            expect(result).toBeNull();
+            expect(spyTrackEvent).toHaveBeenLastCalledWith('ValidationAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
+        });
+    });
+    describe('when the response is neither 2xx or 422', () => {
+        it('should track a failure and return null', async () => {
+            const analytics = { something: 'important' };
+            const httpClient = getMockHttpClient({
+                '/validate': async () => respondWith({ analytics }, { status: 500 }),
+            });
+            const spyTrackEvent = vi.fn();
+            const performValidationAsync = getPerformValidationAsync({
+                httpClient,
+                trackEvent: spyTrackEvent,
+                validationAsyncConfig,
+                schemaId: 'schemaId',
+            });
+            const result = await performValidationAsync({ value: 'value', signal });
+            expect(result).toBeNull();
+            expect(spyTrackEvent).toHaveBeenLastCalledWith('ValidationAsync Failed', expect.objectContaining({ schema: 'schemaId', something: 'important' }));
+        });
+        it('should track and throw if the request fails', async () => {
+            const httpClient = getMockHttpClient({
+                '/validate': async () => Promise.reject(new Error()),
+            });
+            const spyTrackEvent = vi.fn();
+            const performValidationAsync = getPerformValidationAsync({
+                httpClient,
+                trackEvent: spyTrackEvent,
+                validationAsyncConfig,
+                schemaId: 'schemaId',
+            });
+            await expect(performValidationAsync({ value: 'value', signal })).rejects.toThrow();
+            expect(spyTrackEvent).toHaveBeenLastCalledWith('ValidationAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
+        });
+    });
+    it('should track and throw if the request is aborted', async () => {
+        const signalController = new AbortController();
+        const httpClient = vi.fn().mockImplementation(async (input, init) => new Promise((resolve, reject) => {
+            var _a;
+            (_a = init === null || init === void 0 ? void 0 : init.signal) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', () => {
+                reject(new DOMException('Aborted', 'AbortError'));
+            });
+        }));
+        const spyTrackEvent = vi.fn();
+        const performValidationAsync = getPerformValidationAsync({
+            httpClient,
+            trackEvent: spyTrackEvent,
+            validationAsyncConfig,
+            schemaId: 'schemaId',
+        });
+        const request = performValidationAsync({ value: 'value', signal: signalController.signal });
+        signalController.abort();
+        await expect(request).rejects.toThrow('Aborted');
+        expect(spyTrackEvent).toHaveBeenLastCalledWith('ValidationAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
+    });
+});

package/build/domain/handlers/dismissHandler.js

@@ -0,0 +1,11 @@
+export const makeDismissHandler = (onDismiss, mapperProps) => () => {
+    const { url, method, body, headers } = onDismiss;
+    void mapperProps.httpClient(url, {
+        method,
+        body: method === 'GET' ? undefined : JSON.stringify(body),
+        headers,
+    })
+        .catch(() => {
+        // Dismiss requests are fire and forget.
+    });
+};

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

@@ -0,0 +1,18 @@
+import { createAlertComponent } from '../../components/AlertComponent';
+import { makeDismissHandler } from '../../handlers/dismissHandler';
+import { getDomainLayerCallToAction } from '../utils/call-to-action-utils';
+import { mapLegacyContext } from '../utils/legacy-utils';
+export const alertLayoutToComponent = (uid, { control, markdown, margin, context, callToAction, analyticsId, tags, title, media, onDismiss, secondaryCallToAction, }, mapperProps) => createAlertComponent({
+    uid,
+    analyticsId,
+    control,
+    markdown,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    callToAction: getDomainLayerCallToAction(callToAction, mapperProps),
+    context: mapLegacyContext(context !== null && context !== void 0 ? context : 'neutral'),
+    tags,
+    title,
+    media,
+    dismiss: onDismiss ? makeDismissHandler(onDismiss, mapperProps) : undefined,
+    secondaryCallToAction: getDomainLayerCallToAction(secondaryCallToAction, mapperProps),
+});

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

@@ -0,0 +1,13 @@
+import { createBoxComponent } from '../../components/BoxComponent';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+import { normaliseMarginInLastComponent } from '../utils/layout-utils';
+export const boxLayoutToComponent = (uid, { border = false, components, control, margin, width, analyticsId, tags }, mapperProps, schemaComponents) => createBoxComponent({
+    uid,
+    analyticsId,
+    border,
+    control,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    width: width !== null && width !== void 0 ? width : 'xl',
+    tags,
+    components: normaliseMarginInLastComponent(components).map((component, index) => mapLayoutToComponent(`${uid}.box-${index}`, component, mapperProps, schemaComponents)),
+});

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

@@ -0,0 +1,77 @@
+import { createButtonComponent } from '../../components/ButtonComponent';
+import { getDomainLayerBehavior, inlineAction } from '../utils/behavior-utils';
+import { mapLegacyActionTypeToContext, mapLegacyActionTypeToControl, mapLegacyContext, } from '../utils/legacy-utils';
+import { getDomainLayerMedia } from '../utils/media-utils';
+export const buttonLayoutToComponent = (uid, button, mapperProps) => {
+    if (!button.behavior &&
+        !button.action &&
+        mapperProps.features.isEnabled('strictButtonOperations')) {
+        throw new Error('ButtonLayout must have either a behavior or an action');
+    }
+    // Soon-to-be deprecated behaviour
+    if (!button.behavior && button.action) {
+        return buttonLayoutToComponentWithAction(uid, Object.assign(Object.assign({}, button), { action: button.action }), mapperProps);
+    }
+    return buttonLayoutToComponentWithBehavior(uid, button, mapperProps);
+};
+const buttonLayoutToComponentWithBehavior = (uid, button, mapperProps) => {
+    var _a;
+    const { onBehavior } = mapperProps;
+    const { context, control, disabled, margin, media, pinOrder, size, title, analyticsId, tags } = button;
+    const behavior = getDomainLayerBehavior(button, (_a = mapperProps.step.actions) !== null && _a !== void 0 ? _a : [], mapperProps.registerSubmissionBehavior);
+    const onClick = () => {
+        void onBehavior(behavior);
+    };
+    return createButtonComponent({
+        uid,
+        analyticsId,
+        context: mapLegacyContext(context !== null && context !== void 0 ? context : 'neutral'),
+        control,
+        disabled: disabled !== null && disabled !== void 0 ? disabled : false,
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        media: getDomainLayerMedia({ media }),
+        pinOrder,
+        size,
+        title: title !== null && title !== void 0 ? title : '',
+        onClick,
+        tags,
+    });
+};
+// Soon-to-be deprecated behaviour
+const buttonLayoutToComponentWithAction = (uid, button, mapperProps) => {
+    const { onBehavior, step } = mapperProps;
+    const { context, control, disabled, margin = 'md', media, pinOrder, size, title, analyticsId, tags, } = button;
+    const { action } = button;
+    const inlinedAction = action ? inlineAction(action, step === null || step === void 0 ? void 0 : step.actions) : {};
+    const onClick = () => {
+        void onBehavior({ type: 'action', action: inlinedAction, track: false });
+    };
+    return createButtonComponent({
+        uid,
+        context: getButtonContext({ context, action: inlinedAction }),
+        control: getButtonControl({ control, action: inlinedAction }),
+        disabled: getButtonDisabled({ disabled, action: inlinedAction }),
+        margin,
+        media: getDomainLayerMedia({ media }),
+        pinOrder,
+        size,
+        title: getButtonTitle({ title, action: inlinedAction }),
+        onClick,
+        analyticsId,
+        tags,
+    });
+};
+const getButtonTitle = ({ title, action }) => { var _a; return (_a = title !== null && title !== void 0 ? title : action === null || action === void 0 ? void 0 : action.title) !== null && _a !== void 0 ? _a : ''; };
+const getButtonDisabled = ({ disabled, action, }) => { var _a; return (_a = disabled !== null && disabled !== void 0 ? disabled : action === null || action === void 0 ? void 0 : action.disabled) !== null && _a !== void 0 ? _a : false; };
+const getButtonControl = ({ control, action }) => {
+    if (control) {
+        return control;
+    }
+    return (action === null || action === void 0 ? void 0 : action.type) ? mapLegacyActionTypeToControl(action.type) : undefined;
+};
+const getButtonContext = ({ context, action }) => {
+    if (context) {
+        return mapLegacyContext(context);
+    }
+    return (action === null || action === void 0 ? void 0 : action.type) ? mapLegacyActionTypeToContext(action.type) : 'neutral';
+};

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

@@ -0,0 +1,49 @@
+import { getDomainLayerCallToAction } from '../utils/call-to-action-utils';
+import { mapInlineAlert } from '../utils/utils';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+import { getDomainLayerBehavior } from '../utils/behavior-utils';
+import { createCollectionComponent } from '../../components/collectionComponent/CollectionComponent';
+import { getPerformCollectionQuery } from '../../features/collection/getPerformCollectionQuery';
+export const collectionLayoutToComponent = (uid, { analyticsId, control, initialState, margin, search, tags, baseRequest }, mapperProps) => {
+    const { httpClient, onComponentUpdate, trackEvent } = mapperProps;
+    const mapLayout = (layout, index) => mapLayoutToComponent(`${uid}-collection-response-${index}`, layout, mapperProps, []);
+    const mapState = (state) => mapCollectionSpecToDomainState(state, mapperProps, mapLayout);
+    const queryFunction = getPerformCollectionQuery(httpClient, baseRequest, mapState);
+    const component = createCollectionComponent({
+        uid,
+        analyticsId,
+        control,
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        tags,
+        state: mapState(initialState),
+        search,
+    }, onComponentUpdate, queryFunction, trackEvent);
+    return component;
+};
+export const mapCollectionSpecToDomainState = (specState, mapperProps, mapLayout) => {
+    const { sections, filters, beforeSections, afterSections, nextCursor, analytics = {}, } = specState;
+    return {
+        sections: sections.map((section) => {
+            var _a;
+            return Object.assign(Object.assign({}, section), { callToAction: getDomainLayerCallToAction(section.callToAction, mapperProps), help: (_a = section.help) === null || _a === void 0 ? void 0 : _a.markdown, inlineAlert: mapInlineAlert(section.inlineAlert), items: section.items.map((item) => {
+                    const behavior = getDomainLayerBehavior({ behavior: item.primaryBehavior }, [], mapperProps.registerSubmissionBehavior);
+                    return Object.assign(Object.assign({}, item), { id: item.entityId, onClick: item.primaryBehavior
+                            ? () => {
+                                void mapperProps.onBehavior(behavior);
+                            }
+                            : undefined, callToAction: getDomainLayerCallToAction(item.callToAction, mapperProps), inlineAlert: mapInlineAlert(item.inlineAlert) });
+                }) });
+        }),
+        filters: filters === null || filters === void 0 ? void 0 : filters.map(mapFilter),
+        beforeSections: beforeSections === null || beforeSections === void 0 ? void 0 : beforeSections.map(mapLayout),
+        afterSections: afterSections === null || afterSections === void 0 ? void 0 : afterSections.map(mapLayout),
+        nextCursor,
+        analytics,
+    };
+};
+const mapFilter = (filter) => {
+    const anySelected = filter.options.some((option) => option.selected);
+    return Object.assign(Object.assign({}, filter), { options: filter.options.map((option, index) => { var _a; return (Object.assign(Object.assign({}, option), { 
+            // if a single select with no selection, we should default to selecting the first item
+            selected: filter.multiSelect || anySelected ? ((_a = option.selected) !== null && _a !== void 0 ? _a : false) : index === 0, onSelect: () => { } })); }) });
+};

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

@@ -0,0 +1,13 @@
+import { createColumnsComponent } from '../../components/ColumnsComponent';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+import { mapLegacyBias } from '../utils/legacy-utils';
+export const columnsLayoutToComponent = (uid, { control, left, right, bias, margin, analyticsId, tags }, mapperProps, schemaComponents) => createColumnsComponent({
+    uid,
+    analyticsId,
+    control,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    bias: mapLegacyBias(bias !== null && bias !== void 0 ? bias : 'none'),
+    tags,
+    startComponents: left.map((component, index) => mapLayoutToComponent(`${uid}.columns-start-${index}`, component, mapperProps, schemaComponents)),
+    endComponents: right.map((component, index) => mapLayoutToComponent(`${uid}.columns-end-${index}`, component, mapperProps, schemaComponents)),
+});

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

@@ -0,0 +1,24 @@
+import { createDecisionComponent } from '../../components/DecisionComponent';
+import { getDomainLayerBehavior } from '../utils/behavior-utils';
+import { getHrefWithTracking } from '../utils/getHrefWithTracking';
+import { getDomainLayerMedia } from '../utils/media-utils';
+import { mapTags } from '../utils/tags-utils';
+import { mapInlineAlert } from '../utils/utils';
+export const decisionLayoutToComponent = (uid, { analyticsId, control, margin, options, tags, title, }, mapperProps) => createDecisionComponent({
+    uid,
+    analyticsId,
+    control,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    options: options.map((option) => mapOption(option, mapperProps)),
+    tags,
+    title,
+});
+const mapOption = (option, mapperProps) => {
+    var _a, _b;
+    const { step, onBehavior, trackEvent, registerSubmissionBehavior } = mapperProps;
+    const behavior = getDomainLayerBehavior(option, (_a = step.actions) !== null && _a !== void 0 ? _a : [], registerSubmissionBehavior);
+    const isLink = behavior.type === 'link';
+    return Object.assign(Object.assign({}, option), { disabled: (_b = option.disabled) !== null && _b !== void 0 ? _b : false, href: isLink ? behavior.url : undefined, media: getDomainLayerMedia(option), inlineAlert: mapInlineAlert(option.inlineAlert), tags: mapTags(option), hrefWithTracking: getHrefWithTracking({ behavior, onBehavior, trackEvent }), onClick: () => {
+            void onBehavior(behavior);
+        } });
+};

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

@@ -0,0 +1,30 @@
+import { createStatusListComponent } from '../../components/StatusListComponent';
+export const isDeprecatedListLayout = (layout) => {
+    return layout.items.some((item) => item.status);
+};
+export const deprecatedListLayoutToComponent = (uid, { analyticsId, control, items, margin, title, tags }) => createStatusListComponent({
+    uid,
+    analyticsId,
+    control,
+    items: items.map(({ description, icon, status, title: itemTitle, tags: itemTags }) => ({
+        description,
+        icon: icon !== null && icon !== void 0 ? icon : { text: '' },
+        title: itemTitle !== null && itemTitle !== void 0 ? itemTitle : '',
+        status: status ? mapLegacyStatus(status) : undefined,
+        tags: itemTags,
+    })),
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    title,
+    tags,
+});
+const mapLegacyStatus = (status) => {
+    switch (status) {
+        case 'positive':
+            return 'done';
+        case 'warning':
+            return 'pending';
+        case 'neutral':
+        default:
+            return 'not-done';
+    }
+};

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

@@ -0,0 +1,2 @@
+import { createDividerComponent } from '../../components/DividerComponent';
+export const dividerLayoutToComponent = (uid, { control, margin, analyticsId, tags }) => createDividerComponent({ uid, analyticsId, control, margin: margin !== null && margin !== void 0 ? margin : 'md', tags });

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

@@ -0,0 +1,19 @@
+import { createFormComponent } from '../../components/FormComponent';
+export const formLayoutToComponent = (uid, { analyticsId, schemaId, schema: schemaRef, control, margin, tags }, schemaComponents) => {
+    const id = schemaId !== null && schemaId !== void 0 ? schemaId : schemaRef === null || schemaRef === void 0 ? void 0 : schemaRef.$ref;
+    if (id == null) {
+        throw new Error('FormLayouts must refer to a schema. Set the `schemaId` property to the intended schema.');
+    }
+    const schemaComponent = schemaComponents.find((component) => component.schemaId === id);
+    if (!schemaComponent) {
+        throw new Error(`FormLayout with schemaId ${id} not found in inputComponents. The schema is probably missing in the step.schemas array.`);
+    }
+    return createFormComponent({
+        uid,
+        analyticsId,
+        schemaComponent,
+        control,
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        tags,
+    });
+};

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

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

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

@@ -0,0 +1,17 @@
+import { createImageComponent } from '../../components/ImageComponent';
+import { mapLegacyAlign } from '../utils/legacy-utils';
+export const imageLayoutToComponent = (uid, { analyticsId, accessibilityDescription, align, content, control, margin, size, tags, text, url, }) => { var _a, _b, _c; return createImageComponent({
+    uid,
+    analyticsId,
+    align: mapLegacyAlign(align !== null && align !== void 0 ? align : 'center'),
+    content: content
+        ? {
+            uri: (_b = (_a = content.uri) !== null && _a !== void 0 ? _a : content.url) !== null && _b !== void 0 ? _b : '',
+            accessibilityDescription: (_c = content.accessibilityDescription) !== null && _c !== void 0 ? _c : content.text,
+        }
+        : { accessibilityDescription: accessibilityDescription !== null && accessibilityDescription !== void 0 ? accessibilityDescription : text, uri: url !== null && url !== void 0 ? url : '' },
+    control,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    size: size !== null && size !== void 0 ? size : 'md',
+    tags,
+}); };

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

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

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

@@ -0,0 +1,12 @@
+import { createInstructionsComponent } from '../../components/InstructionsComponent';
+import { mapLegacyContext } from '../utils/legacy-utils';
+import { mapTags } from '../utils/tags-utils';
+export const instructionsLayoutToComponent = (uid, { analyticsId, control, items, margin, tags, title }) => createInstructionsComponent({
+    uid,
+    analyticsId,
+    control,
+    items: items.map((item) => (Object.assign(Object.assign({}, item), { context: mapLegacyContext(item.context), tags: mapTags(item) }))),
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    tags,
+    title,
+});

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

@@ -0,0 +1,39 @@
+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 { createListComponent } from '../../components/ListComponent';
+import { getDomainLayerCallToAction } from '../utils/call-to-action-utils';
+import { mapAdditionalInfo, mapInlineAlert } from '../utils/utils';
+import { getDomainLayerMedia } from '../utils/media-utils';
+import { mapTags } from '../utils/tags-utils';
+export const listLayoutToComponent = (uid, { analyticsId, callToAction, control, items, margin, tags, title }, mapperProps) => {
+    return createListComponent({
+        uid,
+        analyticsId,
+        control,
+        items: items.map((item) => mapItem(item, mapperProps)),
+        callToAction: getDomainLayerCallToAction(callToAction, mapperProps),
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        tags,
+        title,
+    });
+};
+const mapItem = (item, mapperProps) => {
+    const { value, subvalue, subtitle, callToAction, description, icon, image, media, additionalInfo, inlineAlert } = item, rest = __rest(item, ["value", "subvalue", "subtitle", "callToAction", "description", "icon", "image", "media", "additionalInfo", "inlineAlert"]);
+    return Object.assign(Object.assign({}, rest), { description: description !== null && description !== void 0 ? description : subtitle, media: getDomainLayerMedia({ icon, image, media }), supportingValues: mapSupportingValues(item), additionalInfo: mapAdditionalInfo(additionalInfo, mapperProps), inlineAlert: mapInlineAlert(inlineAlert), callToAction: getDomainLayerCallToAction(callToAction, mapperProps), tags: mapTags(rest) });
+};
+const mapSupportingValues = (item) => {
+    const { value, subvalue, supportingValues } = item;
+    if (supportingValues) {
+        return supportingValues;
+    }
+    return value || subvalue ? { value, subvalue } : undefined;
+};

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

@@ -0,0 +1,9 @@
+import { createLoadingIndicatorComponent } from '../../components/LoadingIndicatorComponent';
+export const loadingIndicatorLayoutToComponent = (uid, { analyticsId, control, margin, size, tags }) => createLoadingIndicatorComponent({
+    uid,
+    analyticsId,
+    control,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    size: size !== null && size !== void 0 ? size : 'md',
+    tags,
+});

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

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

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

@@ -0,0 +1,12 @@
+import { createMediaComponent } from '../../components/MediaComponent';
+import { mapLegacyAlign } from '../utils/legacy-utils';
+export const mediaLayoutToComponent = (uid, { analyticsId, align, control, margin, media, size, tags }) => createMediaComponent({
+    uid,
+    analyticsId,
+    align: mapLegacyAlign(align !== null && align !== void 0 ? align : 'center'),
+    control,
+    margin: margin !== null && margin !== void 0 ? margin : 'md',
+    media,
+    size: size !== null && size !== void 0 ? size : 'md',
+    tags,
+});

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

@@ -0,0 +1,17 @@
+import { createModalComponent } from '../../components/ModalLayoutComponent';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+export const modalLayoutToComponent = (uid, { analyticsId, content, control, margin, tags, trigger }, mapperProps, schemaComponents) => {
+    const { components, title } = content;
+    return createModalComponent({
+        uid,
+        analyticsId,
+        content: {
+            components: components.map((component, index) => mapLayoutToComponent(`${uid}.modal-${index}`, component, mapperProps, schemaComponents)),
+            title,
+        },
+        control,
+        margin: margin !== null && margin !== void 0 ? margin : 'md',
+        tags,
+        trigger,
+    });
+};

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

@@ -0,0 +1,8 @@
+import { createModalContentComponent } from '../../components/ModalComponent';
+import { getRandomId } from '../../components/utils/getRandomId';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+export const modalToComponent = (uid, { content, title }, mapperProps, schemaComponents) => createModalContentComponent({
+    uid: `${uid}-modal-${getRandomId()}`,
+    title,
+    components: content.map((component, index) => mapLayoutToComponent(`${uid}.modal-${index}`, component, mapperProps, schemaComponents)),
+}, mapperProps.onComponentUpdate);