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

package/build/domain/features/validation/getPatternRegExp.js

@@ -1,25 +0,0 @@
-export const getPatternRegExp = (pattern, logEvent) => {
-    if (!pattern) {
-        return;
-    }
-    try {
-        return new RegExp(pattern, 'u');
-    }
-    catch (error) {
-        const message = `Invalid schema pattern. Failed to instantiate RegExp with Unicode support.`;
-        if (logEvent) {
-            logEvent('warning', message, {
-                pattern,
-                error: error === null || error === void 0 ? void 0 : error.toString(),
-            });
-        }
-        else {
-            // eslint-disable-next-line no-console
-            console.warn(`Dynamic Flow - ${message}`, {
-                pattern,
-                error: error === null || error === void 0 ? void 0 : error.toString(),
-            });
-        }
-        return new RegExp(pattern);
-    }
-};

package/build/domain/features/validation/spec-utils.js

@@ -1,23 +0,0 @@
-import { vi } from 'vitest';
-export const mockErrorMessageFunctions = {
-    minimum: vi.fn().mockReturnValue('minimum'),
-    maximum: vi.fn().mockReturnValue('maximum'),
-    minimumDate: vi.fn().mockReturnValue('minimumDate'),
-    maximumDate: vi.fn().mockReturnValue('maximumDate'),
-    invalidDate: vi.fn().mockReturnValue('invalidDate'),
-    minLength: vi.fn().mockReturnValue('minLength'),
-    maxLength: vi.fn().mockReturnValue('maxLength'),
-    minFiles: vi.fn().mockReturnValue('minFiles'),
-    maxFiles: vi.fn().mockReturnValue('maxFiles'),
-    minItems: vi.fn().mockReturnValue('minItems'),
-    maxItems: vi.fn().mockReturnValue('maxItems'),
-    maxSize: vi.fn().mockReturnValue('maxSize'),
-    accepts: vi.fn().mockReturnValue('accepts'),
-    pattern: vi.fn().mockReturnValue('pattern'),
-    required: vi.fn().mockReturnValue('required'),
-    genericError: vi.fn().mockReturnValue('genericError'),
-    genericErrorWithRetry: vi.fn().mockReturnValue('genericErrorWithRetry'),
-    downloadStarted: vi.fn().mockReturnValue('downloadStarted'),
-    downloadFailed: vi.fn().mockReturnValue('downloadFailed'),
-    downloadSuccessful: vi.fn().mockReturnValue('downloadSuccessful'),
-};

package/build/domain/features/validation/validation-functions.js

@@ -1,6 +0,0 @@
-import { isString } from '../../../utils/type-validators';
-export const validateComponents = (components) => components.reduce((acc, component) => component.validate() && acc, true);
-/**
- * Returns a function that takes a local value and returns an array of validation errors
- */
-export const getLocalValueValidator = (checks) => (currentValue) => checks.map((check) => check(currentValue)).filter(isString);

package/build/domain/features/validation/validation-functions.test.js

