@wise/dynamic-flow-client 5.30.1 → 5.30.2-experimental-949e5e5

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

@@ -1,58 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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, []));
-};

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

@@ -1,56 +0,0 @@
-import { createDateInputComponent } from '../../components/DateInputComponent';
-import { getSchemaOnChange } from '../../features/schema-on-change/getSchemaOnChange';
-import { normaliseDateAvailability } from '../../features/validation/date-availability';
-import { getAboveMaximumDateCheck, getBelowMinimumDateCheck, getStringRequiredCheck, getUnavailableDateCheck, getValidDateCheck, } from '../../features/validation/value-checks';
-import { isString } from '../../../utils/type-validators';
-import { getAutocompleteString } from '../utils/getAutocompleteString';
-import { mapSuggestions } from '../utils/suggestions-utils';
-import { getValidationAsyncInitialState } from './utils/getValidationAsyncInitialState';
-import { mapCommonSchemaProps } from './utils/mapCommonSchemaProps';
-export const dateSchemaToComponent = (schemaMapperProps, mapperProps) => {
-    var _a;
-    const { schema, localValue, model, required = false, onPersistAsync, onValueChange, } = schemaMapperProps;
-    const { autocompleteHint, default: defaultValue, minimum: minimumDate, maximum: maximumDate, suggestions, } = schema;
-    const { getErrorMessageFunctions, onComponentUpdate, onBehavior } = mapperProps;
-    const availability = schema.type === 'date'
-        ? normaliseDateAvailability(schema.availability, mapperProps.logEvent)
-        : undefined;
-    const errorMessageFunctions = getErrorMessageFunctions(schema.validationMessages);
-    const { performValidationAsync, validationAsyncState } = getValidationAsyncInitialState(schemaMapperProps, mapperProps);
-    const validLocalValue = isString(localValue) ? localValue : null;
-    const value = onPersistAsync
-        ? validLocalValue
-        : ((_a = normaliseDateValue(model)) !== null && _a !== void 0 ? _a : normaliseDateValue(defaultValue !== null && defaultValue !== void 0 ? defaultValue : null));
-    return createDateInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: getAutocompleteString(autocompleteHint), availability, checks: schema.hidden
-            ? []
-            : [
-                getStringRequiredCheck(required, errorMessageFunctions),
-                getValidDateCheck(required, errorMessageFunctions),
-                getAboveMaximumDateCheck(schema, errorMessageFunctions),
-                getBelowMinimumDateCheck(schema, errorMessageFunctions),
-                ...(schema.type === 'date'
-                    ? [getUnavailableDateCheck(Object.assign(Object.assign({}, schema), { availability }))]
-                    : []),
-            ], minimumDate,
-        maximumDate, suggestions: mapSuggestions(suggestions, mapperProps.logEvent), value,
-        validationAsyncState, schemaOnChange: getSchemaOnChange(schema, onBehavior), performValidationAsync,
-        onValueChange }), onComponentUpdate);
-};
-const normaliseDateValue = (value) => {
-    if (!isString(value)) {
-        return null;
-    }
-    // Preserve partial dates (YYYY or YYYY-MM).
-    if (/^\d{4}(?:-\d{2})?$/.test(value)) {
-        return value;
-    }
-    // otherwise, it must be parseable to a Date, or return null
-    try {
-        const date = new Date(value);
-        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/dateSchemaToComponent.test.js

@@ -1,117 +0,0 @@
-import { getMockMapperProps, getMockSchemaMapperProps } from './tests/test-utils';
-import { dateSchemaToComponent } from './dateSchemaToComponent';
-describe('dateSchemaToComponent', () => {
-    const mapperProps = getMockMapperProps();
-    it('maps date input properties and normalises an ISO date-time model', async () => {
-        const availability = {
-            message: 'Choose an available date',
-            unavailable: [{ type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' }],
-        };
-        const schema = {
-            type: 'date',
-            control: 'date-lookup',
-            minimum: '2026-09-01',
-            maximum: '2026-09-30',
-            availability,
-        };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({
-            schema,
-            model: '2026-09-02T20:15:00+01:00',
-        }), mapperProps);
-        expect(component).toMatchObject({
-            type: 'date',
-            control: 'date-lookup',
-            minimumDate: '2026-09-01',
-            maximumDate: '2026-09-30',
-            availability,
-            value: '2026-09-02',
-        });
-        expect(await component.getSubmittableValue()).toBe('2026-09-02');
-    });
-    it('uses the default when the model has no value', () => {
-        const schema = { type: 'date', default: '2026-09-02' };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: null }), mapperProps);
-        expect(component.value).toBe('2026-09-02');
-    });
-    it('uses a valid model value instead of the default', () => {
-        const schema = { type: 'date', default: '2026-09-02' };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: '2026-09-08' }), mapperProps);
-        expect(component.value).toBe('2026-09-08');
-    });
-    it.each(['2026', '2026-09'])('accepts the partial date %s from the model', async (value) => {
-        const schema = { type: 'date' };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: value }), mapperProps);
-        expect(component.value).toBe(value);
-        expect(await component.getSubmittableValue()).toBeNull();
-    });
-    it.each(['2026', '2026-09'])('accepts the partial date %s from the default', async (value) => {
-        const schema = { type: 'date', default: value };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: null }), mapperProps);
-        expect(component.value).toBe(value);
-        expect(await component.getSubmittableValue()).toBeNull();
-    });
-    it('normalises a date-time to its UTC date', () => {
-        const schema = { type: 'date' };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: '2026-09-02T23:30:00-02:00' }), mapperProps);
-        expect(component.value).toBe('2026-09-03');
-    });
-    it('uses the default when the model is invalid', () => {
-        const schema = { type: 'date', default: '2026-09-02' };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: 'not-a-date' }), mapperProps);
-        expect(component.value).toBe('2026-09-02');
-    });
-    it('uses the first matching availability rule reason', () => {
-        const schema = {
-            type: 'date',
-            availability: {
-                unavailable: [
-                    { type: 'dates', dates: ['2026-12-27'], reason: 'Bank holiday' },
-                    { type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' },
-                ],
-            },
-        };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: '2026-12-27' }), mapperProps);
-        expect(component.validate()).toBe(false);
-        expect(component.errors).toStrictEqual(['Bank holiday']);
-    });
-    it('only exposes valid availability rules to validation and rendering', () => {
-        const logEvent = vi.fn();
-        const schema = {
-            type: 'date',
-            availability: {
-                unavailable: [
-                    {
-                        type: 'dates',
-                        dates: ['2026-09-07', '2026-09-0a'],
-                        reason: 'Unavailable',
-                    },
-                    {
-                        type: 'range',
-                        start: '2026-09-30',
-                        end: '2026-09-01',
-                        reason: 'Reversed range',
-                    },
-                ],
-            },
-        };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: '2026-09-07' }), Object.assign(Object.assign({}, mapperProps), { logEvent }));
-        expect(component.availability).toEqual({
-            unavailable: [{ type: 'dates', dates: ['2026-09-07'], reason: 'Unavailable' }],
-        });
-        expect(component.validate()).toBe(false);
-        expect(component.errors).toStrictEqual(['Unavailable']);
-        expect(logEvent).toHaveBeenCalledTimes(2);
-    });
-    it('validates maximum before availability', () => {
-        const schema = {
-            type: 'date',
-            maximum: '2026-12-26',
-            availability: {
-                unavailable: [{ type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' }],
-            },
-        };
-        const component = dateSchemaToComponent(getMockSchemaMapperProps({ schema, model: '2026-12-27' }), mapperProps);
-        expect(component.validate()).toBe(false);
-        expect(component.errors).toStrictEqual(['maximumDate', 'Closed on Sundays']);
-    });
-});

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

