@wise/dynamic-flow-client 5.8.1 → 5.9.0

package/build/domain/mappers/schema/oneOfSchemaToComponent/oneOfSchemaToComponent.test.js

@@ -0,0 +1,265 @@
+import { getMockMapperProps, getMockSchemaMapperProps } from '../tests/test-utils';
+import { oneOfSchemaToComponent } from './oneOfSchemaToComponent';
+describe('oneOfSchemaToComponent', () => {
+    describe('initial model handling', () => {
+        describe('when initial model is null', () => {
+            it('sets component value to null', async () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                    },
+                    model: null,
+                });
+                const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+                expect(await component.getSubmittableValue()).toBeNull();
+            });
+        });
+    });
+    describe('when a default is provided', () => {
+        it('initialises the value to the default', async () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                    default: 'USD',
+                },
+                model: null,
+            });
+            const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+            expect(await component.getSubmittableValue()).toBe('USD');
+        });
+    });
+    describe('when initial model is defined', () => {
+        it('sets the component value to the initial model', async () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                },
+                model: 'USD',
+            });
+            const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+            expect(await component.getSubmittableValue()).toBe('USD');
+        });
+    });
+    describe('when a default and a model are provided', () => {
+        it('prefers the model over the default', async () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                    default: 'EUR',
+                },
+                model: 'USD',
+            });
+            const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+            expect(await component.getSubmittableValue()).toBe('USD');
+        });
+    });
+    describe('initial validation error handling', () => {
+        it('sets the initial error if provided', () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                },
+                model: null,
+                validationErrors: 'You must select a currency',
+            });
+            const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+            expect(component.errors).toEqual(['You must select a currency']);
+        });
+    });
+    describe('validation checks', () => {
+        describe('when required is true but the model is null', () => {
+            it('fails validation', () => {
+                const schemaMapperProps = Object.assign(Object.assign({}, getMockSchemaMapperProps({
+                    schema: {
+                        oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                    },
+                    model: null,
+                })), { required: true });
+                const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+                expect(component.validate()).toBe(false);
+                expect(component.errors).toStrictEqual(['required']);
+            });
+        });
+        describe('when required is true but the model is not null', () => {
+            it('passes validation', () => {
+                const schemaMapperProps = Object.assign(Object.assign({}, getMockSchemaMapperProps({
+                    schema: {
+                        oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                    },
+                    model: 'EUR',
+                })), { required: true });
+                const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+                expect(component.validate()).toBe(true);
+            });
+        });
+    });
+    describe('analytics', () => {
+        describe('when selecting an option that is a const schema', () => {
+            it('triggers an event', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        analyticsId: 'currency',
+                        oneOf: [
+                            { const: 'EUR', analyticsId: 'EUR' },
+                            { const: 'USD', analyticsId: 'USD' },
+                            { const: 'GBP', analyticsId: 'GBP' },
+                        ],
+                    },
+                    model: null,
+                });
+                const defaultMapperProps = getMockMapperProps();
+                const component = oneOfSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                component.onSelect(1);
+                expect(defaultMapperProps.trackEvent).toHaveBeenCalledWith('OneOf Selected', {
+                    oneOfId: 'currency',
+                    schemaId: 'USD',
+                });
+            });
+            it('uses $id in the absence of analyticsId', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        $id: 'currency',
+                        oneOf: [
+                            { const: 'EUR', $id: 'EUR' },
+                            { const: 'USD', $id: 'USD' },
+                            { const: 'GBP', $id: 'GBP' },
+                        ],
+                    },
+                    model: null,
+                });
+                const defaultMapperProps = getMockMapperProps();
+                const component = oneOfSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                component.onSelect(1);
+                expect(defaultMapperProps.trackEvent).toHaveBeenCalledWith('OneOf Selected', {
+                    oneOfId: 'currency',
+                    schemaId: 'USD',
+                });
+            });
+            it('favours analyticsId over $id', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        analyticsId: 'currency',
+                        $id: 'currency-$id',
+                        oneOf: [
+                            { const: 'EUR', analyticsId: 'EUR', $id: 'EUR-$id' },
+                            { const: 'USD', analyticsId: 'USD', $id: 'USD-$id' },
+                            { const: 'GBP', analyticsId: 'GBP', $id: 'GBP-$id' },
+                        ],
+                    },
+                    model: null,
+                });
+                const defaultMapperProps = getMockMapperProps();
+                const component = oneOfSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                component.onSelect(1);
+                expect(defaultMapperProps.trackEvent).toHaveBeenCalledWith('OneOf Selected', {
+                    oneOfId: 'currency',
+                    schemaId: 'USD',
+                });
+            });
+            it(`doesn't trigger a 'OneOf Selected' event if the main schema doesn't have an analyticsId or $id, but it triggers 'OneOf Option Selected'`, () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        oneOf: [
+                            { const: 'EUR', analyticsId: 'EUR', $id: 'EUR-$id' },
+                            { const: 'USD', analyticsId: 'USD', $id: 'USD-$id' },
+                            { const: 'GBP', analyticsId: 'GBP', $id: 'GBP-$id' },
+                        ],
+                    },
+                    model: null,
+                });
+                const defaultMapperProps = getMockMapperProps();
+                const component = oneOfSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                component.onSelect(1);
+                expect(defaultMapperProps.trackEvent).not.toHaveBeenCalledWith('OneOf Selected', expect.objectContaining({ oneOfId: '', schemaId: 'USD' }));
+                expect(defaultMapperProps.trackEvent).toHaveBeenCalledWith('OneOf Option Selected', expect.objectContaining({ selectedOption: 'USD', schema: '' }));
+            });
+            it('does trigger an event if the selected option doesnt have an analyticsId or $id', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        analyticsId: 'currency',
+                        oneOf: [{ const: 'EUR' }, { const: 'USD' }, { const: 'GBP' }],
+                    },
+                    model: null,
+                });
+                const defaultMapperProps = getMockMapperProps();
+                const component = oneOfSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                component.onSelect(1);
+                expect(defaultMapperProps.trackEvent).toHaveBeenCalledWith('OneOf Selected', {
+                    oneOfId: 'currency',
+                    schemaId: undefined,
+                });
+            });
+        });
+        describe('when selecting an option that is an object schema', () => {
+            it('triggers an event', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        analyticsId: 'options-a-or-b',
+                        oneOf: [
+                            {
+                                type: 'object',
+                                analyticsId: 'option-A',
+                                displayOrder: ['name'],
+                                properties: { name: { type: 'string' } },
+                            },
+                            {
+                                type: 'object',
+                                analyticsId: 'option-B',
+                                displayOrder: ['name'],
+                                properties: { name: { type: 'string' } },
+                            },
+                        ],
+                    },
+                    model: null,
+                });
+                const defaultMapperProps = getMockMapperProps();
+                const component = oneOfSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                component.onSelect(1);
+                expect(defaultMapperProps.trackEvent).toHaveBeenCalledWith('OneOf Selected', {
+                    oneOfId: 'options-a-or-b',
+                    schemaId: 'option-B',
+                });
+            });
+        });
+    });
+    describe('number of elements', () => {
+        describe('when the oneOf contains only more than one element', () => {
+            it('returns an SelectComponent', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        oneOf: [
+                            { type: 'object', displayOrder: ['name'], properties: { name: { type: 'string' } } },
+                            { type: 'object', displayOrder: ['name'], properties: { name: { type: 'string' } } },
+                        ],
+                    },
+                });
+                const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+                expect(component.type).toBe('select');
+            });
+        });
+        describe('when the oneOf contains only one element, and its an object schema', () => {
+            it('returns an ObjectComponent', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        oneOf: [
+                            { type: 'object', displayOrder: ['name'], properties: { name: { type: 'string' } } },
+                        ],
+                    },
+                });
+                const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+                expect(component.type).toBe('object');
+            });
+        });
+        describe('when the oneOf contains only one element, and its a const schema', () => {
+            it('returns an SelectComponent', () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        oneOf: [{ const: 'EUR' }],
+                    },
+                });
+                const component = oneOfSchemaToComponent(schemaMapperProps, getMockMapperProps());
+                expect(component.type).toBe('select');
+            });
+        });
+    });
+});

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

