@wise/dynamic-flow-client 5.25.1 → 5.25.2

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

@@ -0,0 +1,319 @@
+import { waitFor } from '@testing-library/react';
+import { vi } from 'vitest';
+import { mapStepToComponent } from './mapStepToComponent';
+import { getStepMapperProps } from './schema/tests/test-utils';
+import { FeatureFlags } from './utils/FeatureFlags';
+describe('mapStepToComponent', () => {
+    describe('javascript URLs', () => {
+        const baseStep = {
+            id: 'step',
+            title: 'Title',
+            schemas: [],
+            layout: [],
+        };
+        /* eslint-disable no-script-url */
+        const javascriptUrls = [
+            'javascript:alert(document.domain)',
+            'JAVASCRIPT:alert(document.domain)',
+            ' javascript:alert(document.domain)',
+            '\u0001javascript:alert(document.domain)',
+            'java\tscript:alert(document.domain)',
+            'java\nscript:alert(document.domain)',
+            'java\rscript:alert(document.domain)',
+        ];
+        /* eslint-enable no-script-url */
+        it.each([
+            ['external', Object.assign(Object.assign({}, baseStep), { external: { url: javascriptUrls[0] } })],
+            ['onLoad', Object.assign(Object.assign({}, baseStep), { onLoad: { type: 'link', url: javascriptUrls[0] } })],
+            [
+                'LinkBehavior',
+                Object.assign(Object.assign({}, baseStep), { layout: [
+                        {
+                            type: 'button',
+                            title: 'Open link',
+                            behavior: { type: 'link', url: javascriptUrls[0] },
+                        },
+                    ] }),
+            ],
+        ])('throws for a javascript URL in %s', (_, step) => {
+            expect(() => mapStepToComponent(Object.assign(Object.assign({}, getStepMapperProps()), { step }))).toThrow('Javascript URLs are not allowed');
+        });
+        it.each(javascriptUrls)('throws for the browser-normalised URL %j', (url) => {
+            const step = Object.assign(Object.assign({}, baseStep), { onLoad: { type: 'link', url } });
+            expect(() => mapStepToComponent(Object.assign(Object.assign({}, getStepMapperProps()), { step }))).toThrow('Javascript URLs are not allowed');
+        });
+        it.each([
+            '/relative-link',
+            'https://example.com',
+            'mailto:person@example.com',
+            'wise://example/path',
+        ])('preserves the allowed URL %s', (url) => {
+            var _a;
+            const step = Object.assign(Object.assign({}, baseStep), { external: { url } });
+            const component = mapStepToComponent(Object.assign(Object.assign({}, getStepMapperProps()), { step }));
+            expect((_a = component.externalConfirmation) === null || _a === void 0 ? void 0 : _a.url).toBe(url);
+        });
+    });
+    it('returns a StepDomainComponent', () => {
+        const step = {
+            id: 'step',
+            title: '',
+            schemas: [],
+            layout: [],
+        };
+        const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: true });
+        expect(mapStepToComponent(mapperProps)).toEqual(expect.objectContaining({
+            type: 'step',
+        }));
+    });
+    describe('when a button with an action reference is given', () => {
+        const step = {
+            id: 'step',
+            title: 'Title',
+            schemas: [],
+            actions: [
+                {
+                    $id: 'action-id',
+                    title: 'Action title',
+                    url: '/submit',
+                    type: 'primary',
+                    method: 'POST',
+                },
+            ],
+            layout: [{ type: 'button', action: { $ref: 'action-id' } }],
+        };
+        it('returns a composition with a ButtonComponent with the correct action', async () => {
+            const onBehavior = vi.fn();
+            const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, onBehavior });
+            const stepComponent = mapStepToComponent(mapperProps);
+            expect(stepComponent.layoutComponents[0]).toMatchObject({ type: 'button' });
+            const btn = stepComponent.layoutComponents[0];
+            btn.onClick();
+            await waitFor(() => {
+                expect(onBehavior).toHaveBeenCalledWith(expect.objectContaining({
+                    type: 'action',
+                    action: expect.objectContaining(step.actions[0]),
+                }));
+            });
+        });
+        it('throws if the reference is invalid', async () => {
+            const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { displayStepTitle: false, step: Object.assign(Object.assign({}, step), { layout: [{ type: 'button', action: { $ref: 'WRONG-action-id' } }] }) });
+            expect(() => mapStepToComponent(mapperProps)).toThrow('Action reference not found in actions array.');
+        });
+    });
+    describe('when a decision with an action reference is given', () => {
+        const step = {
+            id: 'step',
+            title: 'Title',
+            schemas: [],
+            actions: [
+                {
+                    $id: 'action-id',
+                    title: 'Action title',
+                    url: '/submit',
+                    type: 'primary',
+                    method: 'POST',
+                },
+            ],
+            layout: [
+                { type: 'decision', options: [{ title: 'Option 1 Title', action: { $ref: 'action-id' } }] },
+            ],
+        };
+        it('returns a composition with a DecisionComponent with the correct action', async () => {
+            const onBehavior = vi.fn();
+            const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, onBehavior });
+            const stepComponent = mapStepToComponent(mapperProps);
+            expect(stepComponent.layoutComponents[0]).toMatchObject({ type: 'decision' });
+            const decision = stepComponent.layoutComponents[0];
+            decision.options[0].onClick();
+            await waitFor(() => {
+                expect(onBehavior).toHaveBeenCalledWith(expect.objectContaining({
+                    type: 'action',
+                    action: expect.objectContaining(step.actions[0]),
+                }));
+            });
+        });
+        it('throws if the reference is invalid', async () => {
+            const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { displayStepTitle: false, step: Object.assign(Object.assign({}, step), { layout: [
+                        {
+                            type: 'decision',
+                            options: [{ title: 'Option 1 Title', action: { $ref: 'WRONG-action-id' } }],
+                        },
+                    ] }) });
+            expect(() => mapStepToComponent(mapperProps)).toThrow('Action reference not found in actions array.');
+        });
+    });
+    describe('pinned buttons', () => {
+        const action = {
+            url: '/submit',
+            method: 'POST',
+        };
+        const createStepWithButtons = (buttons) => ({
+            id: 'step',
+            title: 'Title',
+            schemas: [],
+            layout: buttons.map(({ pinOrder }) => (Object.assign({ type: 'button', action }, (pinOrder !== undefined && { pinOrder })))),
+        });
+        describe('when pinned buttons feature is enabled', () => {
+            it('separates pinned and non-pinned buttons correctly', () => {
+                const step = createStepWithButtons([
+                    { pinOrder: 0, type: 'button' },
+                    { type: 'button' },
+                    { pinOrder: 1, type: 'button' },
+                ]);
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({ pinnedButtons: true }) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.layoutComponents).toHaveLength(1);
+                expect(stepComponent.layoutComponents[0]).toMatchObject({ type: 'button' });
+                expect(stepComponent.footerComponents).toHaveLength(2);
+                expect(stepComponent.footerComponents[0]).toMatchObject({ type: 'button', pinOrder: 0 });
+                expect(stepComponent.footerComponents[1]).toMatchObject({ type: 'button', pinOrder: 1 });
+            });
+            it('puts all buttons in layoutComponents when none are pinned', () => {
+                const step = createStepWithButtons([
+                    { type: 'button' },
+                    { type: 'button' },
+                    { type: 'button' },
+                ]);
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({ pinnedButtons: true }) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.layoutComponents).toHaveLength(3);
+                expect(stepComponent.footerComponents).toHaveLength(0);
+            });
+            it('puts all buttons in footerComponents when all are pinned', () => {
+                const step = createStepWithButtons([
+                    { pinOrder: 0, type: 'button' },
+                    { pinOrder: 1, type: 'button' },
+                    { pinOrder: 2, type: 'button' },
+                ]);
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({ pinnedButtons: true }) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.layoutComponents).toHaveLength(0);
+                expect(stepComponent.footerComponents).toHaveLength(3);
+            });
+            it('applies margin "xs" to the last pinned button when margin is undefined', () => {
+                const step = createStepWithButtons([
+                    { pinOrder: 0, type: 'button' },
+                    { pinOrder: 1, type: 'button' },
+                ]);
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({ pinnedButtons: true }) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.footerComponents).toHaveLength(2);
+                expect(stepComponent.footerComponents[1]).toMatchObject({
+                    type: 'button',
+                    margin: 'xs',
+                });
+            });
+            it('preserves existing margin on the last pinned button', () => {
+                const step = {
+                    id: 'step',
+                    title: 'Title',
+                    schemas: [],
+                    layout: [
+                        {
+                            type: 'button',
+                            action,
+                            pinOrder: 1,
+                            margin: 'lg',
+                        },
+                    ],
+                };
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({ pinnedButtons: true }) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.footerComponents[0]).toMatchObject({
+                    type: 'button',
+                    margin: 'lg',
+                });
+            });
+        });
+        describe('when pinned buttons feature is disabled', () => {
+            it('puts all buttons in layoutComponents regardless of pinOrder', () => {
+                const step = createStepWithButtons([
+                    { pinOrder: 0, type: 'button' },
+                    { type: 'button' },
+                    { pinOrder: 1, type: 'button' },
+                ]);
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({}) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.layoutComponents).toHaveLength(3);
+                expect(stepComponent.footerComponents).toHaveLength(0);
+            });
+            it('ignores pinOrder when feature is explicitly set to false', () => {
+                const step = createStepWithButtons([
+                    { pinOrder: 0, type: 'button' },
+                    { pinOrder: 1, type: 'button' },
+                ]);
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({ pinnedButtons: false }) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.layoutComponents).toHaveLength(2);
+                expect(stepComponent.footerComponents).toHaveLength(0);
+            });
+            it('works with mixed layout components when feature is disabled', () => {
+                const step = {
+                    id: 'step',
+                    title: 'Title',
+                    schemas: [],
+                    layout: [
+                        {
+                            type: 'button',
+                            action,
+                            pinOrder: 0,
+                        },
+                    ],
+                };
+                const mapperProps = Object.assign(Object.assign({}, getStepMapperProps()), { step, displayStepTitle: false, features: new FeatureFlags({}) });
+                const stepComponent = mapStepToComponent(mapperProps);
+                expect(stepComponent.layoutComponents).toHaveLength(1);
+                expect(stepComponent.footerComponents).toHaveLength(0);
+            });
+        });
+    });
+    describe('when an onLoad is provided', () => {
+        it('is triggered when a step is started', () => {
+            const step = {
+                id: 'id',
+                title: 'title',
+                schemas: [],
+                layout: [],
+                onLoad: {
+                    type: 'action',
+                    action: {
+                        url: '/test',
+                        method: 'POST',
+                    },
+                },
+            };
+            const onBehavior = vi.fn();
+            const component = mapStepToComponent(Object.assign(Object.assign({}, getStepMapperProps()), { onBehavior,
+                step }));
+            expect(onBehavior).not.toHaveBeenCalled();
+            component.start();
+            expect(onBehavior).toHaveBeenCalledTimes(1);
+            component.start();
+            expect(onBehavior).toHaveBeenCalledTimes(1);
+        });
+        describe('when the onLoad is a LinkBehavior and external is provided', () => {
+            it('uses the onLoad, but passes it via the external config', () => {
+                var _a;
+                const step = {
+                    id: 'id',
+                    title: 'title',
+                    schemas: [],
+                    layout: [],
+                    external: { url: 'bing.com' },
+                    onLoad: {
+                        type: 'link',
+                        url: 'google.com',
+                    },
+                };
+                const onBehavior = vi.fn();
+                const component = mapStepToComponent(Object.assign(Object.assign({}, getStepMapperProps()), { onBehavior,
+                    step }));
+                component.start();
+                expect(onBehavior).not.toHaveBeenCalled();
+                expect(component.externalConfirmation).not.toBeNullable();
+                expect((_a = component.externalConfirmation) === null || _a === void 0 ? void 0 : _a.url).toBe('google.com');
+            });
+        });
+    });
+});