@@ -1,28 +0,0 @@
-import { isInteger } from '../../../utils/type-validators';
-import { createIntegerInputComponent } from '../../components/IntegerInputComponent';
-import { getSchemaOnChange } from '../../features/schema-on-change/getSchemaOnChange';
-import { getAboveMaximumCheck, getBelowMinimumCheck, getRequiredCheck, } from '../../features/validation/value-checks';
-import { getAutocompleteString } from '../utils/getAutocompleteString';
-import { getValidationAsyncInitialState } from './utils/getValidationAsyncInitialState';
-import { mapCommonSchemaProps } from './utils/mapCommonSchemaProps';
-export const integerSchemaToComponent = (schemaMapperProps, mapperProps) => {
-    const { schema, localValue, model, required = false, onPersistAsync, onValueChange, } = schemaMapperProps;
-    const { autocompleteHint, validationMessages, default: defaultValue, maximum, minimum } = schema;
-    const { getErrorMessageFunctions, onComponentUpdate, onBehavior } = mapperProps;
-    const errorMessageFunctions = getErrorMessageFunctions(validationMessages);
-    const { performValidationAsync, validationAsyncState } = getValidationAsyncInitialState(schemaMapperProps, mapperProps);
-    const validLocalValue = isInteger(localValue) ? localValue : null;
-    const validModel = isInteger(model) ? model : (defaultValue !== null && defaultValue !== void 0 ? defaultValue : null);
-    const value = onPersistAsync ? validLocalValue : validModel;
-    const checks = [
-        getRequiredCheck(required, errorMessageFunctions),
-        getBelowMinimumCheck(schema, errorMessageFunctions),
-        getAboveMaximumCheck(schema, errorMessageFunctions),
-    ];
-    return createIntegerInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: getAutocompleteString(autocompleteHint), checks,
-        maximum,
-        minimum,
-        value,
-        validationAsyncState, schemaOnChange: getSchemaOnChange(schema, onBehavior), performValidationAsync,
-        onValueChange }), onComponentUpdate);
-};

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