@@ -1,108 +0,0 @@
-import { vi } from 'vitest';
-import { mockErrorMessageFunctions } from './spec-utils';
-import { getLocalValueValidator, validateComponents } from './validation-functions';
-import { getAboveMaxLengthCheck, getAboveMaximumCheck, getBelowMinLengthCheck, getBelowMinimumCheck, getNotAdheringToPatternCheck, getRequiredCheck, } from './value-checks';
-const getMockComponent = ({ valid }) => ({ validate: vi.fn().mockReturnValue(valid) });
-describe('validateComponents', () => {
-    it('should return true when all components validate', () => {
-        const components = [
-            getMockComponent({ valid: true }),
-            getMockComponent({ valid: true }),
-            getMockComponent({ valid: true }),
-        ];
-        const result = validateComponents(components);
-        expect(result).toBe(true);
-    });
-    it('should return false when at least one component fails to validate', () => {
-        const components = [
-            getMockComponent({ valid: true }),
-            getMockComponent({ valid: false }),
-            getMockComponent({ valid: true }),
-        ];
-        const result = validateComponents(components);
-        expect(result).toBe(false);
-    });
-    it('should return true when there are no components', () => {
-        const components = [];
-        const result = validateComponents(components);
-        expect(result).toBe(true);
-    });
-    it('should call validate on every component', () => {
-        const validateOne = vi.fn().mockReturnValue(false);
-        const validateTwo = vi.fn().mockReturnValue(true);
-        const validateThree = vi.fn().mockReturnValue(true);
-        const components = [
-            { validate: validateOne },
-            { validate: validateTwo },
-            { validate: validateThree },
-        ];
-        validateComponents(components);
-        expect(validateOne).toHaveBeenCalled();
-        expect(validateTwo).toHaveBeenCalled();
-        expect(validateThree).toHaveBeenCalled();
-    });
-});
-describe('getLocalValueValidator', () => {
-    it('returns an empty array when the model is valid', () => {
-        const schema = {
-            type: 'integer',
-            minimum: 1,
-            maximum: 90,
-        };
-        const checks = [
-            getRequiredCheck(false, mockErrorMessageFunctions),
-            getBelowMinimumCheck(schema, mockErrorMessageFunctions),
-            getAboveMaximumCheck(schema, mockErrorMessageFunctions),
-        ];
-        const validationErrors = getLocalValueValidator(checks)(30);
-        expect(validationErrors).toEqual([]);
-    });
-    it('returns an array of validation errors when the model is invalid', () => {
-        const schema = {
-            type: 'string',
-            minLength: 3,
-            maxLength: 10,
-            pattern: 'foo',
-        };
-        const checks = [
-            getRequiredCheck(false, mockErrorMessageFunctions),
-            getAboveMaxLengthCheck(schema, mockErrorMessageFunctions),
-            getBelowMinLengthCheck(schema, mockErrorMessageFunctions),
-            getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions),
-        ];
-        const validationErrors = getLocalValueValidator(checks)('invalid-model');
-        expect(validationErrors).toEqual(['maxLength', 'pattern']);
-    });
-    it('returns a single error if the model is required and not provided', () => {
-        const schema = {
-            type: 'string',
-            minLength: 3,
-            maxLength: 10,
-            pattern: 'foo',
-        };
-        const checks = [
-            getRequiredCheck(true, mockErrorMessageFunctions),
-            getAboveMaxLengthCheck(schema, mockErrorMessageFunctions),
-            getBelowMinLengthCheck(schema, mockErrorMessageFunctions),
-            getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions),
-        ];
-        const validationErrors = getLocalValueValidator(checks)(null);
-        expect(validationErrors).toEqual(['required']);
-    });
-    it('returns an empty array when the model is not required and not provided', () => {
-        const schema = {
-            type: 'string',
-            minLength: 3,
-            maxLength: 10,
-            pattern: 'foo',
-        };
-        const checks = [
-            getRequiredCheck(false, mockErrorMessageFunctions),
-            getAboveMaxLengthCheck(schema, mockErrorMessageFunctions),
-            getBelowMinLengthCheck(schema, mockErrorMessageFunctions),
-            getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions),
-        ];
-        const validationErrors = getLocalValueValidator(checks)(null);
-        expect(validationErrors).toEqual([]);
-    });
-});

package/build/domain/features/validation/value-checks.js