@@ -0,0 +1,29 @@
+import { createPersistAsyncComponent } from '../../components/PersistAsyncComponent';
+import { getSchemaOnChange } from '../../features/schema-on-change/getSchemaOnChange';
+import { mapSchemaToComponent } from '../mapSchemaToComponent';
+import { getPerformPersistAsyncFn } from './utils/getPerformPersistAsyncFn';
+// Only some component types are supported for persistAsync
+const isSupported = (type) => ['const', 'boolean', 'text', 'date', 'integer', 'number', 'upload'].includes(type);
+export const persistAsyncSchemaToComponent = (schemaMapperProps, mapperProps) => {
+    const { uid, schema, model, localValue } = schemaMapperProps;
+    const { persistAsync, tags } = schema;
+    const performPersistAsync = getPerformPersistAsyncFn(schema, persistAsync, mapperProps);
+    const onPersistAsync = async () => paComponent.persist().then(() => { });
+    const childComponent = mapSchemaToComponent(Object.assign(Object.assign({}, schemaMapperProps), { uid: `${uid}-persist`, schema: persistAsync.schema, onPersistAsync }), mapperProps);
+    if (!isSupported(childComponent.type)) {
+        return childComponent;
+    }
+    const paComponent = createPersistAsyncComponent({
+        uid,
+        // This should be `schema.hidden ?? false`
+        // but some steps are setting PA schemas as hidden for no good reason
+        // so we default to false here to avoid hiding the the children of the PA component
+        hidden: false,
+        component: childComponent,
+        schemaId: schema.$id,
+        model,
+        localValue,
+        tags,
+    }, performPersistAsync, getSchemaOnChange(schema, mapperProps.onBehavior), mapperProps.onComponentUpdate);
+    return paComponent;
+};

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