@@ -1,26 +0,0 @@
-import { isNumber } from '../../../utils/type-validators';
-import { createNumberInputComponent } from '../../components/NumberInputComponent';
-import { getSchemaOnChange } from '../../features/schema-on-change/getSchemaOnChange';
-import { getAboveMaximumCheck, getBelowMinimumCheck, getRequiredCheck, } from '../../features/validation/value-checks';
-import { getAutocompleteString } from '../utils/getAutocompleteString';
-import { getValidationAsyncInitialState } from './utils/getValidationAsyncInitialState';
-import { mapCommonSchemaProps } from './utils/mapCommonSchemaProps';
-export const numberSchemaToComponent = (schemaMapperProps, mapperProps) => {
-    const { schema, model, localValue, required = false, onPersistAsync, onValueChange, } = schemaMapperProps;
-    const { autocompleteHint, validationMessages, default: defaultValue, maximum, minimum } = schema;
-    const { getErrorMessageFunctions, onComponentUpdate, onBehavior } = mapperProps;
-    const errorMessageFunctions = getErrorMessageFunctions(validationMessages);
-    const { performValidationAsync, validationAsyncState } = getValidationAsyncInitialState(schemaMapperProps, mapperProps);
-    const validLocalValue = isNumber(localValue) ? localValue : null;
-    const validModel = isNumber(model) ? model : (defaultValue !== null && defaultValue !== void 0 ? defaultValue : null);
-    const value = onPersistAsync ? validLocalValue : validModel;
-    return createNumberInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { autoComplete: getAutocompleteString(autocompleteHint), checks: [
-            getRequiredCheck(required, errorMessageFunctions),
-            getBelowMinimumCheck(schema, errorMessageFunctions),
-            getAboveMaximumCheck(schema, errorMessageFunctions),
-        ], value,
-        maximum,
-        minimum,
-        validationAsyncState, schemaOnChange: getSchemaOnChange(schema, onBehavior), performValidationAsync,
-        onValueChange }), onComponentUpdate);
-};

package/build/domain/mappers/schema/objectSchemaToComponent/assertDisplayOrder.js