package/build/domain/mappers/mapToolbarToComponent.js

@@ -0,0 +1,15 @@
+import { getDomainLayerBehavior } from './utils/behavior-utils';
+import { mapLegacyContext } from './utils/legacy-utils';
+export const mapToolbarToComponent = (uid, toolbar, mapperProps) => {
+    if (!toolbar) {
+        return undefined;
+    }
+    const { onBehavior } = mapperProps;
+    return Object.assign(Object.assign({}, toolbar), { type: 'toolbar', uid: `${uid}.toolbar`, tags: toolbar.tags, items: toolbar.items.map((item) => {
+            const context = item.context ? mapLegacyContext(item.context) : undefined;
+            const behavior = getDomainLayerBehavior({ behavior: item.behavior }, [], mapperProps.registerSubmissionBehavior);
+            return Object.assign(Object.assign({}, item), { context: context ? mapLegacyContext(context) : undefined, disabled: !!item.disabled, tags: item.tags, onClick: () => {
+                    void onBehavior(behavior);
+                } });
+        }) });
+};

package/build/domain/mappers/schema/allOfSchemaToComponent.js

@@ -0,0 +1,17 @@
+import { createAllOfComponent } from '../../components/AllOfComponent';
+import { mapSchemaToComponent } from '../mapSchemaToComponent';
+import { mapCommonSchemaProps } from './utils/mapCommonSchemaProps';
+export const allOfSchemaToComponent = (schemaMapperProps, mapperProps) => {
+    const { uid, schema, localValue, model, required, validationErrors, onValueChange } = schemaMapperProps;
+    const { allOf } = schema;
+    const components = allOf.map((childSchema, index) => mapSchemaToComponent({
+        uid: `${uid}.allOf-${index}`,
+        schema: childSchema,
+        model,
+        localValue,
+        required,
+        validationErrors,
+        onValueChange,
+    }, mapperProps));
+    return createAllOfComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { components }));
+};