@@ -0,0 +1,18 @@
+import { stringSchemaToDateInputComponent } from './stringSchemaToDateInputComponent';
+import { stringSchemaToUploadInputComponent } from './stringSchemaToUploadInputComponent';
+import { stringSchemaToTextInputComponent } from './stringSchemaToTextInputComponent';
+export const stringSchemaToComponent = (schemaMapperProps, mapperProps) => {
+    const { schema } = schemaMapperProps;
+    if (isStringSchemaWithBase64(schema)) {
+        return stringSchemaToUploadInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema }), mapperProps);
+    }
+    switch (schema.format) {
+        case 'date':
+            return stringSchemaToDateInputComponent(schemaMapperProps, mapperProps);
+        default:
+            return stringSchemaToTextInputComponent(schemaMapperProps, mapperProps);
+    }
+};
+const isStringSchemaWithBase64 = (schema) => {
+    return schema.format === 'base64url' && !('persistAsync' in schema);
+};

package/build/domain/mappers/schema/stringSchemaToComponent/stringSchemaToComponent.test.js

@@ -0,0 +1,133 @@
+import { getMockMapperProps, getMockSchemaMapperProps } from '../tests/test-utils';
+import { stringSchemaToComponent } from './stringSchemaToComponent';
+describe('stringSchemaToComponent', () => {
+    const defaultMapperProps = getMockMapperProps();
+    describe('initial model handling', () => {
+        describe('when initial model is null', () => {
+            it('sets component value to null', async () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        type: 'string',
+                    },
+                    model: null,
+                });
+                const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                expect(await component.getSubmittableValue()).toBeNull();
+            });
+            describe('when a default is provided', () => {
+                it('initialises the value to the default', async () => {
+                    const schemaMapperProps = getMockSchemaMapperProps({
+                        schema: {
+                            type: 'string',
+                            default: 'John Smith',
+                        },
+                        model: null,
+                    });
+                    const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                    expect(await component.getSubmittableValue()).toBe('John Smith');
+                });
+            });
+        });
+        describe('when initial model is defined', () => {
+            it('sets the component value to the initial model', async () => {
+                const schemaMapperProps = getMockSchemaMapperProps({
+                    schema: {
+                        type: 'string',
+                    },
+                    model: 'John Smith',
+                });
+                const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                expect(await component.getSubmittableValue()).toBe('John Smith');
+            });
+            describe('when a default is provided', () => {
+                it('prefers the model over the default', async () => {
+                    const schemaMapperProps = getMockSchemaMapperProps({
+                        schema: {
+                            type: 'string',
+                            default: 'Jane Doe',
+                        },
+                        model: 'John Smith',
+                    });
+                    const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+                    expect(await component.getSubmittableValue()).toBe('John Smith');
+                });
+            });
+        });
+    });
+    describe('initial validation error handling', () => {
+        it('sets the initial error if provided', () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    type: 'string',
+                },
+                model: 'jane@doe.com',
+                validationErrors: 'An account with this email already exists',
+            });
+            const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+            expect(component.errors).toStrictEqual(['An account with this email already exists']);
+        });
+    });
+    describe('autocomplete', () => {
+        it('sets the autocomplete value', () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    type: 'string',
+                    autocompleteHint: ['name', 'shipping'],
+                },
+                model: 'John Smith',
+            });
+            const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+            expect(component.autoComplete).toBe('name shipping');
+        });
+    });
+    describe('validation checks', () => {
+        it('sets minimum length validation', () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    type: 'string',
+                    minLength: 10,
+                },
+                model: 'Jane',
+            });
+            const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+            expect(component.validate()).toBe(false);
+            expect(component.errors).toStrictEqual(['minLength']);
+        });
+        it('sets maximum length validation', () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    type: 'string',
+                    maxLength: 2,
+                },
+                model: 'Jane',
+            });
+            const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+            expect(component.validate()).toBe(false);
+            expect(component.errors).toStrictEqual(['maxLength']);
+        });
+        it('sets pattern validation', () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    type: 'string',
+                    pattern: '^[a-zA-Z]*$',
+                },
+                model: '012345',
+            });
+            const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+            expect(component.validate()).toBe(false);
+            expect(component.errors).toStrictEqual(['pattern']);
+        });
+        it('sets required validation', () => {
+            const schemaMapperProps = getMockSchemaMapperProps({
+                schema: {
+                    type: 'string',
+                },
+                model: null,
+                required: true,
+            });
+            const component = stringSchemaToComponent(schemaMapperProps, defaultMapperProps);
+            expect(component.validate()).toBe(false);
+            expect(component.errors).toStrictEqual(['required']);
+        });
+    });
+});