@@ -1,23 +0,0 @@
-export const assertDisplayOrder = (schema, logEvent) => {
-    const { $id, displayOrder, properties } = schema;
-    if (!displayOrder) {
-        const message = `Object schema ${$id} has no displayOrder property.`;
-        logEvent('error', message);
-        throw new Error(message);
-    }
-    const propertyNames = Object.keys(properties);
-    displayOrder.forEach((propName) => {
-        if (!properties[propName]) {
-            const message = `Object schema ${$id} has no property named "${propName}", but it is listed in the displayOrder array.`;
-            logEvent('error', message);
-            throw new Error(message);
-        }
-    });
-    propertyNames.forEach((propName) => {
-        if (!displayOrder.includes(propName)) {
-            const message = `Object schema ${$id} has a "${propName}" property which is missing in the displayOrder array.`;
-            logEvent('error', message);
-            throw new Error(message);
-        }
-    });
-};

package/build/domain/mappers/schema/objectSchemaToComponent/objectSchemaToFormattedValueComponent.js

@@ -1,9 +0,0 @@
-import { createFormattedValueComponent } from '../../../components/FormattedValueComponent';
-import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
-import { getSchemaOnChange } from '../../../features/schema-on-change/getSchemaOnChange';
-export const objectSchemaToFormattedValueComponent = (schemaMapperProps, mapperProps) => {
-    const { onBehavior } = mapperProps;
-    const { schema } = schemaMapperProps;
-    const { format } = schema;
-    return createFormattedValueComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), { format, value: schemaMapperProps.model, schemaOnChange: getSchemaOnChange(schema, onBehavior) }), mapperProps.onComponentUpdate);
-};

package/build/domain/mappers/schema/objectSchemaToComponent/objectSchemaToMoneyInputComponent.js