package/build/domain/mappers/schema/arraySchemaToComponent/arraySchemaToComponent.js

@@ -0,0 +1,26 @@
+import { arraySchemaToRepeatableComponent } from './arraySchemaToRepeatableComponent';
+import { isArrayListSchema, isArrayModel, isStringSchemaWithUpload, isSchemaWithPersistAsync, isBlobSchema, isConstSchema, isArrayTupleSchema, } from '../../../../utils/type-utils';
+import { isNullish } from '../../../../utils/type-validators';
+import { arraySchemaToMultiUploadComponent } from './arraySchemaToMultiUploadComponent';
+import { arraySchemaToMultiSelectComponent } from './arraySchemaToMultiSelectComponent';
+import { arraySchemaToTupleComponent } from './arraySchemaToTupleComponent';
+export const arraySchemaToComponent = (schemaMapperProps, mapperProps) => {
+    const { schema, model: originalModel } = schemaMapperProps;
+    const model = isNullish(originalModel) || isArrayModel(originalModel) ? originalModel : null;
+    if (isArraySchemaListWithMultiFileUpload(schema)) {
+        return arraySchemaToMultiUploadComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema, model }), mapperProps);
+    }
+    if (isArraySchemaListWithMultiSelect(schema)) {
+        return arraySchemaToMultiSelectComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema, model }), mapperProps);
+    }
+    if (isArrayTupleSchema(schema)) {
+        return arraySchemaToTupleComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema, model }), mapperProps);
+    }
+    return arraySchemaToRepeatableComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema, model }), mapperProps);
+};
+const isArraySchemaListWithMultiFileUpload = (schema) => isArrayListSchema(schema) &&
+    (isPersistAsyncWithUploadSchema(schema.items) || isStringSchemaWithUpload(schema.items));
+const isPersistAsyncWithUploadSchema = (schema) => isSchemaWithPersistAsync(schema) &&
+    (isBlobSchema(schema.persistAsync.schema) ||
+        isStringSchemaWithUpload(schema.persistAsync.schema));
+const isArraySchemaListWithMultiSelect = (schema) => isArrayListSchema(schema) && 'oneOf' in schema.items && schema.items.oneOf.every(isConstSchema);