@@ -1,130 +0,0 @@
-import { isArray, isNullish, isNumber, isString, isValidDate, } from '../../../utils/type-validators';
-import { getUnavailableDateReason } from './date-availability';
-import { getPatternRegExp } from './getPatternRegExp';
-export const getAboveMaxItemsCheck = ({ maxItems }, messageFunctions) => (value) => {
-    if (isNumber(maxItems) && isArray(value) && value.length > maxItems) {
-        return messageFunctions.maxItems(maxItems);
-    }
-    return null;
-};
-export const getBelowMinFilesCheck = ({ minItems }, messageFunctions) => (value) => {
-    if (isNumber(minItems) && isArray(value) && value.length > 0 && value.length < minItems) {
-        return messageFunctions.minFiles(minItems);
-    }
-    return null;
-};
-export const getAboveMaxFilesCheck = ({ maxItems }, messageFunctions) => (value) => {
-    if (isNumber(maxItems) && isArray(value) && value.length > maxItems) {
-        return messageFunctions.maxFiles(maxItems);
-    }
-    return null;
-};
-export const getFileSizeCheck = (schema, messageFunctions) => (value) => {
-    const maxSize = 'persistAsync' in schema ? schema.persistAsync.schema.maxSize : schema.maxSize;
-    if (maxSize && value && value.size > maxSize) {
-        return messageFunctions.maxSize();
-    }
-    return null;
-};
-export const getFileTypeCheck = (schema, messageFunctions) => (value) => {
-    const accepts = 'persistAsync' in schema ? schema.persistAsync.schema.accepts : schema.accepts;
-    if (accepts && value && !accepts.includes(value.type)) {
-        return messageFunctions.accepts();
-    }
-    return null;
-};
-export const getBelowMinItemsCheck = ({ minItems }, messageFunctions) => (value) => {
-    if (isNumber(minItems) && isArray(value) && value.length > 0 && value.length < minItems) {
-        return messageFunctions.minItems(minItems);
-    }
-    return null;
-};
-export const getAboveMaxLengthCheck = ({ maxLength }, messageFunctions) => (value) => {
-    if (isNumber(maxLength) && isString(value) && value.length > maxLength) {
-        return messageFunctions.maxLength(maxLength);
-    }
-    return null;
-};
-export const getBelowMinLengthCheck = ({ minLength }, messageFunctions) => (value) => {
-    if (isNumber(minLength) && isString(value) && value && value.length < minLength) {
-        return messageFunctions.minLength(minLength);
-    }
-    return null;
-};
-export const getAboveMaximumCheck = ({ maximum }, messageFunctions) => (value) => {
-    if (isNumber(maximum) && isNumber(value) && value > maximum) {
-        return messageFunctions.maximum(maximum);
-    }
-    return null;
-};
-export const getBelowMinimumCheck = ({ minimum }, messageFunctions) => (value) => {
-    if (isNumber(minimum) && isNumber(value) && value < minimum) {
-        return messageFunctions.minimum(minimum);
-    }
-    return null;
-};
-export const getAboveMaximumMoneyAmountCheck = ({ maximum }, messageFunctions) => (value) => {
-    const numericValue = value != null ? Number.parseFloat(value) : null;
-    const numericMax = maximum != null ? Number.parseFloat(maximum) : null;
-    if (maximum != null &&
-        isNumber(numericMax) &&
-        isNumber(numericValue) &&
-        numericValue > numericMax) {
-        return messageFunctions.maximum(maximum);
-    }
-    return null;
-};
-export const getBelowMinimumMoneyAmountCheck = ({ minimum }, messageFunctions) => (value) => {
-    const numericValue = value != null ? Number.parseFloat(value) : null;
-    const numericMin = minimum != null ? Number.parseFloat(minimum) : null;
-    if (minimum != null &&
-        isNumber(numericMin) &&
-        isNumber(numericValue) &&
-        numericValue < numericMin) {
-        return messageFunctions.minimum(minimum);
-    }
-    return null;
-};
-export const getAboveMaximumDateCheck = ({ maximum }, messageFunctions) => (value) => {
-    if (isString(maximum) && isValidDate(value) && value > maximum) {
-        return messageFunctions.maximumDate(maximum);
-    }
-    return null;
-};
-export const getBelowMinimumDateCheck = ({ minimum }, messageFunctions) => (value) => {
-    if (isString(minimum) && isValidDate(value) && value < minimum) {
-        return messageFunctions.minimumDate(minimum);
-    }
-    return null;
-};
-export const getNotAdheringToPatternCheck = ({ pattern }, messageFunctions, options) => {
-    const regExp = getPatternRegExp(pattern, options === null || options === void 0 ? void 0 : options.logEvent);
-    return (value) => {
-        if (regExp && isString(value) && value) {
-            return (regExp === null || regExp === void 0 ? void 0 : regExp.test(value)) ? null : messageFunctions.pattern();
-        }
-        return null;
-    };
-};
-export const getRequiredCheck = (required, messageFunctions) => (value) => {
-    if (!required) {
-        return null;
-    }
-    if (isArray(value) && value.length === 0) {
-        return messageFunctions.required();
-    }
-    return isNullish(value) ? messageFunctions.required() : null;
-};
-export const getStringRequiredCheck = (required, messageFunctions) => (value) => {
-    if (!required) {
-        return null;
-    }
-    return isNullish(value) || value === '' ? messageFunctions.required() : null;
-};
-export const getValidDateCheck = (required, messageFunctions) => (value) => {
-    if (required && value && !isValidDate(value)) {
-        return messageFunctions.invalidDate();
-    }
-    return null;
-};
-export const getUnavailableDateCheck = ({ availability }) => (value) => isValidDate(value) ? getUnavailableDateReason(value, availability) : null;