@@ -1,119 +0,0 @@
-import { isConstSchema, isOneOfSchema, isStringSchema } from '../../../../utils/type-utils';
-import { createMoneyInputComponent } from '../../../components/MoneyInputComponent';
-import { getAboveMaximumMoneyAmountCheck, getBelowMinimumMoneyAmountCheck, } from '../../../features/validation/value-checks';
-import { mapCommonSchemaProps } from '../utils/mapCommonSchemaProps';
-import { createComponentMap } from './objectSchemaToObjectComponent';
-import { isObject } from '../../../../utils/type-validators';
-// Constraints for amount schema
-const isAmountSchema = (schema) => isStringSchema(schema) &&
-    !schema.hidden &&
-    schema.format !== 'date' &&
-    schema.format !== 'base64url' &&
-    schema.persistAsync === undefined;
-// Constraints for currency schema
-const isCurrencyConstSchema = (schema) => isConstSchema(schema);
-// A oneOf schema is valid for currency if all its options are const schemas, and there is at least one option
-const isCurrencySelectSchema = (schema) => isOneOfSchema(schema) &&
-    schema.oneOf.length > 0 &&
-    schema.oneOf.every((option) => isCurrencyConstSchema(option));
-export const objectSchemaToMoneyInputComponent = (schemaMapperProps, mapperProps) => {
-    return createMoneyInputComponent(Object.assign(Object.assign({}, mapCommonSchemaProps(schemaMapperProps)), createMoneyInputSubComponents(schemaMapperProps, mapperProps)), mapperProps.onComponentUpdate);
-};
-const createMoneyInputSubComponents = (schemaMapperProps, mapperProps) => {
-    const { schema: objectSchema, model } = schemaMapperProps;
-    const amountKey = getAmountSchemaKey(objectSchema, mapperProps);
-    const currencyKey = getCurrencySchemaKey(objectSchema, mapperProps);
-    // This is to ensure that the currency schema is always a oneOf schema,
-    // so that it is always mapped to a SelectInputComponent.
-    const currencySchema = objectSchema.properties[currencyKey];
-    const customSchemaMapperProps = Object.assign(Object.assign({}, schemaMapperProps), { model: getSanitizedModel(amountKey, model), schema: isOneOfSchema(currencySchema)
-            ? objectSchema
-            : replaceKeyInObjectSchema(objectSchema, currencyKey, { oneOf: [currencySchema] }) });
-    const componentMap = createComponentMap(customSchemaMapperProps, mapperProps, 'money');
-    const amountComponent = componentMap[amountKey];
-    assertAmountComponent(amountComponent, mapperProps.logEvent);
-    const currencyComponent = componentMap[currencyKey];
-    assertCurrencyComponent(currencyComponent, mapperProps.logEvent);
-    const extraValues = getExtraValues(componentMap, [amountKey, currencyKey]);
-    const checks = getMinMaxChecks(objectSchema, amountKey, mapperProps);
-    return { amountKey, amountComponent, currencyKey, currencyComponent, extraValues, checks };
-};
-const isNumberString = (value) => {
-    return (typeof value === 'string' &&
-        !Number.isNaN(Number.parseFloat(value)) &&
-        /^\d*(?:\.\d*)?$/.test(value));
-};
-const getSanitizedModel = (key, value) => {
-    if (isObject(value)) {
-        const amount = value[key];
-        if (!isNumberString(amount)) {
-            return Object.assign(Object.assign({}, value), { [key]: null });
-        }
-    }
-    return value;
-};
-const getAmountSchemaKey = ({ displayOrder, properties }, mapperProps) => {
-    var _a;
-    const entry = displayOrder
-        .map((key) => ({ key, schema: properties[key] }))
-        .find(({ schema }) => isAmountSchema(schema));
-    if (!entry) {
-        const message = `Object schema with format "money" is not properly configured. It must have one schema property of type "string" which is not hidden and has a valid format or no format at all.`;
-        (_a = mapperProps.logEvent) === null || _a === void 0 ? void 0 : _a.call(mapperProps, 'error', message);
-        throw new Error(message);
-    }
-    return entry.key;
-};
-const getCurrencySchemaKey = ({ displayOrder, properties }, mapperProps) => {
-    var _a;
-    const entry = displayOrder
-        .map((key) => ({ key, schema: properties[key] }))
-        .find(({ schema }) => isCurrencyConstSchema(schema) || isCurrencySelectSchema(schema));
-    if (!entry) {
-        const message = `Object schema with format "money" is not properly configured. It must have one schema property representing the currency code. This property must be a const schema or a oneOf schema with at least one const schema options.`;
-        (_a = mapperProps.logEvent) === null || _a === void 0 ? void 0 : _a.call(mapperProps, 'error', message);
-        throw new Error(message);
-    }
-    return entry.key;
-};
-// Returns a new ObjectSchema with the specified key replaced by the new schema
-const replaceKeyInObjectSchema = (objSchema, key, newSchema) => {
-    return Object.assign(Object.assign({}, objSchema), { properties: Object.assign(Object.assign({}, objSchema.properties), { [key]: newSchema }) });
-};
-const getMinMaxChecks = (objectSchema, amountKey, mapperProps) => {
-    const amountSchema = objectSchema.properties[amountKey];
-    const errorMessageFunctions = mapperProps.getErrorMessageFunctions(amountSchema.validationMessages);
-    const checks = [
-        getAboveMaximumMoneyAmountCheck(amountSchema, errorMessageFunctions),
-        getBelowMinimumMoneyAmountCheck(amountSchema, errorMessageFunctions),
-    ];
-    return checks;
-};
-// Returns values of schema components that are either const or hidden,
-// excluding the ones with keys in excludeKeys (typically, amount and currency).
-function getExtraValues(componentMap, excludeKeys) {
-    return Object.fromEntries(Object.entries(componentMap)
-        .filter(([key, component]) => !excludeKeys.includes(key) && (component.type === 'const' || component.hidden))
-        .map(([key, component]) => [key, component.getSubmittableValueSync()]));
-}
-function assertAmountComponent(component, logEvent) {
-    if (component.type !== 'text') {
-        // This should never happen because isAmountSchema ensures that the amount schema
-        // is a string schema of without hidden, date or base64url format,
-        // and those are always mapped to TextInputComponents.
-        const message = 'A string schema was selected for amount but it was not successfully mapped into a TextInputComponent.';
-        logEvent === null || logEvent === void 0 ? void 0 : logEvent('error', message);
-        throw new Error(message);
-    }
-}
-function assertCurrencyComponent(component, logEvent) {
-    if (component.type !== 'select') {
-        // This should never happen because
-        // oneOfSchemaToComponent always returns a SelectInputComponent
-        // for oneOf schemas with const options, and
-        // we have already asserted that the oneOf schema only has const options.
-        const message = 'A schema was selected for currency but it was not successfully mapped into a SelectInputComponent.';
-        logEvent === null || logEvent === void 0 ? void 0 : logEvent('error', message);
-        throw new Error(message);
-    }
-}