package/build/domain/mappers/schema/arraySchemaToComponent/arraySchemaToMultiSelectComponent.js

@@ -0,0 +1,56 @@
+import { createMultiSelectComponent } from '../../../components/MultiSelectInputComponent';
+import { getSchemaOnChange } from '../../../features/schema-on-change/getSchemaOnChange';
+import { getAboveMaxItemsCheck, getBelowMinItemsCheck, getRequiredCheck, } from '../../../features/validation/value-checks';
+import { mapSchemaToComponent } from '../../mapSchemaToComponent';
+import { getDomainLayerMedia } from '../../utils/media-utils';
+import { mapInlineAlert } from '../../utils/utils';
+import { getValidationAsyncInitialState } from '../utils/getValidationAsyncInitialState';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export const arraySchemaToMultiSelectComponent = (schemaMapperProps, mapperProps) => {
+    const { uid, localValue, schema, model, required = false, validationErrors: initialError, onValueChange, } = schemaMapperProps;
+    const initialModel = model !== null && model !== void 0 ? model : null;
+    const options = schema.items.oneOf.map((childSchema, index) => {
+        var _a;
+        const { title = '', description, image, icon, media, keywords = [], tags } = childSchema;
+        return {
+            title,
+            description,
+            media: getDomainLayerMedia({ icon, image, media }),
+            keywords,
+            tags,
+            disabled: 'disabled' in childSchema ? Boolean(childSchema.disabled) : false,
+            analyticsId: (_a = childSchema.analyticsId) !== null && _a !== void 0 ? _a : childSchema.$id,
+            additionalText: childSchema.additionalText,
+            inlineAlert: mapInlineAlert(childSchema.inlineAlert),
+            supportingValues: childSchema.supportingValues,
+            component: mapSchemaToComponent({
+                uid: `${uid}.oneOf-${index}`,
+                schema: childSchema,
+                model: initialModel,
+                localValue,
+                validationErrors: initialError,
+                required,
+                onValueChange,
+            }, mapperProps),
+        };
+    });
+    const { maxItems, minItems, title, validationMessages } = schema;
+    const { getErrorMessageFunctions, onBehavior, onComponentUpdate } = mapperProps;
+    const errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    const { performValidationAsync, validationAsyncState } = getValidationAsyncInitialState(schemaMapperProps, mapperProps);
+    const initialValue = model !== null && model !== void 0 ? model : null;
+    return createMultiSelectComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: 'off', checks: schema.hidden
+            ? []
+            : [
+                getRequiredCheck(required, errorMessageFunctions),
+                getAboveMaxItemsCheck(schema, errorMessageFunctions),
+                getBelowMinItemsCheck(schema, errorMessageFunctions),
+            ], initialValue,
+        maxItems,
+        minItems,
+        options,
+        required,
+        title,
+        validationAsyncState,
+        performValidationAsync, schemaOnChange: getSchemaOnChange(schema, onBehavior), onValueChange }), onComponentUpdate);
+};