package/build/domain/mappers/schema/stringSchemaToComponent/stringSchemaToDateInputComponent.js

@@ -0,0 +1,48 @@
+import { isString } from '../../../../utils/type-validators';
+import { createDateInputComponent } from '../../../components/DateInputComponent';
+import { getSchemaOnChange } from '../../../features/schema-on-change/getSchemaOnChange';
+import { getAboveMaximumDateCheck, getBelowMinimumDateCheck, getRequiredCheck, getValidDateCheck, } from '../../../features/validation/value-checks';
+import { getAutocompleteString } from '../../utils/getAutocompleteString';
+import { mapStringSchemaSuggestions } from '../../utils/suggestions-utils';
+import { getValidationAsyncInitialState } from '../utils/getValidationAsyncInitialState';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export const stringSchemaToDateInputComponent = (schemaMapperProps, mapperProps) => {
+    var _a;
+    const { schema, localValue, model, required = false, onPersistAsync } = schemaMapperProps;
+    const { autocompleteHint, default: defaultValue, minimum: minimumDate, maximum: maximumDate, suggestions, } = schema;
+    const { getErrorMessageFunctions, onComponentUpdate, onBehavior, onValueChange } = mapperProps;
+    const errorMessageFunctions = getErrorMessageFunctions(schema.validationMessages);
+    const { performValidationAsync, validationAsyncState } = getValidationAsyncInitialState(schemaMapperProps, mapperProps);
+    const validLocalValue = isString(localValue) ? localValue : null;
+    const validModel = (_a = getValidDate(model)) !== null && _a !== void 0 ? _a : getValidDate(defaultValue !== null && defaultValue !== void 0 ? defaultValue : null);
+    const value = onPersistAsync ? validLocalValue : validModel;
+    return createDateInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: getAutocompleteString(autocompleteHint), checks: schema.hidden
+            ? []
+            : [
+                getRequiredCheck(required, errorMessageFunctions),
+                getValidDateCheck(required, errorMessageFunctions),
+                getAboveMaximumDateCheck(schema, errorMessageFunctions),
+                getBelowMinimumDateCheck(schema, errorMessageFunctions),
+            ], minimumDate,
+        maximumDate, suggestions: mapStringSchemaSuggestions(suggestions, mapperProps.logEvent), value,
+        validationAsyncState, schemaOnChange: getSchemaOnChange(schema, onBehavior), performValidationAsync,
+        onValueChange }), onComponentUpdate);
+};
+const getValidDate = (model) => {
+    if (!isString(model)) {
+        return null;
+    }
+    // partial date check (YYYY-MM)
+    if (/^\d{4}-\d{2}$/.test(model)) {
+        return model;
+    }
+    // otherwise, it must be parseable to a Date, or return null
+    try {
+        const date = new Date(model);
+        const stringDate = date.toISOString(); // YYYY-MM-DDTHH:mm:ss.sssZ
+        return stringDate.split('T')[0]; // return only the date part
+    }
+    catch (_a) {
+        return null;
+    }
+};