package/build/domain/mappers/schema/objectSchemaToComponent/objectSchemaToMoneyInputComponent.test.js

@@ -1,97 +0,0 @@
-import { objectSchemaToMoneyInputComponent } from './objectSchemaToMoneyInputComponent';
-describe('objectSchemaToMoneyInputComponent', () => {
-    const schemaMapperProps = {
-        uid: 'test-money-input',
-        model: { amount: '100' },
-        localValue: null,
-        validationErrors: null,
-        onValueChange: () => { },
-    };
-    const mapperProps = {
-        logEvent: () => { },
-        getErrorMessageFunctions: () => () => '',
-    };
-    describe('when the object schema has "format": "money"', () => {
-        describe('and it is properly configured', () => {
-            it('should map to a MoneyInputComponent', () => {
-                const moneyInputComponent = objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: {
-                        type: 'object',
-                        format: 'money',
-                        properties: {
-                            amount: { type: 'string', format: 'numeric' },
-                            currency: { const: 'USD' },
-                        },
-                        displayOrder: ['amount', 'currency'],
-                    } }), mapperProps);
-                expect(moneyInputComponent.type).toBe('money-input');
-            });
-        });
-        describe('but it is not properly configured', () => {
-            it('should throw when missing string schema (for amount)', () => {
-                expect(() => objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: {
-                        type: 'object',
-                        format: 'money',
-                        properties: {
-                            amount: { type: 'number' },
-                            currency: { const: 'USD' },
-                        },
-                        displayOrder: ['amount', 'currency'],
-                    } }), mapperProps)).toThrow(/not properly configured.*string/);
-            });
-            it('should throw when missing a usable string schema (hidden schemas cannot be used)', () => {
-                expect(() => objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: {
-                        type: 'object',
-                        format: 'money',
-                        properties: {
-                            amount: { type: 'string', hidden: true },
-                            currency: { const: 'USD' },
-                        },
-                        displayOrder: ['amount', 'currency'],
-                    } }), mapperProps)).toThrow(/not properly configured.*string/);
-            });
-            it('should throw when missing a usable string schema (format: "date" cannot be used)', () => {
-                expect(() => objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: {
-                        type: 'object',
-                        format: 'money',
-                        properties: {
-                            amount: { type: 'string', format: 'date' },
-                            currency: { const: 'USD' },
-                        },
-                        displayOrder: ['amount', 'currency'],
-                    } }), mapperProps)).toThrow(/not properly configured.*string/);
-            });
-            it('should throw when missing a usable string schema (upload schemas cannot be used)', () => {
-                expect(() => objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: {
-                        type: 'object',
-                        format: 'money',
-                        properties: {
-                            amount: { type: 'string', format: 'base64url' },
-                            currency: { const: 'USD' },
-                        },
-                        displayOrder: ['amount', 'currency'],
-                    } }), mapperProps)).toThrow(/not properly configured.*string/);
-            });
-            it('should throw when missing currency schema', () => {
-                expect(() => objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: {
-                        type: 'object',
-                        format: 'money',
-                        properties: {
-                            amount: { type: 'string' },
-                        },
-                        displayOrder: ['amount'],
-                    } }), mapperProps)).toThrow(/not properly configured.*currency code/);
-            });
-            it('should throw when currency schema oneOf is empty', () => {
-                expect(() => objectSchemaToMoneyInputComponent(Object.assign(Object.assign({}, schemaMapperProps), { schema: {
-                        type: 'object',
-                        format: 'money',
-                        properties: {
-                            amount: { type: 'string', format: 'numeric' },
-                            currency: { oneOf: [] },
-                        },
-                        displayOrder: ['amount', 'currency'],
-                    } }), mapperProps)).toThrow(/not properly configured.*const.*oneOf/);
-            });
-        });
-    });
-});