package/build/domain/mappers/schema/arraySchemaToComponent/arraySchemaToMultiUploadComponent.js

@@ -0,0 +1,66 @@
+import { isBlobSchema, isSchemaWithPersistAsync, isStringSchemaWithUpload, } from '../../../../utils/type-utils';
+import { isArray, isFile } from '../../../../utils/type-validators';
+import { createMultiUploadInputComponent } from '../../../components/MultiUploadInputComponent';
+import { getInitialPersistedState } from '../../../features/persistAsync/getInitialPersistedState';
+import { getAboveMaxFilesCheck, getBelowMinFilesCheck, getFileSizeCheck, getFileTypeCheck, getRequiredCheck, } from '../../../features/validation/value-checks';
+import { getPerformPersistAsyncFn } from '../utils/getPerformPersistAsyncFn';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export const arraySchemaToMultiUploadComponent = (schemaMapperProps, mapperProps) => {
+    var _a;
+    const { getErrorMessageFunctions } = mapperProps;
+    const { localValue, model, schema, required = false, onValueChange } = schemaMapperProps;
+    const uploadSchema = getUploadSchema(schema.items);
+    const { accepts, cameraConfig, maxSize } = uploadSchema;
+    const { minItems, maxItems, title, validationMessages } = schema;
+    const arrayErrorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    const fileErrorMessageFunctions = getErrorMessageFunctions(uploadSchema.validationMessages);
+    const checks = [
+        getRequiredCheck(required, arrayErrorMessageFunctions),
+        getAboveMaxFilesCheck(schema, arrayErrorMessageFunctions),
+        getBelowMinFilesCheck(schema, arrayErrorMessageFunctions),
+    ];
+    const fileChecks = [
+        getFileSizeCheck(schema.items, fileErrorMessageFunctions),
+        getFileTypeCheck(schema.items, fileErrorMessageFunctions),
+    ];
+    const persistAsyncConfig = getPersistAsyncConfig(schema.items);
+    const format = getFormat(schema.items);
+    const combinedSchemaProps = Object.assign(Object.assign({}, schemaMapperProps), { persistAsyncConfig, schema: Object.assign(Object.assign({}, uploadSchema), { hidden: (_a = schema.hidden) !== null && _a !== void 0 ? _a : uploadSchema.hidden, alert: schema.alert }) });
+    const performPersistAsync = persistAsyncConfig
+        ? getPerformPersistAsyncFn(combinedSchemaProps.schema, persistAsyncConfig, mapperProps)
+        : undefined;
+    const value = performPersistAsync ? getValueForPersistAsync(localValue) : [];
+    const persistedState = performPersistAsync && isArray(model)
+        ? model.map((itemModel) => getInitialPersistedState(null, itemModel))
+        : [];
+    return createMultiUploadInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(combinedSchemaProps)), { title,
+        cameraConfig, uploadLabel: uploadSchema.title, accepts, autoComplete: 'off', checks: schema.hidden ? [] : checks, fileChecks: schema.hidden ? [] : fileChecks, format,
+        maxSize,
+        minItems,
+        maxItems,
+        required, source: uploadSchema.source, value,
+        persistedState,
+        performPersistAsync,
+        onValueChange }), mapperProps.onComponentUpdate);
+};
+const getFormat = (schema) => {
+    if (isStringSchemaWithUpload(schema)) {
+        return 'base64';
+    }
+    return isBlobSchema(schema.persistAsync.schema) ? 'blob' : 'base64';
+};
+const getUploadSchema = (schema) => {
+    if (isStringSchemaWithUpload(schema)) {
+        return schema;
+    }
+    return schema.persistAsync.schema;
+};
+const getPersistAsyncConfig = (schema) => {
+    if (!isSchemaWithPersistAsync(schema)) {
+        return undefined;
+    }
+    const { persistAsync } = schema;
+    const { idProperty, method, param, url } = persistAsync;
+    return { idProperty, method, param, url };
+};
+const getValueForPersistAsync = (localValue) => isArray(localValue) && localValue.every(isFile) ? localValue : [];