package/build/domain/features/validation/value-checks.test.js

@@ -1,297 +0,0 @@
-import { vi } from 'vitest';
-import { mockErrorMessageFunctions } from './spec-utils';
-import { getAboveMaxFilesCheck, getAboveMaximumCheck, getAboveMaximumDateCheck, getAboveMaxItemsCheck, getAboveMaxLengthCheck, getBelowMinFilesCheck, getBelowMinimumCheck, getBelowMinimumDateCheck, getBelowMinItemsCheck, getBelowMinLengthCheck, getNotAdheringToPatternCheck, getRequiredCheck, getStringRequiredCheck, getUnavailableDateCheck, getValidDateCheck, } from './value-checks';
-describe('value checks', () => {
-    describe('getAboveMaxLengthCheck', () => {
-        it('should return null if the string length is below or equal to the maxLength', () => {
-            const schema = { type: 'string', maxLength: 5 };
-            const check = getAboveMaxLengthCheck(schema, mockErrorMessageFunctions);
-            const belowLength = check('0');
-            const atLength = check('01234');
-            expect(belowLength).toBeNull();
-            expect(atLength).toBeNull();
-        });
-        it('should return an error message if the string length is above the maxLength', () => {
-            const schema = { type: 'string', maxLength: 5 };
-            const check = getAboveMaxLengthCheck(schema, mockErrorMessageFunctions);
-            expect(check('012345')).toBe('maxLength');
-        });
-    });
-    describe('getBelowMinLengthCheck', () => {
-        it('should return null if the string length is above or equal to the minLength', () => {
-            const schema = { type: 'string', minLength: 5 };
-            const check = getBelowMinLengthCheck(schema, mockErrorMessageFunctions);
-            const atLength = check('01234');
-            const aboveLength = check('0123456789');
-            expect(atLength).toBeNull();
-            expect(aboveLength).toBeNull();
-        });
-        it('should return null if the string is empty', () => {
-            const schema = { type: 'string', minLength: 5 };
-            const check = getBelowMinLengthCheck(schema, mockErrorMessageFunctions);
-            expect(check('')).toBeNull();
-        });
-        it('should return an error message if the string length is below the minLength', () => {
-            const schema = { type: 'string', minLength: 5 };
-            const check = getBelowMinLengthCheck(schema, mockErrorMessageFunctions);
-            expect(check('0')).toBe('minLength');
-        });
-    });
-    describe('getAboveMaximumCheck', () => {
-        it('should return null if the number is below or equal to the maximum', () => {
-            const schema = { type: 'number', maximum: 10 };
-            const check = getAboveMaximumCheck(schema, mockErrorMessageFunctions);
-            const atMax = check(5);
-            const belowMax = check(10);
-            expect(atMax).toBeNull();
-            expect(belowMax).toBeNull();
-        });
-        it('should return an error message if the number is above the maximum', () => {
-            const schema = { type: 'number', maximum: 10 };
-            const check = getAboveMaximumCheck(schema, mockErrorMessageFunctions);
-            expect(check(15)).toBe('maximum');
-        });
-    });
-    describe('getBelowMinimumCheck', () => {
-        it('should return null if the number is above or equal to the minimum', () => {
-            const schema = { type: 'integer', minimum: 5 };
-            const check = getBelowMinimumCheck(schema, mockErrorMessageFunctions);
-            const atMinimum = check(5);
-            const aboveMinimum = check(10);
-            expect(atMinimum).toBeNull();
-            expect(aboveMinimum).toBeNull();
-        });
-        it('should return an error message if the number is below the minimum', () => {
-            const schema = { type: 'integer', minimum: 10 };
-            const check = getBelowMinimumCheck(schema, mockErrorMessageFunctions);
-            expect(check(5)).toBe('minimum');
-        });
-    });
-    describe('getAboveMaximumDateCheck', () => {
-        it('should return null if the date is below or equal to the maximum', () => {
-            const schema = { type: 'string', format: 'date', maximum: '2022-01-01' };
-            const check = getAboveMaximumDateCheck(schema, mockErrorMessageFunctions);
-            const atDate = check('2022-01-01');
-            const belowDate = check('2021-12-31');
-            expect(atDate).toBeNull();
-            expect(belowDate).toBeNull();
-        });
-        it('should return an error message if the date is above the maximum', () => {
-            const schema = { type: 'string', format: 'date', maximum: '2022-01-01' };
-            const check = getAboveMaximumDateCheck(schema, mockErrorMessageFunctions);
-            expect(check('2022-01-02')).toBe('maximumDate');
-        });
-        it('does not apply business validation to a partial date', () => {
-            const schema = { type: 'string', format: 'date', maximum: '2022-01-01' };
-            expect(getAboveMaximumDateCheck(schema, mockErrorMessageFunctions)('2023-01')).toBeNull();
-        });
-    });
-    describe('getUnavailableDateCheck', () => {
-        const schema = {
-            type: 'date',
-            availability: {
-                unavailable: [{ type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' }],
-            },
-        };
-        it('returns the matching reason for a complete date', () => {
-            expect(getUnavailableDateCheck(schema)('2026-09-06')).toBe('Closed on Sundays');
-        });
-        it('does not apply availability validation to a partial date', () => {
-            expect(getUnavailableDateCheck(schema)('2026-09')).toBeNull();
-        });
-    });
-    describe('getBelowMinimumDateCheck', () => {
-        it('should return null if the date is above or equal to the minimum', () => {
-            const schema = { type: 'string', format: 'date', minimum: '2022-01-01' };
-            const check = getBelowMinimumDateCheck(schema, mockErrorMessageFunctions);
-            const atDate = check('2022-01-01');
-            const aboveDate = check('2022-01-02');
-            expect(atDate).toBeNull();
-            expect(aboveDate).toBeNull();
-        });
-        it('should return an error message if the date is below the minimum', () => {
-            const schema = { type: 'string', format: 'date', minimum: '2022-01-01' };
-            const check = getBelowMinimumDateCheck(schema, mockErrorMessageFunctions);
-            expect(check('2021-12-31')).toBe('minimumDate');
-        });
-    });
-    describe('getNotAdheringToPatternCheck', () => {
-        it('should return null if the string adheres to the pattern', () => {
-            const schema = { type: 'string', pattern: '[A-Za-z]+' };
-            const check = getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions);
-            expect(check('Hello')).toBeNull();
-        });
-        it('should return null if the string is empty', () => {
-            const schema = { type: 'string', pattern: '[A-Za-z]+' };
-            const check = getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions);
-            expect(check('')).toBeNull();
-        });
-        it('should return an error message if the string does not adhere to the pattern', () => {
-            const schema = { type: 'string', pattern: '[A-Za-z]+' };
-            const check = getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions);
-            expect(check('01234')).toBe('pattern');
-        });
-        describe('unicode support', () => {
-            it('should return null if string adheres to the pattern', () => {
-                const schema = { type: 'string', pattern: '^[A-Za-z0-9\\s\\p{P}]*$' };
-                const check = getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions);
-                expect(check('23 Bananas!')).toBeNull();
-            });
-            it('should return an error message if the string does not adhere to the pattern', () => {
-                const schema = { type: 'string', pattern: '^[A-Za-z0-9\\s\\p{P}]*$' };
-                const check = getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions);
-                expect(check('é')).toBe('pattern');
-                expect(check('ñ')).toBe('pattern');
-                expect(check('❌')).toBe('pattern');
-            });
-            describe('when a pattern is valid without Unicode support but invalid with Unicode support', () => {
-                const logEvent = vi.fn();
-                const schema = { type: 'string', pattern: '^\\d{3}\\-?\\d{3}$' };
-                it('a logging event should be emitted', () => {
-                    const check = getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions, {
-                        logEvent,
-                    });
-                    expect(logEvent).toHaveBeenCalledWith('warning', expect.stringMatching(/Failed to instantiate RegExp with Unicode support/), expect.any(Object));
-                });
-                it(`the check function still works, because it doesn't use Unicode support`, () => {
-                    const check = getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions, {
-                        logEvent,
-                    });
-                    expect(check('123-123')).toBeNull();
-                    expect(check('123123')).toBeNull();
-                    expect(check('123')).toBe('pattern');
-                });
-            });
-        });
-    });
-    describe('getAboveMaxItemsCheck', () => {
-        const arraySchema = {
-            type: 'array',
-            items: { type: 'string' },
-            addItemTitle: '',
-            editItemTitle: '',
-            maxItems: 5,
-        };
-        it('should return null if the array length is below or equal to the maxItems', () => {
-            const check = getAboveMaxItemsCheck(arraySchema, mockErrorMessageFunctions);
-            const belowLength = check(['0']);
-            const atLength = check(['0', '1', '2', '3', '4']);
-            expect(belowLength).toBeNull();
-            expect(atLength).toBeNull();
-        });
-        it('should return an error message if the array length is above the maxItems', () => {
-            const check = getAboveMaxItemsCheck(arraySchema, mockErrorMessageFunctions);
-            expect(check(['0', '1', '2', '3', '4', '5'])).toBe('maxItems');
-        });
-    });
-    describe('getBelowMinItemsCheck', () => {
-        const arraySchema = {
-            type: 'array',
-            items: { type: 'string' },
-            addItemTitle: '',
-            editItemTitle: '',
-            minItems: 3,
-        };
-        it('should return null if the array length is above or equal to the minItems', () => {
-            const check = getBelowMinItemsCheck(arraySchema, mockErrorMessageFunctions);
-            const atLength = check(['0', '1', '2']);
-            const aboveLength = check(['0', '1', '2', '3']);
-            expect(atLength).toBeNull();
-            expect(aboveLength).toBeNull();
-        });
-        it('should return null if the array is empty', () => {
-            const check = getBelowMinItemsCheck(arraySchema, mockErrorMessageFunctions);
-            const empty = check([]);
-            expect(empty).toBeNull();
-        });
-        it('should return an error message if the array length is below the minItems', () => {
-            const check = getBelowMinItemsCheck(arraySchema, mockErrorMessageFunctions);
-            expect(check(['0', '1'])).toBe('minItems');
-        });
-    });
-    describe('getAboveMaxFilesCheck', () => {
-        const arraySchema = {
-            type: 'array',
-            items: { type: 'string' },
-            addItemTitle: '',
-            editItemTitle: '',
-            maxItems: 2,
-        };
-        it('should return null if the array length is below or equal to the maxItems', () => {
-            const check = getAboveMaxFilesCheck(arraySchema, mockErrorMessageFunctions);
-            const belowLength = check([new File([new Blob()], '0')]);
-            const atLength = check([new File([new Blob()], '0'), new File([new Blob()], '1')]);
-            expect(belowLength).toBeNull();
-            expect(atLength).toBeNull();
-        });
-        it('should return an error message if the array length is above the maxItems', () => {
-            const check = getAboveMaxFilesCheck(arraySchema, mockErrorMessageFunctions);
-            expect(check([
-                new File([new Blob()], '0'),
-                new File([new Blob()], '1'),
-                new File([new Blob()], '2'),
-            ])).toBe('maxFiles');
-        });
-    });
-    describe('getBelowMinFilesCheck', () => {
-        const arraySchema = {
-            type: 'array',
-            items: { type: 'string' },
-            addItemTitle: '',
-            editItemTitle: '',
-            minItems: 2,
-        };
-        it('should return null if the array length is above or equal to the minItems', () => {
-            const check = getBelowMinFilesCheck(arraySchema, mockErrorMessageFunctions);
-            const atLength = check([new File([new Blob()], '0'), new File([new Blob()], '1')]);
-            const aboveLength = check([
-                new File([new Blob()], '0'),
-                new File([new Blob()], '1'),
-                new File([new Blob()], '2'),
-            ]);
-            expect(atLength).toBeNull();
-            expect(aboveLength).toBeNull();
-        });
-        it('should return null if the array is empty', () => {
-            const check = getBelowMinFilesCheck(arraySchema, mockErrorMessageFunctions);
-            const empty = check([]);
-            expect(empty).toBeNull();
-        });
-        it('should return an error message if the array length is below the minItems', () => {
-            const check = getBelowMinFilesCheck(arraySchema, mockErrorMessageFunctions);
-            expect(check([new File([new Blob()], '0')])).toBe('minFiles');
-        });
-    });
-    describe('getValidDateCheck', () => {
-        it('should return null for partial date strings when not required', () => {
-            const check = getValidDateCheck(false, mockErrorMessageFunctions);
-            expect(check('2012-01')).toBeNull();
-        });
-        it('should return null for valid date strings when required', () => {
-            const check = getValidDateCheck(true, mockErrorMessageFunctions);
-            expect(check('2012-01-01')).toBeNull();
-        });
-        it('should return the invalid date message for partial date strings when required', () => {
-            const check = getValidDateCheck(true, mockErrorMessageFunctions);
-            expect(check('2012-01')).toBe('invalidDate');
-        });
-        it.each([null, ''])('should leave required validation to the required check for %s', (value) => {
-            const check = getValidDateCheck(true, mockErrorMessageFunctions);
-            expect(check(value)).toBeNull();
-        });
-    });
-    describe('required checks', () => {
-        describe('getRequiredCheck', () => {
-            it('should accept an empty string when required', () => {
-                const check = getRequiredCheck(true, mockErrorMessageFunctions);
-                expect(check('')).toBeNull();
-            });
-        });
-        describe('getStringRequiredCheck', () => {
-            it('should reject an empty string when required', () => {
-                const check = getStringRequiredCheck(true, mockErrorMessageFunctions);
-                expect(check('')).toBe('required');
-            });
-        });
-    });
-});

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