package/build/domain/mappers/schema/stringSchemaToComponent/stringSchemaToTextInputComponent.js

@@ -0,0 +1,37 @@
+import { createTextInputComponent } from '../../../components/TextInputComponent';
+import { isString } from '../../../../utils/type-validators';
+import { getSchemaOnChange } from '../../../features/schema-on-change/getSchemaOnChange';
+import { getAboveMaxLengthCheck, getBelowMinLengthCheck, getNotAdheringToPatternCheck, getRequiredCheck, } from '../../../features/validation/value-checks';
+import { getAutocompleteString } from '../../utils/getAutocompleteString';
+import { mapStringSchemaSuggestions } from '../../utils/suggestions-utils';
+import { getValidationAsyncInitialState } from '../utils/getValidationAsyncInitialState';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export const stringSchemaToTextInputComponent = (schemaMapperProps, mapperProps) => {
+    const { schema, localValue, model, required = false, onPersistAsync } = schemaMapperProps;
+    const { autocapitalization, autocompleteHint, control, default: defaultValue, displayFormat, format, maxLength, minLength, suggestions, validationMessages, } = schema;
+    const { getErrorMessageFunctions, onComponentUpdate, onBehavior, onValueChange, logEvent } = mapperProps;
+    const controlForLegacyFormat = getControlForLegacyFormat(format);
+    const errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    const { performValidationAsync, validationAsyncState } = getValidationAsyncInitialState(schemaMapperProps, mapperProps);
+    const validLocalValue = isString(localValue) ? localValue : null;
+    const validModel = isString(model) ? model : (defaultValue !== null && defaultValue !== void 0 ? defaultValue : null);
+    const value = onPersistAsync ? validLocalValue : validModel;
+    return createTextInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { autocapitalization, autoComplete: getAutocompleteString(autocompleteHint), checks: schema.hidden
+            ? []
+            : [
+                getRequiredCheck(required, errorMessageFunctions),
+                getAboveMaxLengthCheck(schema, errorMessageFunctions),
+                getBelowMinLengthCheck(schema, errorMessageFunctions),
+                getNotAdheringToPatternCheck(schema, errorMessageFunctions, { logEvent }),
+            ], control: control !== null && control !== void 0 ? control : controlForLegacyFormat, displayFormat,
+        maxLength,
+        minLength, suggestions: mapStringSchemaSuggestions(suggestions, mapperProps.logEvent), value,
+        validationAsyncState, schemaOnChange: getSchemaOnChange(schema, onBehavior), performValidationAsync,
+        onValueChange }), onComponentUpdate);
+};
+const getControlForLegacyFormat = (format) => {
+    if (format && ['numeric', 'phone-number', 'email', 'password'].includes(format)) {
+        return format;
+    }
+    return undefined;
+};