package/build/domain/mappers/schema/arraySchemaToComponent/arraySchemaToRepeatableComponent.js

@@ -0,0 +1,58 @@
+import { isArray, isObject } from '../../../../utils/type-validators';
+import { createRepeatableComponent } from '../../../components/RepeatableComponent';
+import { getAboveMaxItemsCheck, getBelowMinItemsCheck, getRequiredCheck, } from '../../../features/validation/value-checks';
+import { mapSchemaToComponent } from '../../mapSchemaToComponent';
+import { getDomainLayerMedia } from '../../utils/media-utils';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export const arraySchemaToRepeatableComponent = (schemaMapperProps, mapperProps) => {
+    const { getErrorMessageFunctions } = mapperProps;
+    const { uid, localValue, schema, model: initialModel, required = false, validationErrors, onValueChange, } = schemaMapperProps;
+    const { items, addItemTitle, editItemTitle, maxItems, minItems, summary } = schema;
+    const value = isArray(localValue) ? localValue : [];
+    const components = initialModel === null || initialModel === void 0 ? void 0 : initialModel.map((item, index) => mapSchemaToComponent({
+        uid: `${uid}.arr-${index}`,
+        schema: items,
+        model: item,
+        localValue: value === null || value === void 0 ? void 0 : value[index],
+        // TODO tests for this
+        validationErrors,
+        onValueChange,
+    }, mapperProps));
+    const createEditableComponent = (editableValue) => mapSchemaToComponent({
+        uid: `${uid}.arr-rnd-${getRandomInt()}`,
+        schema: items,
+        localValue: editableValue,
+        model: localValueToJsonElement(editableValue),
+        validationErrors: undefined,
+        required: true,
+        onValueChange,
+    }, mapperProps);
+    const errorMessageFunctions = getErrorMessageFunctions(schema.validationMessages);
+    return createRepeatableComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { addItemTitle, checks: schema.hidden
+            ? []
+            : [
+                getRequiredCheck(required, errorMessageFunctions),
+                getAboveMaxItemsCheck(schema, errorMessageFunctions),
+                getBelowMinItemsCheck(schema, errorMessageFunctions),
+            ], components: components !== null && components !== void 0 ? components : [], editItemTitle,
+        maxItems,
+        minItems, summary: Object.assign(Object.assign({}, summary), { defaultMedia: getDomainLayerMedia({
+                icon: summary === null || summary === void 0 ? void 0 : summary.defaultIcon,
+                image: summary === null || summary === void 0 ? void 0 : summary.defaultImage,
+                media: summary === null || summary === void 0 ? void 0 : summary.defaultMedia,
+            }) }), createEditableComponent,
+        onValueChange }), mapperProps.onComponentUpdate);
+};
+const localValueToJsonElement = (localValue) => {
+    if (localValue instanceof Array) {
+        return localValue.map(localValueToJsonElement);
+    }
+    if (isObject(localValue)) {
+        return Object.fromEntries(Object.entries(localValue).map(([key, value]) => [key, localValueToJsonElement(value)]));
+    }
+    if (localValue instanceof File) {
+        return localValue.name;
+    }
+    return localValue;
+};
+const getRandomInt = () => Math.floor(Math.random() * 100000000);

