@aemforms/af-core 0.22.25 → 0.22.26

package/lib/esm/utils/ValidationUtils.js

@@ -0,0 +1,274 @@
+import { extractFileInfo, getFileSizeInBytes } from './FormUtils.js';
+import { FileObject } from '../FileObject.js';
+const dateRegex = /^(\d{4})-(\d{1,2})-(\d{1,2})$/;
+const days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const daysInMonth = (leapYear, month) => {
+    if (leapYear && month == 2) {
+        return 29;
+    }
+    return days[month - 1];
+};
+const isLeapYear = (year) => {
+    return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+};
+export const coerceType = (param, type) => {
+    let num;
+    switch (type) {
+        case 'string':
+            return param + '';
+        case 'number':
+            num = +param;
+            if (!isNaN(num)) {
+                return num;
+            }
+            break;
+        case 'boolean':
+            if (typeof param === 'string') {
+                return param === 'true';
+            }
+            else if (typeof param === 'number') {
+                return param !== 0;
+            }
+    }
+    throw `${param} has invalid type. Expected : ${type}, Actual ${typeof param}`;
+};
+const checkNumber = (inputVal) => {
+    if (inputVal === '' || inputVal == null) {
+        return {
+            value: '', valid: true
+        };
+    }
+    let value = parseFloat(inputVal);
+    const valid = !isNaN(value);
+    if (!valid) {
+        value = inputVal;
+    }
+    return {
+        value, valid
+    };
+};
+const checkInteger = (inputVal) => {
+    if (inputVal == '' || inputVal == null) {
+        return {
+            value: '', valid: true
+        };
+    }
+    let value = parseFloat(inputVal);
+    const valid = !isNaN(value) && Math.round(value) === value;
+    if (!valid) {
+        value = inputVal;
+    }
+    return {
+        value, valid
+    };
+};
+const toArray = (inputVal) => {
+    if (inputVal != null && !(inputVal instanceof Array)) {
+        return [inputVal];
+    }
+    return inputVal;
+};
+const checkBool = (inputVal) => {
+    const valid = typeof inputVal === 'boolean' || inputVal === 'true' || inputVal === 'false';
+    const value = typeof inputVal === 'boolean' ? inputVal : (valid ? inputVal === 'true' : inputVal);
+    return { valid, value };
+};
+const checkFile = (inputVal) => {
+    const value = extractFileInfo(inputVal);
+    const valid = value !== null;
+    return {
+        value: valid ? value : inputVal,
+        valid
+    };
+};
+const matchMediaType = (mediaType, accepts) => {
+    return !mediaType || accepts.some((accept) => {
+        const trimmedAccept = accept.trim();
+        const prefixAccept = trimmedAccept.split('/')[0];
+        const suffixAccept = trimmedAccept.split('.')[1];
+        return ((trimmedAccept.includes('*') && mediaType.startsWith(prefixAccept)) ||
+            (trimmedAccept.includes('.') && mediaType.endsWith(suffixAccept)) ||
+            (trimmedAccept === mediaType));
+    });
+};
+const partitionArray = (inputVal, validatorFn) => {
+    const value = toArray(inputVal);
+    if (value == null) {
+        return [[], [value]];
+    }
+    return value.reduce((acc, x) => {
+        if (acc[1].length == 0) {
+            const r = validatorFn(x);
+            const index = r.valid ? 0 : 1;
+            acc[index].push(r.value);
+        }
+        return acc;
+    }, [[], []]);
+};
+export const ValidConstraints = {
+    date: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'format'],
+    string: ['minLength', 'maxLength', 'pattern'],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'],
+    array: ['minItems', 'maxItems', 'uniqueItems'],
+    file: ['accept', 'maxFileSize']
+};
+export const Constraints = {
+    type: (constraint, inputVal) => {
+        let value = inputVal;
+        if (inputVal == undefined) {
+            return {
+                valid: true,
+                value: inputVal
+            };
+        }
+        let valid = true, res;
+        switch (constraint) {
+            case 'string':
+                valid = true;
+                value = inputVal.toString();
+                break;
+            case 'string[]':
+                value = toArray(inputVal);
+                break;
+            case 'number':
+                res = checkNumber(inputVal);
+                value = res.value;
+                valid = res.valid;
+                break;
+            case 'boolean':
+                res = checkBool(inputVal);
+                valid = res.valid;
+                value = res.value;
+                break;
+            case 'integer':
+                res = checkInteger(inputVal);
+                valid = res.valid;
+                value = res.value;
+                break;
+            case 'integer[]':
+                res = partitionArray(inputVal, checkInteger);
+                valid = res[1].length === 0;
+                value = valid ? res[0] : inputVal;
+                break;
+            case 'file':
+                res = checkFile(inputVal instanceof Array ? inputVal[0] : inputVal);
+                valid = res.valid;
+                value = res.value;
+                break;
+            case 'file[]':
+                res = partitionArray(inputVal, checkFile);
+                valid = res[1].length === 0;
+                value = valid ? res[0] : inputVal;
+                break;
+            case 'number[]':
+                res = partitionArray(inputVal, checkNumber);
+                valid = res[1].length === 0;
+                value = valid ? res[0] : inputVal;
+                break;
+            case 'boolean[]':
+                res = partitionArray(inputVal, checkBool);
+                valid = res[1].length === 0;
+                value = valid ? res[0] : inputVal;
+                break;
+        }
+        return {
+            valid,
+            value
+        };
+    },
+    format: (constraint, input) => {
+        let valid = true;
+        const value = input;
+        if (input === null) {
+            return { value, valid };
+        }
+        let res;
+        switch (constraint) {
+            case 'date':
+                res = dateRegex.exec((input || '').trim());
+                if (res != null) {
+                    const [match, year, month, date] = res;
+                    const [nMonth, nDate] = [+month, +date];
+                    const leapYear = isLeapYear(+year);
+                    valid = (nMonth >= 1 && nMonth <= 12) &&
+                        (nDate >= 1 && nDate <= daysInMonth(leapYear, nMonth));
+                }
+                else {
+                    valid = false;
+                }
+                break;
+            case 'data-url':
+                valid = true;
+                break;
+        }
+        return { valid, value };
+    },
+    minimum: (constraint, value) => {
+        return { valid: value >= constraint, value };
+    },
+    maximum: (constraint, value) => {
+        return { valid: value <= constraint, value };
+    },
+    exclusiveMinimum: (constraint, value) => {
+        return { valid: value > constraint, value };
+    },
+    exclusiveMaximum: (constraint, value) => {
+        return { valid: value < constraint, value };
+    },
+    minItems: (constraint, value) => {
+        return { valid: (value instanceof Array) && value.length >= constraint, value };
+    },
+    maxItems: (constraint, value) => {
+        return { valid: (value instanceof Array) && value.length <= constraint, value };
+    },
+    uniqueItems: (constraint, value) => {
+        return { valid: !constraint || ((value instanceof Array) && value.length === new Set(value).size), value };
+    },
+    minLength: (constraint, value) => {
+        return { ...Constraints.minimum(constraint, typeof value === 'string' ? value.length : 0), value };
+    },
+    maxLength: (constraint, value) => {
+        return { ...Constraints.maximum(constraint, typeof value === 'string' ? value.length : 0), value };
+    },
+    pattern: (constraint, value) => {
+        let regex;
+        if (typeof constraint === 'string') {
+            regex = new RegExp(constraint);
+        }
+        else {
+            regex = constraint;
+        }
+        return { valid: regex.test(value), value };
+    },
+    required: (constraint, value) => {
+        const valid = constraint ? value != null && value !== '' : true;
+        return { valid, value };
+    },
+    enum: (constraint, value) => {
+        return {
+            valid: constraint.indexOf(value) > -1,
+            value
+        };
+    },
+    accept: (constraint, value) => {
+        if (!constraint || constraint.length === 0 || value === null || value === undefined) {
+            return {
+                valid: true,
+                value
+            };
+        }
+        const tempValue = value instanceof Array ? value : [value];
+        const invalidFile = tempValue.some((file) => !matchMediaType(file.type, constraint));
+        return {
+            valid: !invalidFile,
+            value
+        };
+    },
+    maxFileSize: (constraint, value) => {
+        const sizeLimit = typeof constraint === 'string' ? getFileSizeInBytes(constraint) : constraint;
+        return {
+            valid: !(value instanceof FileObject) || value.size <= sizeLimit,
+            value
+        };
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aemforms/af-core",
-  "version": "0.22.25",
+  "version": "0.22.26",
   "description": "Core Module for Forms Runtime",
   "author": "Adobe Systems",
   "license": "Adobe Proprietary",