package/build/domain/mappers/schema/stringSchemaToComponent/stringSchemaToUploadInputComponent.js

@@ -0,0 +1,28 @@
+import { isFile, isString } from '../../../../utils/type-validators';
+import { createUploadInputComponent } from '../../../components/UploadInputComponent';
+import { base64dataUrltoFile } from '../../../components/utils/file-utils';
+import { getSchemaOnChange } from '../../../features/schema-on-change/getSchemaOnChange';
+import { getFileSizeCheck, getFileTypeCheck, getRequiredCheck, } from '../../../features/validation/value-checks';
+import { getAutocompleteString } from '../../utils/getAutocompleteString';
+import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
+export const stringSchemaToUploadInputComponent = (schemaMapperProps, mapperProps) => {
+    var _a;
+    const { schema, localValue, model, required = false } = schemaMapperProps;
+    const { accepts, autocompleteHint, cameraConfig, hidden, maxSize, source, validationMessages } = schema;
+    const { getErrorMessageFunctions, onComponentUpdate, onBehavior, onValueChange } = mapperProps;
+    const errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    const validLocalValue = isFile(localValue) ? localValue : null;
+    const value = (_a = getFileFromModel(model)) !== null && _a !== void 0 ? _a : validLocalValue;
+    const checks = hidden
+        ? []
+        : [
+            getRequiredCheck(required, errorMessageFunctions),
+            getFileSizeCheck(schema, errorMessageFunctions),
+            getFileTypeCheck(schema, errorMessageFunctions),
+        ];
+    return createUploadInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { accepts, autoComplete: getAutocompleteString(autocompleteHint), cameraConfig,
+        checks, format: 'base64', maxSize,
+        source,
+        value, schemaOnChange: getSchemaOnChange(schema, onBehavior), onValueChange }), onComponentUpdate);
+};
+const getFileFromModel = (model) => isString(model) ? base64dataUrltoFile(model, '') : null;

package/build/domain/mappers/schema/tests/test-utils.js

@@ -0,0 +1,16 @@
+import { vi } from 'vitest';
+import { getRandomId } from '../../../../test-utils/getRandomId';
+import { mockErrorMessageFunctions } from '../../../features/validation/spec-utils';
+import { FeatureFlags } from '../../utils/FeatureFlags';
+import { makeRequestCache } from '../../../features/prefetch/request-cache';
+export const getStepMapperProps = () => (Object.assign(Object.assign({}, getMockMapperProps()), { uid: 'root', flowRequestCache: makeRequestCache(), etag: null, loadingState: 'idle', trackEvent: vi.fn(), onPoll: vi.fn() }));
+export const getMockMapperProps = (mapperProps = {}) => (Object.assign({ step: {}, stepLocalValue: null, features: new FeatureFlags({}), onComponentUpdate: vi.fn(), onBehavior: vi.fn(), onValueChange: vi.fn(), getErrorMessageFunctions: vi.fn().mockReturnValue(mockErrorMessageFunctions), trackEvent: vi.fn(), logEvent: vi.fn(), httpClient: vi.fn(), registerSubmissionBehavior: vi.fn() }, mapperProps));
+export const getMockSchemaMapperProps = (schemaMapperProps) => (Object.assign({ uid: getRandomId(), localValue: null, model: null, required: false, validationErrors: null }, schemaMapperProps));
+export const getMockRendererMapperProps = () => ({
+    render: vi.fn(),
+    stepLoadingState: 'idle',
+    features: new FeatureFlags({}),
+    trackEvent: vi.fn(),
+    httpClient: vi.fn(),
+});
+export const getUpdateFunctionMock = (getComponent) => vi.fn(() => { });

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

@@ -0,0 +1 @@
+export {};

package/build/domain/mappers/schema/utils/getPerformPersistAsyncFn.js