package/build/domain/mappers/schema/arraySchemaToComponent/arraySchemaToTupleComponent.js

@@ -0,0 +1,18 @@
+import { isArray } from '../../../../utils/type-validators';
+import { createTupleComponent } from '../../../components/TupleComponent';
+import { mapSchemaToComponent } from '../../mapSchemaToComponent';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export const arraySchemaToTupleComponent = (schemaMapperProps, mapperProps) => {
+    const { uid, localValue, schema, model: initialModel, required = false, validationErrors, onValueChange, } = schemaMapperProps;
+    const { items } = schema;
+    const components = items.map((childSchema, index) => { var _a, _b; return mapSchemaToComponent({
+        uid: `${uid}-arr.${index}`,
+        schema: childSchema,
+        model: isArray(initialModel) ? ((_a = initialModel[index]) !== null && _a !== void 0 ? _a : null) : null,
+        localValue: isArray(localValue) ? ((_b = localValue[index]) !== null && _b !== void 0 ? _b : null) : null,
+        validationErrors: isArray(validationErrors) ? validationErrors[index] : undefined,
+        required,
+        onValueChange,
+    }, mapperProps); });
+    return createTupleComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { components }));
+};

package/build/domain/mappers/schema/blobSchemaToComponent.js

@@ -0,0 +1,15 @@
+import { isFile } from '../../../utils/type-validators';
+import { createUploadInputComponent } from '../../components/UploadInputComponent';
+import { getRequiredCheck } from '../../features/validation/value-checks';
+import { mapCommonSchemaProps } from './utils/mapCommonSchemaProps';
+export const blobSchemaToComponent = (schemaMapperProps, mapperProps) => {
+    const { schema, localValue, model, required = false, onPersistAsync, onValueChange, } = schemaMapperProps;
+    const { accepts, cameraConfig, maxSize, source, validationMessages } = schema;
+    const { getErrorMessageFunctions, onComponentUpdate } = mapperProps;
+    const errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    const validLocalValue = isFile(localValue) ? localValue : null;
+    const value = onPersistAsync && model !== null ? validLocalValue : null;
+    return createUploadInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { accepts, autoComplete: 'off', cameraConfig, format: 'blob', maxSize,
+        source,
+        value, checks: schema.hidden ? [] : [getRequiredCheck(required, errorMessageFunctions)], schemaOnChange: undefined, onValueChange }), onComponentUpdate);
+};

