@aemforms/af-core 0.22.74 → 0.22.75

package/esm/afb-runtime.js

@@ -578,285 +578,812 @@ const resolveData = (data, input, create) => {
     return result;
 };
 
-const editableProperties = [
-    'value',
-    'label',
-    'description',
-    'visible',
-    'enabled',
-    'valid',
-    'errorMessage',
-    'readOnly',
-    'enum',
-    'enumNames',
-    'required',
-    'properties',
-    'exclusiveMinimum',
-    'exclusiveMaximum',
-    'maximum',
-    'maxItems',
-    'minimum',
-    'minItems',
-    'checked'
-];
-const dynamicProps = [
-    ...editableProperties,
-    'index',
-    'activeChild'
-];
-const staticFields = ['plain-text', 'image'];
-class ActionImplWithTarget {
-    _action;
-    _target;
-    constructor(_action, _target) {
-        this._action = _action;
-        this._target = _target;
+class FileObject {
+    data;
+    mediaType = 'application/octet-stream';
+    name = 'unknown';
+    size = 0;
+    constructor(init) {
+        Object.assign(this, init);
     }
     get type() {
-        return this._action.type;
-    }
-    get payload() {
-        return this._action.payload;
-    }
-    get metadata() {
-        return this._action.metadata;
-    }
-    get target() {
-        return this._target;
-    }
-    get isCustomEvent() {
-        return this._action.isCustomEvent;
+        return this.mediaType;
     }
-    get originalAction() {
-        return this._action.originalAction;
+    toJSON() {
+        return {
+            'name': this.name,
+            'size': this.size,
+            'mediaType': this.mediaType,
+            'data': this.data.toString()
+        };
     }
-    toString() {
-        return this._action.toString();
+    equals(obj) {
+        return (this.data === obj.data &&
+            this.mediaType === obj.mediaType &&
+            this.name === obj.name &&
+            this.size === obj.size);
     }
 }
-const target = Symbol('target');
-const qualifiedName = Symbol('qualifiedName');
-function dependencyTracked() {
-    return function (target, propertyKey, descriptor) {
-        const get = descriptor.get;
-        if (get != undefined) {
-            descriptor.get = function () {
-                this.ruleEngine.trackDependency(this);
-                return get.call(this);
-            };
+
+const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'.split('');
+const fileSizeRegex = /^(\d*\.?\d+)(\\?(?=[KMGT])([KMGT])(?:i?B)?|B?)$/i;
+const randomWord = (l) => {
+    const ret = [];
+    for (let i = 0; i <= l; i++) {
+        let randIndex;
+        if (i === 0) {
+            randIndex = Math.floor(Math.random() * (chars.length - 11));
         }
-    };
-}
-const addOnly = (includeOrExclude) => (...fieldTypes) => (target, propertyKey, descriptor) => {
-    const get = descriptor.get;
-    if (get != undefined) {
-        descriptor.get = function () {
-            if (fieldTypes.indexOf(this.fieldType) > -1 === includeOrExclude) {
-                return get.call(this);
-            }
-            return undefined;
-        };
-    }
-    const set = descriptor.set;
-    if (set != undefined) {
-        descriptor.set = function (value) {
-            if (fieldTypes.indexOf(this.fieldType) > -1 === includeOrExclude) {
-                set.call(this, value);
-            }
-        };
+        else {
+            randIndex = Math.floor(Math.random() * (chars.length));
+        }
+        ret.push(chars[randIndex]);
     }
+    return ret.join('');
 };
-const include = addOnly(true);
-const exclude = addOnly(false);
-class BaseNode {
-    _options;
-    _ruleNode;
-    _lang = '';
-    _callbacks = {};
-    _dependents = [];
-    _jsonModel;
-    _tokens = [];
-    get isContainer() {
-        return false;
-    }
-    constructor(params, _options) {
-        this._options = _options;
-        this[qualifiedName] = null;
-        this._jsonModel = {
-            ...params,
-            id: 'id' in params ? params.id : this.form.getUniqueId()
-        };
-    }
-    setupRuleNode() {
-        const self = this;
-        this._ruleNode = new Proxy(this.ruleNodeReference(), {
-            get: (ruleNodeReference, prop) => {
-                return self.getFromRule(ruleNodeReference, prop);
-            }
-        });
-    }
-    ruleNodeReference() {
-        return this;
-    }
-    getRuleNode() {
-        return this._ruleNode;
-    }
-    getFromRule(ruleNodeReference, prop) {
-        if (prop === Symbol.toPrimitive || (prop === 'valueOf' && !ruleNodeReference.hasOwnProperty('valueOf'))) {
-            return this.valueOf;
+const getAttachments = (input, excludeUnbound = false) => {
+    const items = input.items || [];
+    return items?.reduce((acc, item) => {
+        if (excludeUnbound && item.dataRef === null) {
+            return acc;
         }
-        else if (prop === target) {
-            return this;
+        let ret = null;
+        if (item.isContainer) {
+            ret = getAttachments(item, excludeUnbound);
         }
-        else if (typeof (prop) === 'string') {
-            if (prop.startsWith('$')) {
-                prop = prop.substr(1);
-                if (typeof this[prop] !== 'function') {
-                    const retValue = this[prop];
-                    if (retValue instanceof BaseNode) {
-                        return retValue.getRuleNode();
-                    }
-                    else if (retValue instanceof Array) {
-                        return retValue.map(r => r instanceof BaseNode ? r.getRuleNode() : r);
-                    }
-                    else {
-                        return retValue;
-                    }
-                }
-            }
-            else {
-                if (ruleNodeReference.hasOwnProperty(prop)) {
-                    return ruleNodeReference[prop];
+        else {
+            if (isFile(item.getState())) {
+                ret = {};
+                const name = item.name || '';
+                const dataRef = (item.dataRef != null)
+                    ? item.dataRef
+                    : (name.length > 0 ? item.name : undefined);
+                if (item.value instanceof Array) {
+                    ret[item.id] = item.value.map((x) => {
+                        return { ...x, 'dataRef': dataRef };
+                    });
                 }
-                else if (typeof ruleNodeReference[prop] === 'function') {
-                    return ruleNodeReference[prop];
+                else if (item.value != null) {
+                    ret[item.id] = { ...item.value, 'dataRef': dataRef };
                 }
             }
         }
-    }
-    get id() {
-        return this._jsonModel.id;
-    }
-    get index() {
-        if (this.parent) {
-            return this.parent.indexOf(this);
+        return Object.assign(acc, ret);
+    }, {});
+};
+const getFileSizeInBytes = (str) => {
+    let retVal = 0;
+    if (typeof str === 'string') {
+        const matches = fileSizeRegex.exec(str.trim());
+        if (matches != null) {
+            retVal = sizeToBytes(parseFloat(matches[1]), (matches[2] || 'kb').toUpperCase());
         }
-        return 0;
-    }
-    get parent() {
-        return this._options.parent;
-    }
-    get type() {
-        return this._jsonModel.type;
-    }
-    get repeatable() {
-        return this.parent?.hasDynamicItems();
-    }
-    get fieldType() {
-        return this._jsonModel.fieldType || 'text-input';
     }
-    get ':type'() {
-        return this._jsonModel[':type'] || this.fieldType;
-    }
-    get name() {
-        return this._jsonModel.name;
-    }
-    get description() {
-        return this._jsonModel.description;
-    }
-    set description(d) {
-        this._setProperty('description', d);
-    }
-    get dataRef() {
-        return this._jsonModel.dataRef;
-    }
-    get visible() {
-        if (this.parent?.visible !== undefined) {
-            return this.parent?.visible ? this._jsonModel.visible : false;
+    return retVal;
+};
+const sizeToBytes = (size, symbol) => {
+    const sizes = { 'KB': 1, 'MB': 2, 'GB': 3, 'TB': 4 };
+    const i = Math.pow(1024, sizes[symbol]);
+    return Math.round(size * i);
+};
+const IdGenerator = function* (initial = 50) {
+    const initialize = function () {
+        const arr = [];
+        for (let i = 0; i < initial; i++) {
+            arr.push(randomWord(10));
         }
-        else {
-            return this._jsonModel.visible;
+        return arr;
+    };
+    const passedIds = {};
+    let ids = initialize();
+    do {
+        let x = ids.pop();
+        while (x in passedIds) {
+            if (ids.length === 0) {
+                ids = initialize();
+            }
+            x = ids.pop();
         }
-    }
-    set visible(v) {
-        if (v !== this._jsonModel.visible) {
-            const changeAction = propertyChange('visible', v, this._jsonModel.visible);
-            this._jsonModel.visible = v;
-            this.notifyDependents(changeAction);
+        passedIds[x] = true;
+        yield ids.pop();
+        if (ids.length === 0) {
+            ids = initialize();
+        }
+    } while (ids.length > 0);
+};
+const isDataUrl = (str) => {
+    const dataUrlRegex = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
+    return dataUrlRegex.exec(str.trim()) != null;
+};
+const extractFileInfo = (file) => {
+    if (file !== null) {
+        let retVal = null;
+        if (file instanceof FileObject) {
+            retVal = file;
+        }
+        else if (typeof File !== 'undefined' && file instanceof File) {
+            retVal = {
+                name: file.name,
+                mediaType: file.type,
+                size: file.size,
+                data: file
+            };
+        }
+        else if (typeof file === 'string' && isDataUrl(file)) {
+            const result = dataURItoBlob(file);
+            if (result !== null) {
+                const { blob, name } = result;
+                retVal = {
+                    name: name,
+                    mediaType: blob.type,
+                    size: blob.size,
+                    data: blob
+                };
+            }
+        }
+        else {
+            let jFile = file;
+            try {
+                jFile = JSON.parse(file);
+                retVal = jFile;
+                if (!retVal.mediaType) {
+                    retVal.mediaType = retVal.type;
+                }
+            }
+            catch (ex) {
+            }
+            if (typeof jFile?.data === 'string' && isDataUrl(jFile?.data)) {
+                const result = dataURItoBlob(jFile?.data);
+                if (result !== null) {
+                    const blob = result.blob;
+                    retVal = {
+                        name: jFile?.name,
+                        mediaType: jFile?.type || jFile?.mediaType,
+                        size: blob.size,
+                        data: blob
+                    };
+                }
+            }
+            else if (typeof jFile === 'string') {
+                const fileName = jFile.split('/').pop();
+                retVal = {
+                    name: fileName,
+                    mediaType: 'application/octet-stream',
+                    size: 0,
+                    data: jFile
+                };
+            }
+            else if (typeof jFile === 'object') {
+                retVal = {
+                    name: jFile?.name,
+                    mediaType: jFile?.type || jFile?.mediaType,
+                    size: jFile?.size,
+                    data: jFile?.data
+                };
+            }
+        }
+        if (retVal !== null && retVal.data != null) {
+            return new FileObject(retVal);
         }
+        return null;
     }
-    get form() {
-        return this._options.form;
+    else {
+        return null;
     }
-    get ruleEngine() {
-        return this.form.ruleEngine;
+};
+const dataURItoBlob = (dataURI) => {
+    const regex = /^data:([a-z]+\/[a-z0-9-+.]+)?(?:;name=([^;]+))?(;base64)?,(.+)$/;
+    const groups = regex.exec(dataURI);
+    if (groups !== null) {
+        const type = groups[1] || '';
+        const name = groups[2] || 'unknown';
+        const isBase64 = typeof groups[3] === 'string';
+        if (isBase64) {
+            const binary = atob(groups[4]);
+            const array = [];
+            for (let i = 0; i < binary.length; i++) {
+                array.push(binary.charCodeAt(i));
+            }
+            const blob = new window.Blob([new Uint8Array(array)], { type });
+            return { name, blob };
+        }
+        else {
+            const blob = new window.Blob([groups[4]], { type });
+            return { name, blob };
+        }
     }
-    get label() {
-        return this._jsonModel.label;
+    else {
+        return null;
     }
-    set label(l) {
-        if (l !== this._jsonModel.label) {
-            const changeAction = propertyChange('label', l, this._jsonModel.label);
-            this._jsonModel = {
-                ...this._jsonModel,
-                label: l
-            };
-            this.notifyDependents(changeAction);
-        }
+};
+const isFormOrSiteContainer = (model) => {
+    return (':items' in model || 'cqItems' in model) && (':itemsOrder' in model || 'cqItemsOrder' in model);
+};
+const sitesModelToFormModel = (sitesModel) => {
+    if (!sitesModel || !Object.keys(sitesModel).length) {
+        return sitesModel;
     }
-    get uniqueItems() {
-        return this._jsonModel.uniqueItems;
+    if (isFormOrSiteContainer(sitesModel)) {
+        const itemsArr = [];
+        const itemsOrder = sitesModel[':itemsOrder'] || sitesModel.cqItemsOrder;
+        const items = sitesModel[':items'] || sitesModel.cqItems;
+        itemsOrder.forEach((elemName) => {
+            itemsArr.push(sitesModelToFormModel(items[elemName]));
+        });
+        sitesModel.items = itemsArr;
     }
-    isTransparent() {
-        const isNonTransparent = this.parent?._jsonModel.type === 'array';
-        return !this._jsonModel.name && !isNonTransparent;
+    return sitesModel;
+};
+const replaceTemplatePlaceholders = (str, values = []) => {
+    return str?.replace(/\${(\d+)}/g, (match, index) => {
+        const replacement = values[index];
+        return typeof replacement !== 'undefined' ? replacement : match;
+    });
+};
+
+const dateRegex = /^(\d{4})-(\d{1,2})-(\d{1,2})$/;
+const emailRegex = /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/;
+const days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const daysInMonth = (leapYear, month) => {
+    if (leapYear && month == 2) {
+        return 29;
     }
-    getState(forRestore = false) {
+    return days[month - 1];
+};
+const isLeapYear = (year) => {
+    return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+};
+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 {
-            ...this._jsonModel,
-            properties: this.properties,
-            index: this.index,
-            parent: undefined,
-            qualifiedName: this.qualifiedName,
-            repeatable: this.repeatable === true ? true : undefined,
-            ':type': this[':type'],
-            ...(forRestore ? {
-                _dependents: this._dependents.length ? this._dependents.map(x => x.node.id) : undefined,
-                allowedComponents: undefined,
-                columnClassNames: undefined,
-                columnCount: undefined,
-                gridClassNames: undefined
-            } : {})
+            value: '', valid: true
         };
     }
-    subscribe(callback, eventName = 'change') {
-        this._callbacks[eventName] = this._callbacks[eventName] || [];
-        this._callbacks[eventName].push(callback);
+    let value = parseFloat(inputVal);
+    const valid = !isNaN(value);
+    if (!valid) {
+        value = inputVal;
+    }
+    return {
+        value, valid
+    };
+};
+const checkInteger = (inputVal) => {
+    if (inputVal == '' || inputVal == null) {
         return {
-            unsubscribe: () => {
-                this._callbacks[eventName] = this._callbacks[eventName].filter(x => x !== callback);
-            }
+            value: '', valid: true
         };
     }
-    _addDependent(dependent) {
-        if (this._dependents.find(({ node }) => node === dependent) === undefined) {
-            const subscription = this.subscribe((change) => {
-                const changes = change.payload.changes;
-                const propsToLook = [...dynamicProps, 'items'];
-                const isPropChanged = changes.findIndex(x => {
-                    return propsToLook.indexOf(x.propertyName) > -1;
-                }) > -1;
-                if (isPropChanged) {
-                    dependent.dispatch(new ExecuteRule());
-                }
-            });
-            this._dependents.push({ node: dependent, subscription });
-        }
+    let value = parseFloat(inputVal);
+    const valid = !isNaN(value) && Math.round(value) === value;
+    if (!valid) {
+        value = inputVal;
     }
-    removeDependent(dependent) {
-        const index = this._dependents.findIndex(({ node }) => node === dependent);
-        if (index > -1) {
-            this._dependents[index].subscription.unsubscribe();
+    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;
+    }, [[], []]);
+};
+const ValidConstraints = {
+    date: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'format'],
+    string: ['minLength', 'maxLength', 'pattern'],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'],
+    array: ['minItems', 'maxItems', 'uniqueItems'],
+    file: ['accept', 'maxFileSize'],
+    email: ['minLength', 'maxLength', 'format', 'pattern']
+};
+const validationConstraintsList = ['type', 'format', 'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'minItems',
+    'maxItems', 'uniqueItems', 'minLength', 'maxLength', 'pattern', 'required', 'enum', 'accept', 'maxFileSize'];
+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 'email':
+                valid = new RegExp(emailRegex).test((input || '').trim());
+                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
+        };
+    }
+};
+
+const editableProperties = [
+    'value',
+    'label',
+    'description',
+    'visible',
+    'enabled',
+    'valid',
+    'errorMessage',
+    'readOnly',
+    'enum',
+    'enumNames',
+    'required',
+    'properties',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+    'maximum',
+    'maxItems',
+    'minimum',
+    'minItems',
+    'checked'
+];
+const dynamicProps = [
+    ...editableProperties,
+    'index',
+    'activeChild'
+];
+const staticFields = ['plain-text', 'image'];
+class ActionImplWithTarget {
+    _action;
+    _target;
+    constructor(_action, _target) {
+        this._action = _action;
+        this._target = _target;
+    }
+    get type() {
+        return this._action.type;
+    }
+    get payload() {
+        return this._action.payload;
+    }
+    get metadata() {
+        return this._action.metadata;
+    }
+    get target() {
+        return this._target;
+    }
+    get isCustomEvent() {
+        return this._action.isCustomEvent;
+    }
+    get originalAction() {
+        return this._action.originalAction;
+    }
+    toString() {
+        return this._action.toString();
+    }
+}
+const target = Symbol('target');
+const qualifiedName = Symbol('qualifiedName');
+function dependencyTracked() {
+    return function (target, propertyKey, descriptor) {
+        const get = descriptor.get;
+        if (get != undefined) {
+            descriptor.get = function () {
+                this.ruleEngine.trackDependency(this);
+                return get.call(this);
+            };
+        }
+    };
+}
+const addOnly = (includeOrExclude) => (...fieldTypes) => (target, propertyKey, descriptor) => {
+    const get = descriptor.get;
+    if (get != undefined) {
+        descriptor.get = function () {
+            if (fieldTypes.indexOf(this.fieldType) > -1 === includeOrExclude) {
+                return get.call(this);
+            }
+            return undefined;
+        };
+    }
+    const set = descriptor.set;
+    if (set != undefined) {
+        descriptor.set = function (value) {
+            if (fieldTypes.indexOf(this.fieldType) > -1 === includeOrExclude) {
+                set.call(this, value);
+            }
+        };
+    }
+};
+const include = addOnly(true);
+const exclude = addOnly(false);
+class BaseNode {
+    _options;
+    _ruleNode;
+    _lang = '';
+    _callbacks = {};
+    _dependents = [];
+    _jsonModel;
+    _tokens = [];
+    get isContainer() {
+        return false;
+    }
+    constructor(params, _options) {
+        this._options = _options;
+        this[qualifiedName] = null;
+        this._jsonModel = {
+            ...params,
+            id: 'id' in params ? params.id : this.form.getUniqueId()
+        };
+    }
+    setupRuleNode() {
+        const self = this;
+        this._ruleNode = new Proxy(this.ruleNodeReference(), {
+            get: (ruleNodeReference, prop) => {
+                return self.getFromRule(ruleNodeReference, prop);
+            }
+        });
+    }
+    ruleNodeReference() {
+        return this;
+    }
+    getRuleNode() {
+        return this._ruleNode;
+    }
+    getFromRule(ruleNodeReference, prop) {
+        if (prop === Symbol.toPrimitive || (prop === 'valueOf' && !ruleNodeReference.hasOwnProperty('valueOf'))) {
+            return this.valueOf;
+        }
+        else if (prop === target) {
+            return this;
+        }
+        else if (typeof (prop) === 'string') {
+            if (prop.startsWith('$')) {
+                prop = prop.substr(1);
+                if (typeof this[prop] !== 'function') {
+                    const retValue = this[prop];
+                    if (retValue instanceof BaseNode) {
+                        return retValue.getRuleNode();
+                    }
+                    else if (retValue instanceof Array) {
+                        return retValue.map(r => r instanceof BaseNode ? r.getRuleNode() : r);
+                    }
+                    else {
+                        return retValue;
+                    }
+                }
+            }
+            else {
+                if (ruleNodeReference.hasOwnProperty(prop)) {
+                    return ruleNodeReference[prop];
+                }
+                else if (typeof ruleNodeReference[prop] === 'function') {
+                    return ruleNodeReference[prop];
+                }
+            }
+        }
+    }
+    get id() {
+        return this._jsonModel.id;
+    }
+    get index() {
+        if (this.parent) {
+            return this.parent.indexOf(this);
+        }
+        return 0;
+    }
+    get parent() {
+        return this._options.parent;
+    }
+    get type() {
+        return this._jsonModel.type;
+    }
+    get repeatable() {
+        return this.parent?.hasDynamicItems();
+    }
+    get fieldType() {
+        return this._jsonModel.fieldType || 'text-input';
+    }
+    get ':type'() {
+        return this._jsonModel[':type'] || this.fieldType;
+    }
+    get name() {
+        return this._jsonModel.name;
+    }
+    get description() {
+        return this._jsonModel.description;
+    }
+    set description(d) {
+        this._setProperty('description', d);
+    }
+    get dataRef() {
+        return this._jsonModel.dataRef;
+    }
+    get visible() {
+        if (this.parent?.visible !== undefined) {
+            return this.parent?.visible ? this._jsonModel.visible : false;
+        }
+        else {
+            return this._jsonModel.visible;
+        }
+    }
+    set visible(v) {
+        if (v !== this._jsonModel.visible) {
+            const changeAction = propertyChange('visible', v, this._jsonModel.visible);
+            this._jsonModel.visible = v;
+            this.notifyDependents(changeAction);
+        }
+    }
+    get form() {
+        return this._options.form;
+    }
+    get ruleEngine() {
+        return this.form.ruleEngine;
+    }
+    get label() {
+        return this._jsonModel.label;
+    }
+    set label(l) {
+        if (l !== this._jsonModel.label) {
+            const changeAction = propertyChange('label', l, this._jsonModel.label);
+            this._jsonModel = {
+                ...this._jsonModel,
+                label: l
+            };
+            this.notifyDependents(changeAction);
+        }
+    }
+    get uniqueItems() {
+        return this._jsonModel.uniqueItems;
+    }
+    isTransparent() {
+        const isNonTransparent = this.parent?._jsonModel.type === 'array';
+        return !this._jsonModel.name && !isNonTransparent;
+    }
+    getState(forRestore = false) {
+        return {
+            ...this._jsonModel,
+            properties: this.properties,
+            index: this.index,
+            parent: undefined,
+            qualifiedName: this.qualifiedName,
+            ...(this.repeatable === true ? {
+                repeatable: true,
+                minOccur: this.parent.minItems,
+                maxOccur: this.parent.maxItems
+            } : {}),
+            ':type': this[':type'],
+            ...(forRestore ? {
+                _dependents: this._dependents.length ? this._dependents.map(x => x.node.id) : undefined,
+                allowedComponents: undefined,
+                columnClassNames: undefined,
+                columnCount: undefined,
+                gridClassNames: undefined
+            } : {})
+        };
+    }
+    subscribe(callback, eventName = 'change') {
+        this._callbacks[eventName] = this._callbacks[eventName] || [];
+        this._callbacks[eventName].push(callback);
+        return {
+            unsubscribe: () => {
+                this._callbacks[eventName] = this._callbacks[eventName].filter(x => x !== callback);
+            }
+        };
+    }
+    _addDependent(dependent) {
+        if (this._dependents.find(({ node }) => node === dependent) === undefined) {
+            const subscription = this.subscribe((change) => {
+                const changes = change.payload.changes;
+                const propsToLook = [...dynamicProps, 'items'];
+                const isPropChanged = changes.findIndex(x => {
+                    return propsToLook.indexOf(x.propertyName) > -1;
+                }) > -1;
+                if (isPropChanged) {
+                    dependent.dispatch(new ExecuteRule());
+                }
+            });
+            this._dependents.push({ node: dependent, subscription });
+        }
+    }
+    removeDependent(dependent) {
+        const index = this._dependents.findIndex(({ node }) => node === dependent);
+        if (index > -1) {
+            this._dependents[index].subscription.unsubscribe();
             this._dependents.splice(index, 1);
         }
     }
@@ -904,6 +1431,9 @@ class BaseNode {
                 this.notifyDependents(changeAction);
             }
             notifyChildren.call(this, changeAction);
+            if (validationConstraintsList.includes(prop)) {
+                this.validate();
+            }
             return changeAction.payload.changes;
         }
         return [];
@@ -1837,257 +2367,14 @@ class EventQueue {
         this._isProcessing = true;
         while (this._pendingEvents.length > 0) {
             const e = this._pendingEvents[0];
-            this.logger.info(`Dequeued event : ${e.event.type} node: ${e.node.id} - ${e.node.name}`);
-            e.node.executeAction(e.event);
-            this._pendingEvents.shift();
-        }
-        this._runningEventCount = {};
-        this._isProcessing = false;
-    }
-}
-
-class FileObject {
-    data;
-    mediaType = 'application/octet-stream';
-    name = 'unknown';
-    size = 0;
-    constructor(init) {
-        Object.assign(this, init);
-    }
-    get type() {
-        return this.mediaType;
-    }
-    toJSON() {
-        return {
-            'name': this.name,
-            'size': this.size,
-            'mediaType': this.mediaType,
-            'data': this.data.toString()
-        };
-    }
-    equals(obj) {
-        return (this.data === obj.data &&
-            this.mediaType === obj.mediaType &&
-            this.name === obj.name &&
-            this.size === obj.size);
-    }
-}
-
-const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_'.split('');
-const fileSizeRegex = /^(\d*\.?\d+)(\\?(?=[KMGT])([KMGT])(?:i?B)?|B?)$/i;
-const randomWord = (l) => {
-    const ret = [];
-    for (let i = 0; i <= l; i++) {
-        let randIndex;
-        if (i === 0) {
-            randIndex = Math.floor(Math.random() * (chars.length - 11));
-        }
-        else {
-            randIndex = Math.floor(Math.random() * (chars.length));
-        }
-        ret.push(chars[randIndex]);
-    }
-    return ret.join('');
-};
-const getAttachments = (input, excludeUnbound = false) => {
-    const items = input.items || [];
-    return items?.reduce((acc, item) => {
-        if (excludeUnbound && item.dataRef === null) {
-            return acc;
-        }
-        let ret = null;
-        if (item.isContainer) {
-            ret = getAttachments(item, excludeUnbound);
-        }
-        else {
-            if (isFile(item.getState())) {
-                ret = {};
-                const name = item.name || '';
-                const dataRef = (item.dataRef != null)
-                    ? item.dataRef
-                    : (name.length > 0 ? item.name : undefined);
-                if (item.value instanceof Array) {
-                    ret[item.id] = item.value.map((x) => {
-                        return { ...x, 'dataRef': dataRef };
-                    });
-                }
-                else if (item.value != null) {
-                    ret[item.id] = { ...item.value, 'dataRef': dataRef };
-                }
-            }
-        }
-        return Object.assign(acc, ret);
-    }, {});
-};
-const getFileSizeInBytes = (str) => {
-    let retVal = 0;
-    if (typeof str === 'string') {
-        const matches = fileSizeRegex.exec(str.trim());
-        if (matches != null) {
-            retVal = sizeToBytes(parseFloat(matches[1]), (matches[2] || 'kb').toUpperCase());
-        }
-    }
-    return retVal;
-};
-const sizeToBytes = (size, symbol) => {
-    const sizes = { 'KB': 1, 'MB': 2, 'GB': 3, 'TB': 4 };
-    const i = Math.pow(1024, sizes[symbol]);
-    return Math.round(size * i);
-};
-const IdGenerator = function* (initial = 50) {
-    const initialize = function () {
-        const arr = [];
-        for (let i = 0; i < initial; i++) {
-            arr.push(randomWord(10));
-        }
-        return arr;
-    };
-    const passedIds = {};
-    let ids = initialize();
-    do {
-        let x = ids.pop();
-        while (x in passedIds) {
-            if (ids.length === 0) {
-                ids = initialize();
-            }
-            x = ids.pop();
-        }
-        passedIds[x] = true;
-        yield ids.pop();
-        if (ids.length === 0) {
-            ids = initialize();
-        }
-    } while (ids.length > 0);
-};
-const isDataUrl = (str) => {
-    const dataUrlRegex = /^data:([a-z]+\/[a-z0-9-+.]+)?;(?:name=(.*);)?base64,(.*)$/;
-    return dataUrlRegex.exec(str.trim()) != null;
-};
-const extractFileInfo = (file) => {
-    if (file !== null) {
-        let retVal = null;
-        if (file instanceof FileObject) {
-            retVal = file;
-        }
-        else if (typeof File !== 'undefined' && file instanceof File) {
-            retVal = {
-                name: file.name,
-                mediaType: file.type,
-                size: file.size,
-                data: file
-            };
-        }
-        else if (typeof file === 'string' && isDataUrl(file)) {
-            const result = dataURItoBlob(file);
-            if (result !== null) {
-                const { blob, name } = result;
-                retVal = {
-                    name: name,
-                    mediaType: blob.type,
-                    size: blob.size,
-                    data: blob
-                };
-            }
-        }
-        else {
-            let jFile = file;
-            try {
-                jFile = JSON.parse(file);
-                retVal = jFile;
-                if (!retVal.mediaType) {
-                    retVal.mediaType = retVal.type;
-                }
-            }
-            catch (ex) {
-            }
-            if (typeof jFile?.data === 'string' && isDataUrl(jFile?.data)) {
-                const result = dataURItoBlob(jFile?.data);
-                if (result !== null) {
-                    const blob = result.blob;
-                    retVal = {
-                        name: jFile?.name,
-                        mediaType: jFile?.type || jFile?.mediaType,
-                        size: blob.size,
-                        data: blob
-                    };
-                }
-            }
-            else if (typeof jFile === 'string') {
-                const fileName = jFile.split('/').pop();
-                retVal = {
-                    name: fileName,
-                    mediaType: 'application/octet-stream',
-                    size: 0,
-                    data: jFile
-                };
-            }
-            else if (typeof jFile === 'object') {
-                retVal = {
-                    name: jFile?.name,
-                    mediaType: jFile?.type || jFile?.mediaType,
-                    size: jFile?.size,
-                    data: jFile?.data
-                };
-            }
-        }
-        if (retVal !== null && retVal.data != null) {
-            return new FileObject(retVal);
-        }
-        return null;
-    }
-    else {
-        return null;
-    }
-};
-const dataURItoBlob = (dataURI) => {
-    const regex = /^data:([a-z]+\/[a-z0-9-+.]+)?(?:;name=([^;]+))?(;base64)?,(.+)$/;
-    const groups = regex.exec(dataURI);
-    if (groups !== null) {
-        const type = groups[1] || '';
-        const name = groups[2] || 'unknown';
-        const isBase64 = typeof groups[3] === 'string';
-        if (isBase64) {
-            const binary = atob(groups[4]);
-            const array = [];
-            for (let i = 0; i < binary.length; i++) {
-                array.push(binary.charCodeAt(i));
-            }
-            const blob = new window.Blob([new Uint8Array(array)], { type });
-            return { name, blob };
-        }
-        else {
-            const blob = new window.Blob([groups[4]], { type });
-            return { name, blob };
-        }
-    }
-    else {
-        return null;
-    }
-};
-const isFormOrSiteContainer = (model) => {
-    return (':items' in model || 'cqItems' in model) && (':itemsOrder' in model || 'cqItemsOrder' in model);
-};
-const sitesModelToFormModel = (sitesModel) => {
-    if (!sitesModel || !Object.keys(sitesModel).length) {
-        return sitesModel;
-    }
-    if (isFormOrSiteContainer(sitesModel)) {
-        const itemsArr = [];
-        const itemsOrder = sitesModel[':itemsOrder'] || sitesModel.cqItemsOrder;
-        const items = sitesModel[':items'] || sitesModel.cqItems;
-        itemsOrder.forEach((elemName) => {
-            itemsArr.push(sitesModelToFormModel(items[elemName]));
-        });
-        sitesModel.items = itemsArr;
-    }
-    return sitesModel;
-};
-const replaceTemplatePlaceholders = (str, values = []) => {
-    return str?.replace(/\${(\d+)}/g, (match, index) => {
-        const replacement = values[index];
-        return typeof replacement !== 'undefined' ? replacement : match;
-    });
-};
+            this.logger.info(`Dequeued event : ${e.event.type} node: ${e.node.id} - ${e.node.name}`);
+            e.node.executeAction(e.event);
+            this._pendingEvents.shift();
+        }
+        this._runningEventCount = {};
+        this._isProcessing = false;
+    }
+}
 
 const request$1 = (url, data = null, options = {}) => {
     const opts = { ...defaultRequestOptions, ...options };
@@ -2336,6 +2623,11 @@ class FunctionRuntimeImpl {
                                 },
                                 exportData: () => {
                                     return FunctionRuntimeImpl.getInstance().getFunctions().exportData._func.call(undefined, args, data, interpreter);
+                                },
+                                submitForm: (payload, validateForm, contentType) => {
+                                    const submitAs = contentType || 'multipart/form-data';
+                                    const args = ['custom:submitSuccess', 'custom:submitError', submitAs, payload, validateForm];
+                                    return FunctionRuntimeImpl.getInstance().getFunctions().submitForm._func.call(undefined, args, data, interpreter);
                                 }
                             }
                         };
@@ -2437,11 +2729,24 @@ class FunctionRuntimeImpl {
             },
             submitForm: {
                 _func: (args, data, interpreter) => {
-                    const success = toString(args[0]);
-                    const error = toString(args[1]);
-                    const submit_as = args.length > 2 ? toString(args[2]) : 'multipart/form-data';
-                    const submit_data = args.length > 3 ? valueOf(args[3]) : null;
-                    const validate_form = args.length > 4 ? valueOf(args[4]) : true;
+                    let success = 'custom:submitSuccess';
+                    let error = 'custom:submitError';
+                    let submit_data;
+                    let validate_form;
+                    let submit_as;
+                    if (args.length > 0 && typeof valueOf(args[0]) === 'object') {
+                        submit_data = args.length > 0 ? valueOf(args[0]) : null;
+                        validate_form = args.length > 1 ? valueOf(args[1]) : true;
+                        submit_as = args.length > 2 ? toString(args[2]) : 'multipart/form-data';
+                    }
+                    else {
+                        interpreter.globals.form.logger.warn('This usage of submitForm is deprecated. Please see the documentation and update');
+                        success = toString(args[0]);
+                        error = toString(args[1]);
+                        submit_as = args.length > 2 ? toString(args[2]) : 'multipart/form-data';
+                        submit_data = args.length > 3 ? valueOf(args[3]) : null;
+                        validate_form = args.length > 4 ? valueOf(args[4]) : true;
+                    }
                     interpreter.globals.form.dispatch(new Submit({
                         success,
                         error,
@@ -2828,405 +3133,127 @@ function stringToNumber(str, language) {
     }
     return 0;
 }
-
-function getStringToNumberFn(locale) {
-    if (locale == null) {
-        const localeOptions = new Intl.DateTimeFormat().resolvedOptions();
-        locale = localeOptions.locale;
-    }
-    return (str) => stringToNumber(str, locale);
-}
-class RuleEngine {
-    _context;
-    _globalNames = [
-        '$form',
-        '$field',
-        '$event'
-    ];
-    customFunctions;
-    debugInfo = [];
-    constructor() {
-        this.customFunctions = FunctionRuntime.getFunctions();
-    }
-    compileRule(rule, locale) {
-        const formula = new Formula(this.customFunctions, getStringToNumberFn(locale), this.debugInfo);
-        return { formula, ast: formula.compile(rule, this._globalNames) };
-    }
-    execute(node, data, globals, useValueOf = false) {
-        const { formula, ast } = node;
-        const oldContext = this._context;
-        this._context = globals;
-        let res = undefined;
-        try {
-            res = formula.run(ast, data, 'en-US', globals);
-        }
-        catch (err) {
-            this._context?.form?.logger?.error(err);
-        }
-        while (this.debugInfo.length > 0) {
-            this._context?.form?.logger?.debug(this.debugInfo.pop());
-        }
-        let finalRes = res;
-        if (useValueOf) {
-            if (typeof res === 'object' && res !== null) {
-                finalRes = Object.getPrototypeOf(res).valueOf.call(res);
-            }
-        }
-        this._context = oldContext;
-        return finalRes;
-    }
-    trackDependency(subscriber) {
-        if (this._context && this._context.field !== undefined && this._context.field !== subscriber) {
-            subscriber._addDependent(this._context.field);
-        }
-    }
-}
-
-class Fieldset extends Container {
-    constructor(params, _options) {
-        super(params, _options);
-        if (_options.mode !== 'restore') {
-            this._applyDefaults();
-            this.queueEvent(new Initialize());
-            this.queueEvent(new ExecuteRule());
-        }
-    }
-    _getDefaults() {
-        return {
-            ...super._getDefaults(),
-            visible: true,
-            required: false,
-            label: {
-                visible: true,
-                richText: false
-            }
-        };
-    }
-    _applyDefaults() {
-        super._applyDefaultsInModel();
-        if (this._jsonModel.dataRef && this._jsonModel.type === undefined) {
-            this._jsonModel.type = 'object';
-        }
-    }
-    get type() {
-        const ret = super.type;
-        if (ret === 'array' || ret === 'object') {
-            return ret;
-        }
-        return undefined;
-    }
-    get items() {
-        return super.items;
-    }
-    get value() {
-        return null;
-    }
-    get fieldType() {
-        return 'panel';
-    }
-}
-
-class InstanceManager extends Fieldset {
-    get maxOccur() {
-        return this._jsonModel.maxItems;
-    }
-    set maxOccur(m) {
-        this.maxItems = m;
-    }
-    get minOccur() {
-        return this.minItems;
-    }
-    addInstance(action) {
-        return this.addItem(action);
-    }
-    removeInstance(action) {
-        return this.removeItem(action);
-    }
-}
-__decorate([
-    dependencyTracked()
-], InstanceManager.prototype, "maxOccur", null);
-__decorate([
-    dependencyTracked()
-], InstanceManager.prototype, "minOccur", null);
-
-const dateRegex = /^(\d{4})-(\d{1,2})-(\d{1,2})$/;
-const emailRegex = /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/;
-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;
-};
-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;
-    }, [[], []]);
-};
-const ValidConstraints = {
-    date: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'format'],
-    string: ['minLength', 'maxLength', 'pattern'],
-    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'],
-    array: ['minItems', 'maxItems', 'uniqueItems'],
-    file: ['accept', 'maxFileSize'],
-    email: ['minLength', 'maxLength', 'format', 'pattern']
-};
-const Constraints = {
-    type: (constraint, inputVal) => {
-        let value = inputVal;
-        if (inputVal == undefined) {
-            return {
-                valid: true,
-                value: inputVal
-            };
+
+function getStringToNumberFn(locale) {
+    if (locale == null) {
+        const localeOptions = new Intl.DateTimeFormat().resolvedOptions();
+        locale = localeOptions.locale;
+    }
+    return (str) => stringToNumber(str, locale);
+}
+class RuleEngine {
+    _context;
+    _globalNames = [
+        '$form',
+        '$field',
+        '$event'
+    ];
+    customFunctions;
+    debugInfo = [];
+    constructor() {
+        this.customFunctions = FunctionRuntime.getFunctions();
+    }
+    compileRule(rule, locale) {
+        const formula = new Formula(this.customFunctions, getStringToNumberFn(locale), this.debugInfo);
+        return { formula, ast: formula.compile(rule, this._globalNames) };
+    }
+    execute(node, data, globals, useValueOf = false) {
+        const { formula, ast } = node;
+        const oldContext = this._context;
+        this._context = globals;
+        let res = undefined;
+        try {
+            res = formula.run(ast, data, 'en-US', globals);
         }
-        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;
+        catch (err) {
+            this._context?.form?.logger?.error(err);
         }
-        return {
-            valid,
-            value
-        };
-    },
-    format: (constraint, input) => {
-        let valid = true;
-        const value = input;
-        if (input === null) {
-            return { value, valid };
+        while (this.debugInfo.length > 0) {
+            this._context?.form?.logger?.debug(this.debugInfo.pop());
         }
-        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 'email':
-                valid = new RegExp(emailRegex).test((input || '').trim());
-                break;
-            case 'data-url':
-                valid = true;
-                break;
+        let finalRes = res;
+        if (useValueOf) {
+            if (typeof res === 'object' && res !== null) {
+                finalRes = Object.getPrototypeOf(res).valueOf.call(res);
+            }
         }
-        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);
+        this._context = oldContext;
+        return finalRes;
+    }
+    trackDependency(subscriber) {
+        if (this._context && this._context.field !== undefined && this._context.field !== subscriber) {
+            subscriber._addDependent(this._context.field);
         }
-        else {
-            regex = constraint;
+    }
+}
+
+class Fieldset extends Container {
+    constructor(params, _options) {
+        super(params, _options);
+        if (_options.mode !== 'restore') {
+            this._applyDefaults();
+            this.queueEvent(new Initialize());
+            this.queueEvent(new ExecuteRule());
         }
-        return { valid: regex.test(value), value };
-    },
-    required: (constraint, value) => {
-        const valid = constraint ? value != null && value !== '' : true;
-        return { valid, value };
-    },
-    enum: (constraint, value) => {
+    }
+    _getDefaults() {
         return {
-            valid: constraint.indexOf(value) > -1,
-            value
+            ...super._getDefaults(),
+            visible: true,
+            required: false,
+            label: {
+                visible: true,
+                richText: false
+            }
         };
-    },
-    accept: (constraint, value) => {
-        if (!constraint || constraint.length === 0 || value === null || value === undefined) {
-            return {
-                valid: true,
-                value
-            };
+    }
+    _applyDefaults() {
+        super._applyDefaultsInModel();
+        if (this._jsonModel.dataRef && this._jsonModel.type === undefined) {
+            this._jsonModel.type = 'object';
         }
-        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
-        };
     }
-};
+    get type() {
+        const ret = super.type;
+        if (ret === 'array' || ret === 'object') {
+            return ret;
+        }
+        return undefined;
+    }
+    get items() {
+        return super.items;
+    }
+    get value() {
+        return null;
+    }
+    get fieldType() {
+        return 'panel';
+    }
+}
+
+class InstanceManager extends Fieldset {
+    get maxOccur() {
+        return this._jsonModel.maxItems;
+    }
+    set maxOccur(m) {
+        this.maxItems = m;
+    }
+    get minOccur() {
+        return this.minItems;
+    }
+    addInstance(action) {
+        return this.addItem(action);
+    }
+    removeInstance(action) {
+        return this.removeItem(action);
+    }
+}
+__decorate([
+    dependencyTracked()
+], InstanceManager.prototype, "maxOccur", null);
+__decorate([
+    dependencyTracked()
+], InstanceManager.prototype, "minOccur", null);
 
 const validTypes = ['string', 'number', 'integer', 'boolean', 'file', 'string[]', 'number[]', 'integer[]', 'boolean[]', 'file[]', 'array', 'object'];
 class Field extends Scriptable {
@@ -3451,7 +3478,6 @@ class Field extends Scriptable {
     }
     set required(r) {
         this._setProperty('required', r);
-        this.validate();
     }
     get maximum() {
         if (this.type === 'number' || this.format === 'date' || this.type === 'integer') {