@@ -0,0 +1,19 @@
+import { getPerformPersistAsync } from '../../../features/persistAsync/getPerformPersistAsync';
+export const getPerformPersistAsyncFn = (schema, persistAsyncConfig, mapperProps) => {
+    const { getErrorMessageFunctions, httpClient, trackEvent, logEvent } = mapperProps;
+    const { $id, analyticsId } = schema;
+    const validationMessages = schemaHasValidationMessages(schema)
+        ? schema.validationMessages
+        : undefined;
+    const errorMessageFunctions = getErrorMessageFunctions(validationMessages);
+    const persistAsyncError = errorMessageFunctions.genericError();
+    return getPerformPersistAsync({
+        genericErrorMessage: persistAsyncError,
+        httpClient,
+        logEvent,
+        persistAsyncConfig,
+        schemaId: analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id,
+        trackEvent,
+    });
+};
+const schemaHasValidationMessages = (schema) => Boolean('validationMessages' in schema && schema.validationMessages);

package/build/domain/mappers/schema/utils/getValidationAsyncInitialState.js

@@ -0,0 +1,23 @@
+import { getInitialValidationAsyncState } from '../../../features/validationAsync/getInitialValidationAsyncState';
+import { getPerformValidationAsync } from '../../../features/validationAsync/getPerformValidationAsync';
+export const getValidationAsyncInitialState = (schemaMapperProps, mapperProps) => {
+    const performValidationAsync = getValidationAsyncFn(schemaMapperProps, mapperProps);
+    const validationAsyncState = getInitialValidationAsyncState();
+    return { performValidationAsync, validationAsyncState };
+};
+const getValidationAsyncFn = (schemaMapperProps, mapperProps) => {
+    const { schema } = schemaMapperProps;
+    const { trackEvent } = mapperProps;
+    if (!schemaHasValidationAsync(schema)) {
+        return undefined;
+    }
+    const { $id, analyticsId, validationAsync } = schema;
+    const { httpClient } = mapperProps;
+    return getPerformValidationAsync({
+        httpClient,
+        validationAsyncConfig: validationAsync,
+        schemaId: analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id,
+        trackEvent,
+    });
+};
+const schemaHasValidationAsync = (schema) => Boolean('validationAsync' in schema && schema.validationAsync);

package/build/domain/mappers/schema/utils/mapCommonSchemaProps.js

@@ -0,0 +1,16 @@
+import { isString } from '../../../../utils/type-validators';
+import { getSummariser } from '../../../features/summary/summary-utils';
+import { mapSchemaAlert } from '../../utils/utils';
+import { getDomainLayerMedia } from '../../utils/media-utils';
+export const mapCommonSchemaProps = (schemaMapperProps) => {
+    var _a;
+    const { uid, schemaId, schema, required, validationErrors, onPersistAsync } = schemaMapperProps;
+    const { $id, analyticsId, control, description, icon, image, keywords, media, tags, title, hidden, } = schema;
+    return Object.assign(Object.assign(Object.assign({ uid, id: $id !== null && $id !== void 0 ? $id : uid, schemaId, analyticsId: (_a = analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id) !== null && _a !== void 0 ? _a : '', control,
+        description, disabled: schemaHasDisabled(schema) ? schema.disabled : false, errors: isString(validationErrors) ? [validationErrors] : undefined, hidden: Boolean(hidden), keywords, media: getDomainLayerMedia({ icon, image, media }), required: Boolean(required), tags,
+        title,
+        onPersistAsync, summariser: getSummariser(schema) }, (schemaHasHelp(schema) ? { help: schema.help.markdown } : {})), (schemaHasPlaceholder(schema) ? { placeholder: schema.placeholder } : {})), (schema.alert ? { alert: mapSchemaAlert(schema.alert) } : {}));
+};
+const schemaHasDisabled = (schema) => Boolean('disabled' in schema && schema.disabled !== undefined);
+const schemaHasHelp = (schema) => Boolean('help' in schema && schema.help);
+const schemaHasPlaceholder = (schema) => Boolean('placeholder' in schema && schema.placeholder);

package/build/domain/mappers/types.js

@@ -0,0 +1 @@
+export {};