package/build/domain/mappers/schema/booleanSchemaToComponent.js

@@ -0,0 +1,29 @@
+import { isBoolean } from '../../../utils/type-validators';
+import { createBooleanInputComponent } from '../../components/BooleanInputComponent';
+import { getSchemaOnChange } from '../../features/schema-on-change/getSchemaOnChange';
+import { mapInlineAlert } from '../utils/utils';
+import { getValidationAsyncInitialState } from './utils/getValidationAsyncInitialState';
+import { mapCommonSchemaProps } from './utils/mapCommonSchemaProps';
+export const booleanSchemaToComponent = (schemaMapperProps, mapperProps) => {
+    const { schema, localValue, model, onPersistAsync, onValueChange } = schemaMapperProps;
+    const { default: defaultValue, additionalText, inlineAlert, supportingValues } = schema;
+    const { onComponentUpdate, onBehavior } = mapperProps;
+    const schemaOnChange = getSchemaOnChange(schema, onBehavior);
+    const { performValidationAsync, validationAsyncState } = getValidationAsyncInitialState(schemaMapperProps, mapperProps);
+    const validLocalValue = isBoolean(localValue) ? localValue : false;
+    const validModel = getValidModel(model, defaultValue);
+    const value = onPersistAsync ? validLocalValue : validModel;
+    return createBooleanInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { additionalText, inlineAlert: mapInlineAlert(inlineAlert), schemaOnChange,
+        supportingValues,
+        validationAsyncState, value: value !== null && value !== void 0 ? value : false, performValidationAsync,
+        onValueChange }), onComponentUpdate);
+};
+const getValidModel = (model, defaultValue) => {
+    if (isBoolean(model)) {
+        return model;
+    }
+    if (isBoolean(defaultValue)) {
+        return defaultValue;
+    }
+    return false;
+};

package/build/domain/mappers/schema/constSchemaToComponent.js

@@ -0,0 +1,23 @@
+import { createConstComponent } from '../../components/ConstComponent';
+import { getConstSummary } from '../../features/summary/summary-utils';
+import { mapLayoutToComponent } from '../mapLayoutToComponent';
+export const constSchemaToComponent = (uid, schemaMapperProps, mapperProps) => {
+    var _a;
+    const { schema, schemaId } = schemaMapperProps;
+    const { title, const: constValue, analyticsId, $id, layout, alert, hidden, tags } = schema;
+    const titleOrValue = (_a = title !== null && title !== void 0 ? title : constValue) !== null && _a !== void 0 ? _a : null;
+    return createConstComponent({
+        uid,
+        schemaId,
+        analyticsId: analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id,
+        summary: getConstSummary(schema, titleOrValue),
+        value: schema.const,
+        layout: getConstLayout(uid, mapperProps, layout, alert),
+        hidden: Boolean(hidden),
+        tags,
+    });
+};
+const getConstLayout = (uid, mapperProps, layout, alert) => {
+    const items = layout !== null && layout !== void 0 ? layout : (alert ? [alert] : []);
+    return items.map((item, index) => mapLayoutToComponent(`${uid}-layout.${index}`, item, mapperProps, []));
+};