@@ -1,57 +0,0 @@
-import { isNullish } from '../../../utils/type-validators';
-import { debounce } from '../../components/utils/debounce';
-import { abortAndResetController } from '../utils/http-utils';
-/**
- * Creates an onValidateAsync handler for a component.
- */
-export const getComponentValidationAsync = (update, performValidationAsync) => 
-/**
- * Will update the validationAsyncState when a new request is made, and will update
- * the description or set errors when the request completes.
- */
-async (component, currentValue) => {
-    const { abortController } = component.validationAsyncState;
-    const newAbortController = abortAndResetController(abortController);
-    if (isNullish(currentValue)) {
-        update(component, (draft) => {
-            draft.validationAsyncState = {
-                abortController: newAbortController,
-                lastSubmitted: currentValue,
-                messages: {},
-                loadingState: 'idle',
-            };
-        });
-        return;
-    }
-    const { signal } = newAbortController;
-    const newSubmission = performValidationAsync({ value: currentValue, signal })
-        .then((message) => {
-        update(component, (draft) => {
-            if (message) {
-                draft.validationAsyncState.messages.success = message;
-            }
-            draft.validationAsyncState.loadingState = 'idle';
-        });
-        return message;
-    })
-        .catch((error) => {
-        if (error instanceof DOMException && error.name === 'AbortError') {
-            // No op, the request was aborted
-            return null;
-        }
-        update(component, (draft) => {
-            draft.validationAsyncState.messages.error = error.message;
-            draft.validationAsyncState.loadingState = 'idle';
-        });
-    });
-    update(component, (draft) => {
-        draft.validationAsyncState = {
-            abortController: newAbortController,
-            lastSubmitted: currentValue,
-            messages: {},
-            loadingState: 'pending',
-        };
-    });
-    return newSubmission;
-};
-export const getDebouncedComponentValidationAsync = (update, performValidationAsync) => debounce(getComponentValidationAsync(update, performValidationAsync), 1000);