@aemforms/af-core 0.22.73 → 0.22.75

package/esm/afb-runtime.js

@@ -1,4 +1,4 @@
-import { propertyChange, ExecuteRule, Initialize, RemoveItem, SubmitSuccess, CustomEvent, SubmitFailure, Submit, RemoveInstance, AddInstance, Reset, AddItem, Click, Change, FormLoad, FieldChanged, ValidationComplete, Valid, Invalid } from './afb-events.js';
+import { propertyChange, ExecuteRule, Initialize, RemoveItem, SubmitSuccess, CustomEvent, SubmitError, SubmitFailure, Submit, RemoveInstance, AddInstance, Reset, AddItem, Click, Change, FormLoad, FieldChanged, ValidationComplete, Valid, Invalid } from './afb-events.js';
 import Formula from '@adobe/json-formula';
 import { parseDefaultDate, datetimeToNumber, format, parseDateSkeleton, formatDate, numberToDatetime } from '@aemforms/af-formatters';
 
@@ -578,593 +578,664 @@ 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'
-];
-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;
-        }
-        else {
-            return this._jsonModel.visible;
+    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));
         }
-    }
-    set visible(v) {
-        if (v !== this._jsonModel.visible) {
-            const changeAction = propertyChange('visible', v, this._jsonModel.visible);
-            this._jsonModel.visible = v;
-            this.notifyDependents(changeAction);
+        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;
     }
-    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();
-            this._dependents.splice(index, 1);
-        }
-    }
-    queueEvent(action) {
-        const actionWithTarget = new ActionImplWithTarget(action, this);
-        this.form.getEventQueue().queue(this, actionWithTarget, ['valid', 'invalid'].indexOf(actionWithTarget.type) > -1);
-    }
-    dispatch(action) {
-        this.queueEvent(action);
-        this.form.getEventQueue().runPendingQueue();
-    }
-    notifyDependents(action) {
-        const depsToRestore = this._jsonModel._dependents;
-        if (depsToRestore) {
-            depsToRestore.forEach((x) => {
-                const node = this.form.getElement(x);
-                if (node) {
-                    this._addDependent(node);
-                }
-            });
-            this._jsonModel._dependents = undefined;
-        }
-        const handlers = this._callbacks[action.type] || [];
-        handlers.forEach(x => {
-            x(new ActionImplWithTarget(action, this));
-        });
+    return {
+        value, valid
+    };
+};
+const toArray = (inputVal) => {
+    if (inputVal != null && !(inputVal instanceof Array)) {
+        return [inputVal];
     }
-    isEmpty(value = this._jsonModel.value) {
-        return value === undefined || value === null || value === '';
+    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]];
     }
-    _setProperty(prop, newValue, notify = true, notifyChildren = (action) => { }) {
-        const oldValue = this._jsonModel[prop];
-        let isValueSame = false;
-        if (newValue !== null && oldValue !== null &&
-            typeof newValue === 'object' && typeof oldValue === 'object') {
-            isValueSame = JSON.stringify(newValue) === JSON.stringify(oldValue);
-        }
-        else {
-            isValueSame = oldValue === newValue;
-        }
-        if (!isValueSame) {
-            this._jsonModel[prop] = newValue;
-            const changeAction = propertyChange(prop, newValue, oldValue);
-            if (notify) {
-                this.notifyDependents(changeAction);
-            }
-            notifyChildren.call(this, changeAction);
-            return changeAction.payload.changes;
+    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 [];
-    }
-    _bindToDataModel(contextualDataModel) {
-        if (this.id === '$form') {
-            this._data = contextualDataModel;
-            return;
+        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
+            };
         }
-        const dataRef = this._jsonModel.dataRef;
-        let _data, _parent = contextualDataModel, _key = '';
-        if (dataRef === null) {
-            _data = NullDataValue;
+        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;
         }
-        else if (dataRef !== undefined && !this.repeatable) {
-            if (this._tokens.length === 0) {
-                this._tokens = tokenize(dataRef);
-            }
-            let searchData = contextualDataModel;
-            if (this._tokens[0].type === TOK_GLOBAL) {
-                searchData = this.form.getDataNode();
-            }
-            else if (this._tokens[0].type === TOK_REPEATABLE) {
-                let repeatRoot = this.parent;
-                while (!repeatRoot.repeatable && repeatRoot !== this.form) {
-                    repeatRoot = repeatRoot.parent;
-                }
-                searchData = repeatRoot.getDataNode();
-            }
-            if (typeof searchData !== 'undefined') {
-                const name = this._tokens[this._tokens.length - 1].value;
-                const create = this.defaultDataModel(name);
-                _data = resolveData(searchData, this._tokens, create);
-                _parent = resolveData(searchData, this._tokens.slice(0, -1));
-                _key = name;
-            }
+        return {
+            valid,
+            value
+        };
+    },
+    format: (constraint, input) => {
+        let valid = true;
+        const value = input;
+        if (input === null) {
+            return { value, valid };
         }
-        else {
-            if (contextualDataModel !== NullDataValue && staticFields.indexOf(this.fieldType) === -1) {
-                _parent = contextualDataModel;
-                const name = this._jsonModel.name || '';
-                const key = contextualDataModel.$type === 'array' ? this.index : name;
-                _key = key;
-                if (key !== '') {
-                    const create = this.defaultDataModel(key);
-                    if (create !== undefined) {
-                        _data = contextualDataModel.$getDataNode(key);
-                        if (_data === undefined) {
-                            _data = create;
-                            contextualDataModel.$addDataNode(key, _data);
-                        }
-                    }
+        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 {
-                    _data = undefined;
+                    valid = false;
                 }
-            }
+                break;
+            case 'email':
+                valid = new RegExp(emailRegex).test((input || '').trim());
+                break;
+            case 'data-url':
+                valid = true;
+                break;
         }
-        if (_data) {
-            if (!this.isContainer && _parent !== NullDataValue && _data !== NullDataValue) {
-                _data = _data?.$convertToDataValue();
-                _parent.$addDataNode(_key, _data, true);
-            }
-            _data?.$bindToField(this);
-            this._data = _data;
+        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);
         }
-    }
-    _data;
-    getDataNode() {
-        return this._data;
-    }
-    get lang() {
-        if (this._jsonModel.lang) {
-            this._lang = this._jsonModel.lang;
+        else {
+            regex = constraint;
         }
-        if (!this._lang) {
-            if (this.parent) {
-                this._lang = this.parent.lang;
-            }
-            else {
-                this._lang = Intl.DateTimeFormat().resolvedOptions().locale;
-            }
+        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
+            };
         }
-        return this._lang;
-    }
-    get properties() {
-        return this._jsonModel.properties || {};
+        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
+        };
     }
-    set properties(p) {
-        this._setProperty('properties', { ...p });
+};
+
+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;
     }
-    getNonTransparentParent() {
-        let nonTransparentParent = this.parent;
-        while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
-            nonTransparentParent = nonTransparentParent.parent;
-        }
-        return nonTransparentParent;
+    get type() {
+        return this._action.type;
     }
-    _initialize(mode) {
-        if (typeof this._data === 'undefined') {
-            let dataNode, parent = this.parent;
-            do {
-                dataNode = parent.getDataNode();
-                parent = parent.parent;
-            } while (dataNode === undefined);
-            this._bindToDataModel(dataNode);
-        }
+    get payload() {
+        return this._action.payload;
     }
-    _applyUpdates(propNames, updates) {
-        return propNames.reduce((acc, propertyName) => {
-            const currentValue = updates[propertyName];
-            const changes = this._setProperty(propertyName, currentValue, false);
-            if (changes.length > 0) {
-                acc[propertyName] = changes[0];
-            }
-            return acc;
-        }, {});
+    get metadata() {
+        return this._action.metadata;
     }
-    get qualifiedName() {
-        if (this.isTransparent()) {
-            return null;
-        }
-        if (this[qualifiedName] !== null) {
-            return this[qualifiedName];
-        }
-        const parent = this.getNonTransparentParent();
-        if (parent && parent.type === 'array') {
-            this[qualifiedName] = `${parent.qualifiedName}[${this.index}]`;
-        }
-        else {
-            this[qualifiedName] = `${parent.qualifiedName}.${this.name}`;
-        }
-        return this[qualifiedName];
+    get target() {
+        return this._target;
     }
-    focus() {
-        if (this.parent) {
-            this.parent.activeChild = this;
-        }
+    get isCustomEvent() {
+        return this._action.isCustomEvent;
     }
-    _getDefaults() {
-        return {};
+    get originalAction() {
+        return this._action.originalAction;
     }
-    _applyDefaultsInModel() {
-        Object.entries(this._getDefaults()).map(([key, value]) => {
-            if (this._jsonModel[key] === undefined && value !== undefined) {
-                this._jsonModel[key] = value;
-            }
-            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-                Object.keys(value).forEach((keyOfValue) => {
-                    if (this._jsonModel[key][keyOfValue] === undefined) {
-                        this._jsonModel[key][keyOfValue] = value[keyOfValue];
-                    }
-                });
-            }
-        });
+    toString() {
+        return this._action.toString();
     }
 }
-__decorate([
-    dependencyTracked()
-], BaseNode.prototype, "index", null);
-__decorate([
-    dependencyTracked()
-], BaseNode.prototype, "description", null);
-__decorate([
-    dependencyTracked()
-], BaseNode.prototype, "visible", null);
-__decorate([
-    dependencyTracked()
-], BaseNode.prototype, "label", null);
-__decorate([
-    dependencyTracked()
-], BaseNode.prototype, "properties", null);
-
-class Scriptable extends BaseNode {
-    _events = {};
-    _rules = {};
-    getRules() {
-        return typeof this._jsonModel.rules !== 'object' ? {} : this._jsonModel.rules;
-    }
-    getCompiledRule(eName, rule) {
-        if (!(eName in this._rules)) {
-            const eString = rule || this.getRules()[eName];
-            if (typeof eString === 'string' && eString.length > 0) {
-                try {
-                    this._rules[eName] = this.ruleEngine.compileRule(eString, this.lang);
-                }
-                catch (e) {
-                    this.form.logger.error(`Unable to compile rule \`"${eName}" : "${eString}"\` Exception : ${e}`);
-                }
-            }
-            else {
-                throw new Error(`only expression strings are supported. ${typeof (eString)} types are not supported`);
-            }
+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);
+            };
         }
-        return this._rules[eName];
-    }
-    getCompiledEvent(eName) {
-        if (!(eName in this._events)) {
-            let eString = this._jsonModel.events?.[eName];
-            if (typeof eString === 'string' && eString.length > 0) {
-                eString = [eString];
+    };
+}
+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);
             }
-            if (typeof eString !== 'undefined' && eString.length > 0) {
-                this._events[eName] = eString.map(x => {
-                    try {
-                        return this.ruleEngine.compileRule(x, this.lang);
-                    }
-                    catch (e) {
-                        this.form.logger.error(`Unable to compile expression \`"${eName}" : "${eString}"\` Exception : ${e}`);
-                    }
-                    return null;
-                }).filter(x => x !== null);
+            return undefined;
+        };
+    }
+    const set = descriptor.set;
+    if (set != undefined) {
+        descriptor.set = function (value) {
+            if (fieldTypes.indexOf(this.fieldType) > -1 === includeOrExclude) {
+                set.call(this, value);
             }
-        }
-        return this._events[eName] || [];
+        };
+    }
+};
+const include = addOnly(true);
+const exclude = addOnly(false);
+class BaseNode {
+    _options;
+    _ruleNode;
+    _lang = '';
+    _callbacks = {};
+    _dependents = [];
+    _jsonModel;
+    _tokens = [];
+    get isContainer() {
+        return false;
     }
-    applyUpdates(updates) {
-        Object.entries(updates).forEach(([key, value]) => {
-            if (key in editableProperties || (key in this && typeof this[key] !== 'function')) {
-                try {
-                    this[key] = value;
-                }
-                catch (e) {
-                    console.error(e);
-                }
+    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);
             }
         });
     }
-    executeAllRules(context) {
-        const entries = Object.entries(this.getRules());
-        if (entries.length > 0) {
-            const scope = this.getExpressionScope();
-            entries.forEach(([prop, rule]) => {
-                const node = this.getCompiledRule(prop, rule);
-                if (node) {
-                    const newVal = this.ruleEngine.execute(node, scope, context, true);
-                    if (editableProperties.indexOf(prop) > -1) {
-                        const oldAndNewValueAreEmpty = this.isEmpty() && this.isEmpty(newVal) && prop === 'value';
-                        if (!oldAndNewValueAreEmpty) {
-                            this[prop] = newVal;
-                        }
-                    }
-                    else {
-                        this.form.logger.warn(`${prop} is not a valid editable property.`);
-                    }
-                }
-            });
-        }
+    ruleNodeReference() {
+        return this;
     }
-    getExpressionScope() {
-        const parent = this.getNonTransparentParent();
-        const target = {
-            self: this.getRuleNode(),
-            siblings: parent?.ruleNodeReference() || {}
-        };
-        const scope = new Proxy(target, {
-            get: (target, prop) => {
-                if (prop === Symbol.toStringTag) {
-                    return 'Object';
-                }
-                if (typeof prop === 'string' && prop.startsWith('$')) {
-                    const retValue = target.self[prop];
+    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();
                     }
@@ -1175,918 +1246,1135 @@ class Scriptable extends BaseNode {
                         return retValue;
                     }
                 }
-                else {
-                    if (prop in target.siblings) {
-                        return target.siblings[prop];
-                    }
-                    else {
-                        return target.self[prop];
-                    }
+            }
+            else {
+                if (ruleNodeReference.hasOwnProperty(prop)) {
+                    return ruleNodeReference[prop];
+                }
+                else if (typeof ruleNodeReference[prop] === 'function') {
+                    return ruleNodeReference[prop];
                 }
-            },
-            has: (target, prop) => {
-                prop = prop;
-                const selfPropertyOrChild = target.self[prop];
-                const sibling = target.siblings[prop];
-                return typeof selfPropertyOrChild != 'undefined' || typeof sibling != 'undefined';
             }
-        });
-        return scope;
-    }
-    executeEvent(context, node) {
-        let updates;
-        if (node) {
-            updates = this.ruleEngine.execute(node, this.getExpressionScope(), context);
-        }
-        if (typeof updates !== 'undefined' && updates != null) {
-            this.applyUpdates(updates);
-        }
-    }
-    executeRule(event, context) {
-        if (typeof event.payload.ruleName === 'undefined') {
-            this.executeAllRules(context);
         }
     }
-    executeExpression(expr) {
-        const ruleContext = {
-            'form': this.form,
-            '$form': this.form.getRuleNode(),
-            '$field': this.getRuleNode(),
-            'field': this
-        };
-        const node = this.ruleEngine.compileRule(expr, this.lang);
-        return this.ruleEngine.execute(node, this.getExpressionScope(), ruleContext);
+    get id() {
+        return this._jsonModel.id;
     }
-    executeAction(action) {
-        const context = {
-            'form': this.form,
-            '$form': this.form.getRuleNode(),
-            '$field': this.getRuleNode(),
-            'field': this,
-            '$event': {
-                type: action.type,
-                payload: action.payload,
-                target: this.getRuleNode()
-            }
-        };
-        const eventName = action.isCustomEvent ? `custom:${action.type}` : action.type;
-        const funcName = action.isCustomEvent ? `custom_${action.type}` : action.type;
-        const node = this.getCompiledEvent(eventName);
-        if (funcName in this && typeof this[funcName] === 'function') {
-            this[funcName](action, context);
+    get index() {
+        if (this.parent) {
+            return this.parent.indexOf(this);
         }
-        node.forEach((n) => this.executeEvent(context, n));
-        this.notifyDependents(action);
-    }
-}
-
-const notifyChildrenAttributes = [
-    'readOnly', 'enabled'
-];
-class Container extends Scriptable {
-    _children = [];
-    _childrenReference;
-    _itemTemplate = null;
-    fieldFactory;
-    constructor(json, _options) {
-        super(json, { form: _options.form, parent: _options.parent, mode: _options.mode });
-        this.fieldFactory = _options.fieldFactory;
-    }
-    _getDefaults() {
-        return {
-            ...super._getDefaults(),
-            enabled: true,
-            readOnly: false
-        };
-    }
-    ruleNodeReference() {
-        return this._childrenReference;
-    }
-    get items() {
-        return this._children;
+        return 0;
     }
-    get maxItems() {
-        return this._jsonModel.maxItems;
+    get parent() {
+        return this._options.parent;
     }
-    set maxItems(m) {
-        this._jsonModel.maxItems = m;
-        const minItems = this._jsonModel.minItems || 1;
-        const itemsLength = this._children.length;
-        const items2Remove = Math.min(itemsLength - m, itemsLength - minItems);
-        if (items2Remove > 0) {
-            for (let i = 0; i < items2Remove; i++) {
-                this.getDataNode().$removeDataNode(m + i);
-                this._childrenReference.pop();
-            }
-            const elems = this._children.splice(m, items2Remove);
-            this.notifyDependents(propertyChange('items', elems, null));
-        }
+    get type() {
+        return this._jsonModel.type;
     }
-    get minItems() {
-        return this._jsonModel.minItems;
+    get repeatable() {
+        return this.parent?.hasDynamicItems();
     }
-    set minItems(m) {
-        this._jsonModel.minItems = m;
-        const itemsLength = this._children.length;
-        const difference = itemsLength - m;
-        const items2Add = Math.abs(difference);
-        if (difference < 0) {
-            const elems = [];
-            for (let i = 0; i < items2Add; i++) {
-                elems.push(this._addChild(this._itemTemplate, null, true));
-            }
-            this.notifyDependents(propertyChange('items', elems, null));
-        }
+    get fieldType() {
+        return this._jsonModel.fieldType || 'text-input';
     }
-    hasDynamicItems() {
-        return this._itemTemplate != null;
+    get ':type'() {
+        return this._jsonModel[':type'] || this.fieldType;
     }
-    get isContainer() {
-        return true;
+    get name() {
+        return this._jsonModel.name;
     }
-    _activeChild = null;
-    isSiteContainer(item) {
-        return (':items' in item || 'cqItems' in item) && !('fieldType' in item);
+    get description() {
+        return this._jsonModel.description;
     }
-    isAFormField(item) {
-        return ('fieldType' in item || 'id' in item || 'name' in item || 'dataRef' in item || 'type' in item);
+    set description(d) {
+        this._setProperty('description', d);
     }
-    _getFormAndSitesState(isRepeatableChild = false, forRestore = false) {
-        return this._jsonModel.items ? this._jsonModel.items.map((x) => {
-            if (this.isSiteContainer(x)) {
-                const newObjWithId = {
-                    ...(x?.id ? { id: this.form.getUniqueId() } : {})
-                };
-                return {
-                    ...x,
-                    ...newObjWithId,
-                    ':items': this.walkSiteContainerItems(x)
-                };
-            }
-            else if (this.isAFormField(x)) {
-                return { ...this.form.getElement(x?.id).getState(isRepeatableChild, forRestore) };
-            }
-            else {
-                return x;
-            }
-        }) : [];
+    get dataRef() {
+        return this._jsonModel.dataRef;
     }
-    getItemsState(isRepeatableChild = false, forRestore = false) {
-        if (this._jsonModel.type === 'array' || isRepeatable$1(this._jsonModel) || isRepeatableChild) {
-            if (isRepeatableChild) {
-                return this._getFormAndSitesState(isRepeatableChild, forRestore);
-            }
-            else {
-                return this._children.map(x => {
-                    return { ...x.getState(true, forRestore) };
-                });
-            }
+    get visible() {
+        if (this.parent?.visible !== undefined) {
+            return this.parent?.visible ? this._jsonModel.visible : false;
         }
         else {
-            return this._getFormAndSitesState(isRepeatableChild, forRestore);
+            return this._jsonModel.visible;
         }
     }
-    getState(isRepeatableChild = false, forRestore = false) {
+    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 {
-            ...super.getState(forRestore),
-            ...(forRestore ? {
-                ':items': undefined,
-                ':itemsOrder': undefined
+            ...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
             } : {}),
-            items: this.getItemsState(isRepeatableChild, forRestore),
-            enabled: this.enabled,
-            readOnly: this.readOnly
+            ':type': this[':type'],
+            ...(forRestore ? {
+                _dependents: this._dependents.length ? this._dependents.map(x => x.node.id) : undefined,
+                allowedComponents: undefined,
+                columnClassNames: undefined,
+                columnCount: undefined,
+                gridClassNames: undefined
+            } : {})
         };
     }
-    _createChild(child, options) {
-        return this.fieldFactory.createField(child, options);
-    }
-    walkSiteContainerItems(x) {
-        return Object.fromEntries(Object.entries(x[':items']).map(([key, value]) => {
-            if (this.isAFormField(value)) {
-                return [key, this.form.getElement(value?.id).getState()];
-            }
-            else if (this.isSiteContainer(value)) {
-                return this.walkSiteContainerItems(value);
-            }
-            else {
-                if (typeof value === 'object') {
-                    const newObjWithId = {
-                        ...(value?.id ? { id: this.form.getUniqueId() } : {})
-                    };
-                    return [key, {
-                            ...value,
-                            ...newObjWithId
-                        }
-                    ];
-                }
-                else {
-                    return [key, value];
-                }
+    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);
             }
-        }));
+        };
     }
-    _addChildToRuleNode(child, options) {
-        const self = this;
-        const { parent = this } = options;
-        const name = parent.type == 'array' ? parent._children.length + '' : child.name || '';
-        if (name.length > 0) {
-            Object.defineProperty(parent._childrenReference, name, {
-                get: () => {
-                    if (child.isContainer && child.hasDynamicItems()) {
-                        self.ruleEngine.trackDependency(child);
-                    }
-                    if (self.hasDynamicItems()) {
-                        self.ruleEngine.trackDependency(self);
-                        if (this._children[name] !== undefined) {
-                            return this._children[name].getRuleNode();
-                        }
-                    }
-                    else {
-                        return child.getRuleNode();
-                    }
-                },
-                configurable: true,
-                enumerable: 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 });
         }
     }
-    _addChild(itemJson, index, cloneIds = false, mode = 'create') {
-        let nonTransparentParent = this;
-        while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
-            nonTransparentParent = nonTransparentParent.parent;
-        }
-        if (typeof index !== 'number' || index > nonTransparentParent._children.length) {
-            index = this._children.length;
-        }
-        const form = this.form;
-        const itemTemplate = {
-            index,
-            ...deepClone(itemJson, cloneIds ? () => { return form.getUniqueId(); } : undefined)
-        };
-        const retVal = this._createChild(itemTemplate, { parent: this, form: this.form, mode });
-        itemJson.id = retVal.id;
-        this.form.fieldAdded(retVal);
-        this._addChildToRuleNode(retVal, { parent: nonTransparentParent });
-        if (index === this._children.length) {
-            this._children.push(retVal);
+    removeDependent(dependent) {
+        const index = this._dependents.findIndex(({ node }) => node === dependent);
+        if (index > -1) {
+            this._dependents[index].subscription.unsubscribe();
+            this._dependents.splice(index, 1);
         }
-        else {
-            this._children.splice(index, 0, retVal);
+    }
+    queueEvent(action) {
+        const actionWithTarget = new ActionImplWithTarget(action, this);
+        this.form.getEventQueue().queue(this, actionWithTarget, ['valid', 'invalid'].indexOf(actionWithTarget.type) > -1);
+    }
+    dispatch(action) {
+        this.queueEvent(action);
+        this.form.getEventQueue().runPendingQueue();
+    }
+    notifyDependents(action) {
+        const depsToRestore = this._jsonModel._dependents;
+        if (depsToRestore) {
+            depsToRestore.forEach((x) => {
+                const node = this.form.getElement(x);
+                if (node) {
+                    this._addDependent(node);
+                }
+            });
+            this._jsonModel._dependents = undefined;
         }
-        return retVal;
+        const handlers = this._callbacks[action.type] || [];
+        handlers.forEach(x => {
+            x(new ActionImplWithTarget(action, this));
+        });
     }
-    indexOf(f) {
-        return this._children.indexOf(f);
+    isEmpty(value = this._jsonModel.value) {
+        return value === undefined || value === null || value === '';
     }
-    defaultDataModel(name) {
-        const type = this._jsonModel.type || undefined;
-        if (type === undefined) {
-            return undefined;
+    _setProperty(prop, newValue, notify = true, notifyChildren = (action) => { }) {
+        const oldValue = this._jsonModel[prop];
+        let isValueSame = false;
+        if (newValue !== null && oldValue !== null &&
+            typeof newValue === 'object' && typeof oldValue === 'object') {
+            isValueSame = JSON.stringify(newValue) === JSON.stringify(oldValue);
         }
         else {
-            const instance = type === 'array' ? [] : {};
-            return new DataGroup(name, instance, type);
+            isValueSame = oldValue === newValue;
         }
-    }
-    _canHaveRepeatingChildren(mode = 'create') {
-        const items = this._jsonModel.items;
-        return this._jsonModel.type == 'array' && this.getDataNode() != null &&
-            (items.length === 1 || (items[0].repeatable == true && mode === 'restore'));
-    }
-    _initialize(mode) {
-        super._initialize(mode);
-        const items = this._jsonModel.items || [];
-        this._childrenReference = this._jsonModel.type == 'array' ? [] : {};
-        if (this._canHaveRepeatingChildren(mode)) {
-            this._itemTemplate = deepClone(items[0]);
-            if (mode === 'restore') {
-                this._itemTemplate.repeatable = undefined;
-            }
-            if (typeof (this._jsonModel.minItems) !== 'number') {
-                this._jsonModel.minItems = 0;
+        if (!isValueSame) {
+            this._jsonModel[prop] = newValue;
+            const changeAction = propertyChange(prop, newValue, oldValue);
+            if (notify) {
+                this.notifyDependents(changeAction);
             }
-            if (typeof (this._jsonModel.maxItems) !== 'number') {
-                this._jsonModel.maxItems = -1;
+            notifyChildren.call(this, changeAction);
+            if (validationConstraintsList.includes(prop)) {
+                this.validate();
             }
-            if (typeof (this._jsonModel.initialItems) !== 'number') {
-                this._jsonModel.initialItems = Math.max(1, this._jsonModel.minItems);
+            return changeAction.payload.changes;
+        }
+        return [];
+    }
+    _bindToDataModel(contextualDataModel) {
+        if (this.id === '$form') {
+            this._data = contextualDataModel;
+            return;
+        }
+        const dataRef = this._jsonModel.dataRef;
+        let _data, _parent = contextualDataModel, _key = '';
+        if (dataRef === null) {
+            _data = NullDataValue;
+        }
+        else if (dataRef !== undefined && !this.repeatable) {
+            if (this._tokens.length === 0) {
+                this._tokens = tokenize(dataRef);
             }
-            for (let i = 0; i < this._jsonModel.initialItems; i++) {
-                let child;
-                if (mode === 'restore') {
-                    let itemTemplate = this._itemTemplate;
-                    if (i < this._jsonModel.items.length) {
-                        itemTemplate = deepClone(items[i]);
-                        itemTemplate.repeatable = undefined;
-                    }
-                    child = this._addChild(itemTemplate, undefined, i > this._jsonModel.items.length - 1, mode);
-                }
-                else {
-                    child = this._addChild(this._itemTemplate, undefined, i > this._jsonModel.items.length - 1);
-                }
-                if (mode === 'create') {
-                    items[0].id = child.id;
+            let searchData = contextualDataModel;
+            if (this._tokens[0].type === TOK_GLOBAL) {
+                searchData = this.form.getDataNode();
+            }
+            else if (this._tokens[0].type === TOK_REPEATABLE) {
+                let repeatRoot = this.parent;
+                while (!repeatRoot.repeatable && repeatRoot !== this.form) {
+                    repeatRoot = repeatRoot.parent;
                 }
-                child._initialize(mode);
+                searchData = repeatRoot.getDataNode();
+            }
+            if (typeof searchData !== 'undefined') {
+                const name = this._tokens[this._tokens.length - 1].value;
+                const create = this.defaultDataModel(name);
+                _data = resolveData(searchData, this._tokens, create);
+                _parent = resolveData(searchData, this._tokens.slice(0, -1));
+                _key = name;
             }
         }
-        else if (items.length > 0) {
-            items.forEach((item) => {
-                if (this.isSiteContainer(item)) {
-                    this._initializeSiteContainer(item);
-                }
-                else if (this.isAFormField(item)) {
-                    const child = this._addChild(item, undefined, false, mode);
-                    child._initialize(mode);
+        else {
+            if (contextualDataModel !== NullDataValue && staticFields.indexOf(this.fieldType) === -1) {
+                _parent = contextualDataModel;
+                const name = this._jsonModel.name || '';
+                const key = contextualDataModel.$type === 'array' ? this.index : name;
+                _key = key;
+                if (key !== '') {
+                    const create = this.defaultDataModel(key);
+                    if (create !== undefined) {
+                        _data = contextualDataModel.$getDataNode(key);
+                        if (_data === undefined) {
+                            _data = create;
+                            contextualDataModel.$addDataNode(key, _data);
+                        }
+                    }
                 }
                 else {
-                    this.form.logger.warn(`A container item was not initialized. ${item}`);
+                    _data = undefined;
                 }
-            });
-            this._jsonModel.minItems = this._children.length;
-            this._jsonModel.maxItems = this._children.length;
-            this._jsonModel.initialItems = this._children.length;
+            }
         }
-        else {
-            this.form.logger.warn('A container exists with no items.');
+        if (_data) {
+            if (!this.isContainer && _parent !== NullDataValue && _data !== NullDataValue) {
+                _data = _data?.$convertToDataValue();
+                _parent.$addDataNode(_key, _data, true);
+            }
+            _data?.$bindToField(this);
+            this._data = _data;
         }
-        this.setupRuleNode();
     }
-    _initializeSiteContainer(item) {
-        Object.entries(item[':items']).forEach(([key, value]) => {
-            if (this.isAFormField(value)) {
-                const child = this._addChild(value);
-                child._initialize();
-            }
-            else if (this.isSiteContainer(value)) {
-                return this._initializeSiteContainer(value);
-            }
-        });
+    _data;
+    getDataNode() {
+        return this._data;
     }
-    addItem(action) {
-        if ((action.type === 'addItem' || action.type == 'addInstance') && this._itemTemplate != null) {
-            if ((this._jsonModel.maxItems === -1) || (this._children.length < this._jsonModel.maxItems)) {
-                const dataNode = this.getDataNode();
-                let instanceIndex = action.payload;
-                const retVal = this._addChild(this._itemTemplate, action.payload, true);
-                if (typeof instanceIndex !== 'number' || instanceIndex > this._children.length) {
-                    instanceIndex = this._children.length;
-                }
-                const _data = retVal.defaultDataModel(instanceIndex);
-                if (_data) {
-                    dataNode.$addDataNode(instanceIndex, _data);
-                }
-                retVal._initialize('create');
-                this.notifyDependents(propertyChange('items', retVal.getState(), null));
-                retVal.dispatch(new Initialize());
-                retVal.dispatch(new ExecuteRule());
-                for (let i = instanceIndex + 1; i < this._children.length; i++) {
-                    this._children[i].dispatch(new ExecuteRule());
-                }
-            }
+    get lang() {
+        if (this._jsonModel.lang) {
+            this._lang = this._jsonModel.lang;
         }
-    }
-    removeItem(action) {
-        if ((action.type === 'removeItem' || action.type == 'removeInstance') && this._itemTemplate != null) {
-            if (this._children.length == 0) {
-                return;
-            }
-            let instanceIndex = action.payload;
-            if (typeof instanceIndex !== 'number') {
-                instanceIndex = this._children.length - 1;
+        if (!this._lang) {
+            if (this.parent) {
+                this._lang = this.parent.lang;
             }
-            const state = this._children[instanceIndex].getState();
-            if (this._children.length > this._jsonModel.minItems) {
-                this._childrenReference.pop();
-                this._children.splice(instanceIndex, 1);
-                this.getDataNode().$removeDataNode(instanceIndex);
-                for (let i = instanceIndex; i < this._children.length; i++) {
-                    this._children[i].dispatch(new ExecuteRule());
-                }
-                this.notifyDependents(propertyChange('items', null, state));
+            else {
+                this._lang = Intl.DateTimeFormat().resolvedOptions().locale;
             }
         }
+        return this._lang;
     }
-    queueEvent(action) {
-        super.queueEvent(action);
-        if (action.metadata?.dispatch) {
-            this.items.forEach(x => {
-                x.queueEvent(action);
-            });
+    get properties() {
+        return this._jsonModel.properties || {};
+    }
+    set properties(p) {
+        this._setProperty('properties', { ...p });
+    }
+    getNonTransparentParent() {
+        let nonTransparentParent = this.parent;
+        while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
+            nonTransparentParent = nonTransparentParent.parent;
         }
+        return nonTransparentParent;
     }
-    reset() {
-        if (this.type === 'array' || isRepeatable$1(this._jsonModel)) {
-            if (this.items.length > this._jsonModel.initialItems) {
-                const itemsToBeRemoved = this.items.length - this._jsonModel.initialItems;
-                for (let i = 0; i < itemsToBeRemoved; i++) {
-                    this.dispatch(new RemoveItem());
-                }
-            }
+    _initialize(mode) {
+        if (typeof this._data === 'undefined') {
+            let dataNode, parent = this.parent;
+            do {
+                dataNode = parent.getDataNode();
+                parent = parent.parent;
+            } while (dataNode === undefined);
+            this._bindToDataModel(dataNode);
         }
-        this.items.forEach(x => {
-            x.reset();
-        });
     }
-    validate() {
-        return this.items.flatMap(x => {
-            return x.validate();
-        }).filter(x => x.fieldName !== '');
+    _applyUpdates(propNames, updates) {
+        return propNames.reduce((acc, propertyName) => {
+            const currentValue = updates[propertyName];
+            const changes = this._setProperty(propertyName, currentValue, false);
+            if (changes.length > 0) {
+                acc[propertyName] = changes[0];
+            }
+            return acc;
+        }, {});
     }
-    dispatch(action) {
-        super.dispatch(action);
+    get qualifiedName() {
+        if (this.isTransparent()) {
+            return null;
+        }
+        if (this[qualifiedName] !== null) {
+            return this[qualifiedName];
+        }
+        const parent = this.getNonTransparentParent();
+        if (parent && parent.type === 'array') {
+            this[qualifiedName] = `${parent.qualifiedName}[${this.index}]`;
+        }
+        else {
+            this[qualifiedName] = `${parent.qualifiedName}.${this.name}`;
+        }
+        return this[qualifiedName];
     }
-    importData(contextualDataModel) {
-        this._bindToDataModel(contextualDataModel);
-        const dataNode = this.getDataNode() || contextualDataModel;
-        this.syncDataAndFormModel(dataNode);
+    focus() {
+        if (this.parent) {
+            this.parent.activeChild = this;
+        }
     }
-    syncDataAndFormModel(contextualDataModel) {
-        if (contextualDataModel?.$type === 'array' && this._itemTemplate != null) {
-            const dataLength = contextualDataModel?.$value.length;
-            const itemsLength = this._children.length;
-            const maxItems = this._jsonModel.maxItems === -1 ? dataLength : this._jsonModel.maxItems;
-            const minItems = this._jsonModel.minItems;
-            let items2Add = Math.min(dataLength - itemsLength, maxItems - itemsLength);
-            const items2Remove = Math.min(itemsLength - dataLength, itemsLength - minItems);
-            while (items2Add > 0) {
-                items2Add--;
-                const child = this._addChild(this._itemTemplate);
-                child._initialize('create');
+    _getDefaults() {
+        return {};
+    }
+    _applyDefaultsInModel() {
+        Object.entries(this._getDefaults()).map(([key, value]) => {
+            if (this._jsonModel[key] === undefined && value !== undefined) {
+                this._jsonModel[key] = value;
             }
-            if (items2Remove > 0) {
-                this._children.splice(dataLength, items2Remove);
-                for (let i = 0; i < items2Remove; i++) {
-                    this._childrenReference.pop();
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                Object.keys(value).forEach((keyOfValue) => {
+                    if (this._jsonModel[key][keyOfValue] === undefined) {
+                        this._jsonModel[key][keyOfValue] = value[keyOfValue];
+                    }
+                });
+            }
+        });
+    }
+}
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "index", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "description", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "visible", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "label", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "properties", null);
+
+class Scriptable extends BaseNode {
+    _events = {};
+    _rules = {};
+    getRules() {
+        return typeof this._jsonModel.rules !== 'object' ? {} : this._jsonModel.rules;
+    }
+    getCompiledRule(eName, rule) {
+        if (!(eName in this._rules)) {
+            const eString = rule || this.getRules()[eName];
+            if (typeof eString === 'string' && eString.length > 0) {
+                try {
+                    this._rules[eName] = this.ruleEngine.compileRule(eString, this.lang);
+                }
+                catch (e) {
+                    this.form.logger.error(`Unable to compile rule \`"${eName}" : "${eString}"\` Exception : ${e}`);
                 }
             }
+            else {
+                throw new Error(`only expression strings are supported. ${typeof (eString)} types are not supported`);
+            }
         }
-        this._children.forEach(x => {
-            x.importData(contextualDataModel);
-        });
-    }
-    get activeChild() {
-        return this._activeChild;
+        return this._rules[eName];
     }
-    set activeChild(c) {
-        if (c !== this._activeChild) {
-            let activeChild = this._activeChild;
-            while (activeChild instanceof Container) {
-                const temp = activeChild.activeChild;
-                activeChild.activeChild = null;
-                activeChild = temp;
+    getCompiledEvent(eName) {
+        if (!(eName in this._events)) {
+            let eString = this._jsonModel.events?.[eName];
+            if (typeof eString === 'string' && eString.length > 0) {
+                eString = [eString];
             }
-            const change = propertyChange('activeChild', c, this._activeChild);
-            this._activeChild = c;
-            if (this.parent && c !== null) {
-                this.parent.activeChild = this;
+            if (typeof eString !== 'undefined' && eString.length > 0) {
+                this._events[eName] = eString.map(x => {
+                    try {
+                        return this.ruleEngine.compileRule(x, this.lang);
+                    }
+                    catch (e) {
+                        this.form.logger.error(`Unable to compile expression \`"${eName}" : "${eString}"\` Exception : ${e}`);
+                    }
+                    return null;
+                }).filter(x => x !== null);
             }
-            this._jsonModel.activeChild = c?.id;
-            this.notifyDependents(change);
-        }
-    }
-    get enabled() {
-        if (this.parent?.enabled !== undefined) {
-            return !this.parent?.enabled ? false : this._jsonModel.enabled;
-        }
-        else {
-            return this._jsonModel.enabled;
-        }
-    }
-    set enabled(e) {
-        this._setProperty('enabled', e, true, this.notifyChildren);
-    }
-    get readOnly() {
-        if (this.parent?.readOnly !== undefined) {
-            return this.parent.readOnly ? true : this._jsonModel.readOnly;
-        }
-        else {
-            return this._jsonModel.readOnly;
         }
+        return this._events[eName] || [];
     }
-    set readOnly(e) {
-        this._setProperty('readOnly', e, true, this.notifyChildren);
+    applyUpdates(updates) {
+        Object.entries(updates).forEach(([key, value]) => {
+            if (key in editableProperties || (key in this && typeof this[key] !== 'function')) {
+                try {
+                    this[key] = value;
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+        });
     }
-    notifyChildren(action) {
-        if (action.payload !== undefined && action.payload.changes !== undefined) {
-            for (const change of action.payload.changes) {
-                if (change.propertyName !== undefined && notifyChildrenAttributes.includes(change.propertyName)) {
-                    this.items.forEach((child) => {
-                        this.notifyDependents.call(child, propertyChange(change.propertyName, child.getState()[change.propertyName], null));
-                        if (child.fieldType === 'panel') {
-                            this.notifyChildren.call(child, action);
+    executeAllRules(context) {
+        const entries = Object.entries(this.getRules());
+        if (entries.length > 0) {
+            const scope = this.getExpressionScope();
+            entries.forEach(([prop, rule]) => {
+                const node = this.getCompiledRule(prop, rule);
+                if (node) {
+                    const newVal = this.ruleEngine.execute(node, scope, context, true);
+                    if (editableProperties.indexOf(prop) > -1) {
+                        const oldAndNewValueAreEmpty = this.isEmpty() && this.isEmpty(newVal) && prop === 'value';
+                        if (!oldAndNewValueAreEmpty) {
+                            this[prop] = newVal;
                         }
-                    });
+                    }
+                    else {
+                        this.form.logger.warn(`${prop} is not a valid editable property.`);
+                    }
                 }
-            }
+            });
         }
     }
-}
-__decorate([
-    dependencyTracked()
-], Container.prototype, "maxItems", null);
-__decorate([
-    dependencyTracked()
-], Container.prototype, "minItems", null);
-__decorate([
-    dependencyTracked()
-], Container.prototype, "activeChild", null);
-
-class Node {
-    _jsonModel;
-    constructor(inputModel) {
-        this._jsonModel = {
-            ...inputModel
+    getExpressionScope() {
+        const parent = this.getNonTransparentParent();
+        const target = {
+            self: this.getRuleNode(),
+            siblings: parent?.ruleNodeReference() || {}
         };
+        const scope = new Proxy(target, {
+            get: (target, prop) => {
+                if (prop === Symbol.toStringTag) {
+                    return 'Object';
+                }
+                if (typeof prop === 'string' && prop.startsWith('$')) {
+                    const retValue = target.self[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 (prop in target.siblings) {
+                        return target.siblings[prop];
+                    }
+                    else {
+                        return target.self[prop];
+                    }
+                }
+            },
+            has: (target, prop) => {
+                prop = prop;
+                const selfPropertyOrChild = target.self[prop];
+                const sibling = target.siblings[prop];
+                return typeof selfPropertyOrChild != 'undefined' || typeof sibling != 'undefined';
+            }
+        });
+        return scope;
     }
-    getP(key, def) {
-        return getProperty(this._jsonModel, key, def);
-    }
-    get isContainer() {
-        return false;
+    executeEvent(context, node) {
+        let updates;
+        if (node) {
+            updates = this.ruleEngine.execute(node, this.getExpressionScope(), context);
+        }
+        if (typeof updates !== 'undefined' && updates != null) {
+            this.applyUpdates(updates);
+        }
     }
-}
-
-class FormMetaData extends Node {
-    get version() {
-        return this.getP('version', '');
+    executeRule(event, context) {
+        if (typeof event.payload.ruleName === 'undefined') {
+            this.executeAllRules(context);
+        }
     }
-    get grammar() {
-        return this.getP('grammar', '');
+    executeExpression(expr) {
+        const ruleContext = {
+            'form': this.form,
+            '$form': this.form.getRuleNode(),
+            '$field': this.getRuleNode(),
+            'field': this
+        };
+        const node = this.ruleEngine.compileRule(expr, this.lang);
+        return this.ruleEngine.execute(node, this.getExpressionScope(), ruleContext);
     }
-}
-
-class SubmitMetaData {
-    lang;
-    captchaInfo;
-    constructor(lang = '', captchaInfo) {
-        this.lang = lang;
-        this.captchaInfo = captchaInfo;
+    executeAction(action) {
+        const context = {
+            'form': this.form,
+            '$form': this.form.getRuleNode(),
+            '$field': this.getRuleNode(),
+            'field': this,
+            '$event': {
+                type: action.type,
+                payload: action.payload,
+                target: this.getRuleNode()
+            }
+        };
+        const eventName = action.isCustomEvent ? `custom:${action.type}` : action.type;
+        const funcName = action.isCustomEvent ? `custom_${action.type}` : action.type;
+        const node = this.getCompiledEvent(eventName);
+        if (funcName in this && typeof this[funcName] === 'function') {
+            this[funcName](action, context);
+        }
+        node.forEach((n) => this.executeEvent(context, n));
+        this.notifyDependents(action);
     }
 }
 
-const levels = {
-    off: 0,
-    debug: 1,
-    info: 2,
-    warn: 3,
-    error: 4
-};
-class Logger {
-    debug(msg) {
-        this.log(msg, 'debug');
-    }
-    info(msg) {
-        this.log(msg, 'info');
-    }
-    warn(msg) {
-        this.log(msg, 'warn');
-    }
-    error(msg) {
-        this.log(msg, 'error');
+const notifyChildrenAttributes = [
+    'readOnly', 'enabled'
+];
+class Container extends Scriptable {
+    _children = [];
+    _childrenReference;
+    _itemTemplate = null;
+    fieldFactory;
+    constructor(json, _options) {
+        super(json, { form: _options.form, parent: _options.parent, mode: _options.mode });
+        this.fieldFactory = _options.fieldFactory;
     }
-    log(msg, level) {
-        if (this.logLevel !== 0 && this.logLevel <= levels[level]) {
-            console[level](msg);
-        }
+    _getDefaults() {
+        return {
+            ...super._getDefaults(),
+            enabled: true,
+            readOnly: false
+        };
     }
-    logLevel;
-    constructor(logLevel = 'off') {
-        this.logLevel = levels[logLevel];
+    ruleNodeReference() {
+        return this._childrenReference;
     }
-}
-
-class EventNode {
-    _node;
-    _event;
-    constructor(_node, _event) {
-        this._node = _node;
-        this._event = _event;
+    get items() {
+        return this._children;
     }
-    get node() {
-        return this._node;
+    get maxItems() {
+        return this._jsonModel.maxItems;
     }
-    get event() {
-        return this._event;
+    set maxItems(m) {
+        this._jsonModel.maxItems = m;
+        const minItems = this._jsonModel.minItems || 1;
+        const itemsLength = this._children.length;
+        const items2Remove = Math.min(itemsLength - m, itemsLength - minItems);
+        if (items2Remove > 0) {
+            for (let i = 0; i < items2Remove; i++) {
+                this.getDataNode().$removeDataNode(m + i);
+                this._childrenReference.pop();
+            }
+            const elems = this._children.splice(m, items2Remove);
+            this.notifyDependents(propertyChange('items', elems, null));
+        }
     }
-    isEqual(that) {
-        return that !== null && that !== undefined && this._node == that._node && this._event.type == that._event.type;
+    get minItems() {
+        return this._jsonModel.minItems;
     }
-    toString() {
-        return this._node.id + '__' + this.event.type;
+    set minItems(m) {
+        this._jsonModel.minItems = m;
+        const itemsLength = this._children.length;
+        const difference = itemsLength - m;
+        const items2Add = Math.abs(difference);
+        if (difference < 0) {
+            const elems = [];
+            for (let i = 0; i < items2Add; i++) {
+                elems.push(this._addChild(this._itemTemplate, null, true));
+            }
+            this.notifyDependents(propertyChange('items', elems, null));
+        }
     }
-    valueOf() {
-        return this.toString();
+    hasDynamicItems() {
+        return this._itemTemplate != null;
     }
-}
-class EventQueue {
-    logger;
-    static MAX_EVENT_CYCLE_COUNT = 10;
-    _runningEventCount;
-    _isProcessing = false;
-    _pendingEvents = [];
-    constructor(logger = new Logger('off')) {
-        this.logger = logger;
-        this._runningEventCount = {};
+    get isContainer() {
+        return true;
     }
-    get length() {
-        return this._pendingEvents.length;
+    _activeChild = null;
+    isSiteContainer(item) {
+        return (':items' in item || 'cqItems' in item) && !('fieldType' in item);
     }
-    get isProcessing() {
-        return this._isProcessing;
+    isAFormField(item) {
+        return ('fieldType' in item || 'id' in item || 'name' in item || 'dataRef' in item || 'type' in item);
     }
-    isQueued(node, event) {
-        const evntNode = new EventNode(node, event);
-        return this._pendingEvents.find(x => evntNode.isEqual(x)) !== undefined;
+    _getFormAndSitesState(isRepeatableChild = false, forRestore = false) {
+        return this._jsonModel.items ? this._jsonModel.items.map((x) => {
+            if (this.isSiteContainer(x)) {
+                const newObjWithId = {
+                    ...(x?.id ? { id: this.form.getUniqueId() } : {})
+                };
+                return {
+                    ...x,
+                    ...newObjWithId,
+                    ':items': this.walkSiteContainerItems(x)
+                };
+            }
+            else if (this.isAFormField(x)) {
+                return { ...this.form.getElement(x?.id).getState(isRepeatableChild, forRestore) };
+            }
+            else {
+                return x;
+            }
+        }) : [];
     }
-    queue(node, events, priority = false) {
-        if (!node || !events) {
-            return;
+    getItemsState(isRepeatableChild = false, forRestore = false) {
+        if (this._jsonModel.type === 'array' || isRepeatable$1(this._jsonModel) || isRepeatableChild) {
+            if (isRepeatableChild) {
+                return this._getFormAndSitesState(isRepeatableChild, forRestore);
+            }
+            else {
+                return this._children.map(x => {
+                    return { ...x.getState(true, forRestore) };
+                });
+            }
         }
-        if (!(events instanceof Array)) {
-            events = [events];
+        else {
+            return this._getFormAndSitesState(isRepeatableChild, forRestore);
         }
-        events.forEach(e => {
-            const evntNode = new EventNode(node, e);
-            const counter = this._runningEventCount[evntNode.valueOf()] || 0;
-            if (counter < EventQueue.MAX_EVENT_CYCLE_COUNT) {
-                this.logger.info(`Queued event : ${e.type} node: ${node.id} - ${node.name}`);
-                if (priority) {
-                    const index = this._isProcessing ? 1 : 0;
-                    this._pendingEvents.splice(index, 0, evntNode);
+    }
+    getState(isRepeatableChild = false, forRestore = false) {
+        return {
+            ...super.getState(forRestore),
+            ...(forRestore ? {
+                ':items': undefined,
+                ':itemsOrder': undefined
+            } : {}),
+            items: this.getItemsState(isRepeatableChild, forRestore),
+            enabled: this.enabled,
+            readOnly: this.readOnly
+        };
+    }
+    _createChild(child, options) {
+        return this.fieldFactory.createField(child, options);
+    }
+    walkSiteContainerItems(x) {
+        return Object.fromEntries(Object.entries(x[':items']).map(([key, value]) => {
+            if (this.isAFormField(value)) {
+                return [key, this.form.getElement(value?.id).getState()];
+            }
+            else if (this.isSiteContainer(value)) {
+                return this.walkSiteContainerItems(value);
+            }
+            else {
+                if (typeof value === 'object') {
+                    const newObjWithId = {
+                        ...(value?.id ? { id: this.form.getUniqueId() } : {})
+                    };
+                    return [key, {
+                            ...value,
+                            ...newObjWithId
+                        }
+                    ];
                 }
                 else {
-                    this._pendingEvents.push(evntNode);
+                    return [key, value];
                 }
-                this._runningEventCount[evntNode.valueOf()] = counter + 1;
             }
-            else {
-                this.logger.info(`Skipped queueing event : ${e.type} node: ${node.id} - ${node.name} with count=${counter}`);
-            }
-        });
+        }));
     }
-    empty() {
-        this._pendingEvents = [];
+    _addChildToRuleNode(child, options) {
+        const self = this;
+        const { parent = this } = options;
+        const name = parent.type == 'array' ? parent._children.length + '' : child.name || '';
+        if (name.length > 0) {
+            Object.defineProperty(parent._childrenReference, name, {
+                get: () => {
+                    if (child.isContainer && child.hasDynamicItems()) {
+                        self.ruleEngine.trackDependency(child);
+                    }
+                    if (self.hasDynamicItems()) {
+                        self.ruleEngine.trackDependency(self);
+                        if (this._children[name] !== undefined) {
+                            return this._children[name].getRuleNode();
+                        }
+                    }
+                    else {
+                        return child.getRuleNode();
+                    }
+                },
+                configurable: true,
+                enumerable: true
+            });
+        }
     }
-    runPendingQueue() {
-        if (this._isProcessing) {
-            return;
+    _addChild(itemJson, index, cloneIds = false, mode = 'create') {
+        let nonTransparentParent = this;
+        while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
+            nonTransparentParent = nonTransparentParent.parent;
         }
-        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();
+        if (typeof index !== 'number' || index > nonTransparentParent._children.length) {
+            index = this._children.length;
         }
-        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()
+        const form = this.form;
+        const itemTemplate = {
+            index,
+            ...deepClone(itemJson, cloneIds ? () => { return form.getUniqueId(); } : undefined)
         };
-    }
-    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));
+        const retVal = this._createChild(itemTemplate, { parent: this, form: this.form, mode });
+        itemJson.id = retVal.id;
+        this.form.fieldAdded(retVal);
+        this._addChildToRuleNode(retVal, { parent: nonTransparentParent });
+        if (index === this._children.length) {
+            this._children.push(retVal);
+        }
+        else {
+            this._children.splice(index, 0, retVal);
+        }
+        return retVal;
+    }
+    indexOf(f) {
+        return this._children.indexOf(f);
+    }
+    defaultDataModel(name) {
+        const type = this._jsonModel.type || undefined;
+        if (type === undefined) {
+            return undefined;
         }
         else {
-            randIndex = Math.floor(Math.random() * (chars.length));
+            const instance = type === 'array' ? [] : {};
+            return new DataGroup(name, instance, type);
         }
-        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;
+    _canHaveRepeatingChildren(mode = 'create') {
+        const items = this._jsonModel.items;
+        return this._jsonModel.type == 'array' && this.getDataNode() != null &&
+            (items.length === 1 || (items[0].repeatable == true && mode === 'restore'));
+    }
+    _initialize(mode) {
+        super._initialize(mode);
+        const items = this._jsonModel.items || [];
+        this._childrenReference = this._jsonModel.type == 'array' ? [] : {};
+        if (this._canHaveRepeatingChildren(mode)) {
+            this._itemTemplate = deepClone(items[0]);
+            if (mode === 'restore') {
+                this._itemTemplate.repeatable = undefined;
+            }
+            if (typeof (this._jsonModel.minItems) !== 'number') {
+                this._jsonModel.minItems = 0;
+            }
+            if (typeof (this._jsonModel.maxItems) !== 'number') {
+                this._jsonModel.maxItems = -1;
+            }
+            if (typeof (this._jsonModel.initialItems) !== 'number') {
+                this._jsonModel.initialItems = Math.max(1, this._jsonModel.minItems);
+            }
+            for (let i = 0; i < this._jsonModel.initialItems; i++) {
+                let child;
+                if (mode === 'restore') {
+                    let itemTemplate = this._itemTemplate;
+                    if (i < this._jsonModel.items.length) {
+                        itemTemplate = deepClone(items[i]);
+                        itemTemplate.repeatable = undefined;
+                    }
+                    child = this._addChild(itemTemplate, undefined, i > this._jsonModel.items.length - 1, mode);
+                }
+                else {
+                    child = this._addChild(this._itemTemplate, undefined, i > this._jsonModel.items.length - 1);
+                }
+                if (mode === 'create') {
+                    items[0].id = child.id;
+                }
+                child._initialize(mode);
+            }
         }
-        let ret = null;
-        if (item.isContainer) {
-            ret = getAttachments(item, excludeUnbound);
+        else if (items.length > 0) {
+            items.forEach((item) => {
+                if (this.isSiteContainer(item)) {
+                    this._initializeSiteContainer(item);
+                }
+                else if (this.isAFormField(item)) {
+                    const child = this._addChild(item, undefined, false, mode);
+                    child._initialize(mode);
+                }
+                else {
+                    this.form.logger.warn(`A container item was not initialized. ${item}`);
+                }
+            });
+            this._jsonModel.minItems = this._children.length;
+            this._jsonModel.maxItems = this._children.length;
+            this._jsonModel.initialItems = this._children.length;
         }
         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 };
-                    });
+            this.form.logger.warn('A container exists with no items.');
+        }
+        this.setupRuleNode();
+    }
+    _initializeSiteContainer(item) {
+        Object.entries(item[':items']).forEach(([key, value]) => {
+            if (this.isAFormField(value)) {
+                const child = this._addChild(value);
+                child._initialize();
+            }
+            else if (this.isSiteContainer(value)) {
+                return this._initializeSiteContainer(value);
+            }
+        });
+    }
+    addItem(action) {
+        if ((action.type === 'addItem' || action.type == 'addInstance') && this._itemTemplate != null) {
+            if ((this._jsonModel.maxItems === -1) || (this._children.length < this._jsonModel.maxItems)) {
+                const dataNode = this.getDataNode();
+                let instanceIndex = action.payload;
+                const retVal = this._addChild(this._itemTemplate, action.payload, true);
+                if (typeof instanceIndex !== 'number' || instanceIndex > this._children.length) {
+                    instanceIndex = this._children.length;
                 }
-                else if (item.value != null) {
-                    ret[item.id] = { ...item.value, 'dataRef': dataRef };
+                const _data = retVal.defaultDataModel(instanceIndex);
+                if (_data) {
+                    dataNode.$addDataNode(instanceIndex, _data);
+                }
+                retVal._initialize('create');
+                this.notifyDependents(propertyChange('items', retVal.getState(), null));
+                retVal.dispatch(new Initialize());
+                retVal.dispatch(new ExecuteRule());
+                for (let i = instanceIndex + 1; i < this._children.length; i++) {
+                    this._children[i].dispatch(new ExecuteRule());
                 }
             }
         }
-        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();
+    removeItem(action) {
+        if ((action.type === 'removeItem' || action.type == 'removeInstance') && this._itemTemplate != null) {
+            if (this._children.length == 0) {
+                return;
             }
-            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
-                };
+            let instanceIndex = action.payload;
+            if (typeof instanceIndex !== 'number') {
+                instanceIndex = this._children.length - 1;
+            }
+            const state = this._children[instanceIndex].getState();
+            if (this._children.length > this._jsonModel.minItems) {
+                this._childrenReference.pop();
+                this._children.splice(instanceIndex, 1);
+                this.getDataNode().$removeDataNode(instanceIndex);
+                for (let i = instanceIndex; i < this._children.length; i++) {
+                    this._children[i].dispatch(new ExecuteRule());
+                }
+                this.notifyDependents(propertyChange('items', null, state));
             }
         }
-        else {
-            let jFile = file;
-            try {
-                jFile = JSON.parse(file);
-                retVal = jFile;
-                if (!retVal.mediaType) {
-                    retVal.mediaType = retVal.type;
+    }
+    queueEvent(action) {
+        super.queueEvent(action);
+        if (action.metadata?.dispatch) {
+            this.items.forEach(x => {
+                x.queueEvent(action);
+            });
+        }
+    }
+    reset() {
+        if (this.type === 'array' || isRepeatable$1(this._jsonModel)) {
+            if (this.items.length > this._jsonModel.initialItems) {
+                const itemsToBeRemoved = this.items.length - this._jsonModel.initialItems;
+                for (let i = 0; i < itemsToBeRemoved; i++) {
+                    this.dispatch(new RemoveItem());
                 }
             }
-            catch (ex) {
+        }
+        this.items.forEach(x => {
+            x.reset();
+        });
+    }
+    validate() {
+        return this.items.flatMap(x => {
+            return x.validate();
+        }).filter(x => x.fieldName !== '');
+    }
+    dispatch(action) {
+        super.dispatch(action);
+    }
+    importData(contextualDataModel) {
+        this._bindToDataModel(contextualDataModel);
+        const dataNode = this.getDataNode() || contextualDataModel;
+        this.syncDataAndFormModel(dataNode);
+    }
+    syncDataAndFormModel(contextualDataModel) {
+        if (contextualDataModel?.$type === 'array' && this._itemTemplate != null) {
+            const dataLength = contextualDataModel?.$value.length;
+            const itemsLength = this._children.length;
+            const maxItems = this._jsonModel.maxItems === -1 ? dataLength : this._jsonModel.maxItems;
+            const minItems = this._jsonModel.minItems;
+            let items2Add = Math.min(dataLength - itemsLength, maxItems - itemsLength);
+            const items2Remove = Math.min(itemsLength - dataLength, itemsLength - minItems);
+            while (items2Add > 0) {
+                items2Add--;
+                const child = this._addChild(this._itemTemplate);
+                child._initialize('create');
             }
-            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
-                    };
+            if (items2Remove > 0) {
+                this._children.splice(dataLength, items2Remove);
+                for (let i = 0; i < items2Remove; i++) {
+                    this._childrenReference.pop();
                 }
             }
-            else if (typeof jFile === 'string') {
-                const fileName = jFile.split('/').pop();
-                retVal = {
-                    name: fileName,
-                    mediaType: 'application/octet-stream',
-                    size: 0,
-                    data: jFile
-                };
+        }
+        this._children.forEach(x => {
+            x.importData(contextualDataModel);
+        });
+    }
+    get activeChild() {
+        return this._activeChild;
+    }
+    set activeChild(c) {
+        if (c !== this._activeChild) {
+            let activeChild = this._activeChild;
+            while (activeChild instanceof Container) {
+                const temp = activeChild.activeChild;
+                activeChild.activeChild = null;
+                activeChild = temp;
             }
-            else if (typeof jFile === 'object') {
-                retVal = {
-                    name: jFile?.name,
-                    mediaType: jFile?.type || jFile?.mediaType,
-                    size: jFile?.size,
-                    data: jFile?.data
-                };
+            const change = propertyChange('activeChild', c, this._activeChild);
+            this._activeChild = c;
+            if (this.parent && c !== null) {
+                this.parent.activeChild = this;
             }
+            this._jsonModel.activeChild = c?.id;
+            this.notifyDependents(change);
         }
-        if (retVal !== null && retVal.data != null) {
-            return new FileObject(retVal);
+    }
+    get enabled() {
+        if (this.parent?.enabled !== undefined) {
+            return !this.parent?.enabled ? false : this._jsonModel.enabled;
+        }
+        else {
+            return this._jsonModel.enabled;
         }
-        return null;
     }
-    else {
-        return null;
+    set enabled(e) {
+        this._setProperty('enabled', e, true, this.notifyChildren);
     }
-};
-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 };
+    get readOnly() {
+        if (this.parent?.readOnly !== undefined) {
+            return this.parent.readOnly ? true : this._jsonModel.readOnly;
         }
         else {
-            const blob = new window.Blob([groups[4]], { type });
-            return { name, blob };
+            return this._jsonModel.readOnly;
         }
     }
-    else {
-        return null;
+    set readOnly(e) {
+        this._setProperty('readOnly', e, true, this.notifyChildren);
     }
+    notifyChildren(action) {
+        if (action.payload !== undefined && action.payload.changes !== undefined) {
+            for (const change of action.payload.changes) {
+                if (change.propertyName !== undefined && notifyChildrenAttributes.includes(change.propertyName)) {
+                    this.items.forEach((child) => {
+                        this.notifyDependents.call(child, propertyChange(change.propertyName, child.getState()[change.propertyName], null));
+                        if (child.fieldType === 'panel') {
+                            this.notifyChildren.call(child, action);
+                        }
+                    });
+                }
+            }
+        }
+    }
+}
+__decorate([
+    dependencyTracked()
+], Container.prototype, "maxItems", null);
+__decorate([
+    dependencyTracked()
+], Container.prototype, "minItems", null);
+__decorate([
+    dependencyTracked()
+], Container.prototype, "activeChild", null);
+
+class Node {
+    _jsonModel;
+    constructor(inputModel) {
+        this._jsonModel = {
+            ...inputModel
+        };
+    }
+    getP(key, def) {
+        return getProperty(this._jsonModel, key, def);
+    }
+    get isContainer() {
+        return false;
+    }
+}
+
+class FormMetaData extends Node {
+    get version() {
+        return this.getP('version', '');
+    }
+    get grammar() {
+        return this.getP('grammar', '');
+    }
+}
+
+class SubmitMetaData {
+    lang;
+    captchaInfo;
+    constructor(lang = '', captchaInfo) {
+        this.lang = lang;
+        this.captchaInfo = captchaInfo;
+    }
+}
+
+const levels = {
+    off: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4
 };
-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;
+class Logger {
+    debug(msg) {
+        this.log(msg, 'debug');
     }
-    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]));
+    info(msg) {
+        this.log(msg, 'info');
+    }
+    warn(msg) {
+        this.log(msg, 'warn');
+    }
+    error(msg) {
+        this.log(msg, 'error');
+    }
+    log(msg, level) {
+        if (this.logLevel !== 0 && this.logLevel <= levels[level]) {
+            console[level](msg);
+        }
+    }
+    logLevel;
+    constructor(logLevel = 'off') {
+        this.logLevel = levels[logLevel];
+    }
+}
+
+class EventNode {
+    _node;
+    _event;
+    constructor(_node, _event) {
+        this._node = _node;
+        this._event = _event;
+    }
+    get node() {
+        return this._node;
+    }
+    get event() {
+        return this._event;
+    }
+    isEqual(that) {
+        return that !== null && that !== undefined && this._node == that._node && this._event.type == that._event.type;
+    }
+    toString() {
+        return this._node.id + '__' + this.event.type;
+    }
+    valueOf() {
+        return this.toString();
+    }
+}
+class EventQueue {
+    logger;
+    static MAX_EVENT_CYCLE_COUNT = 10;
+    _runningEventCount;
+    _isProcessing = false;
+    _pendingEvents = [];
+    constructor(logger = new Logger('off')) {
+        this.logger = logger;
+        this._runningEventCount = {};
+    }
+    get length() {
+        return this._pendingEvents.length;
+    }
+    get isProcessing() {
+        return this._isProcessing;
+    }
+    isQueued(node, event) {
+        const evntNode = new EventNode(node, event);
+        return this._pendingEvents.find(x => evntNode.isEqual(x)) !== undefined;
+    }
+    queue(node, events, priority = false) {
+        if (!node || !events) {
+            return;
+        }
+        if (!(events instanceof Array)) {
+            events = [events];
+        }
+        events.forEach(e => {
+            const evntNode = new EventNode(node, e);
+            const counter = this._runningEventCount[evntNode.valueOf()] || 0;
+            if (counter < EventQueue.MAX_EVENT_CYCLE_COUNT) {
+                this.logger.info(`Queued event : ${e.type} node: ${node.id} - ${node.name}`);
+                if (priority) {
+                    const index = this._isProcessing ? 1 : 0;
+                    this._pendingEvents.splice(index, 0, evntNode);
+                }
+                else {
+                    this._pendingEvents.push(evntNode);
+                }
+                this._runningEventCount[evntNode.valueOf()] = counter + 1;
+            }
+            else {
+                this.logger.info(`Skipped queueing event : ${e.type} node: ${node.id} - ${node.name} with count=${counter}`);
+            }
         });
-        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;
-    });
-};
+    empty() {
+        this._pendingEvents = [];
+    }
+    runPendingQueue() {
+        if (this._isProcessing) {
+            return;
+        }
+        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;
+    }
+}
 
 const request$1 = (url, data = null, options = {}) => {
     const opts = { ...defaultRequestOptions, ...options };
@@ -2203,7 +2491,8 @@ const request = async (context, uri, httpVerb, payload, success, error, headers)
     else {
         context.form.logger.error('Error invoking a rest API');
         const eName = getCustomEventName(error);
-        if (error === 'submitFailure') {
+        if (error === 'submitError') {
+            context.form.dispatch(new SubmitError(result, true));
             context.form.dispatch(new SubmitFailure(result, true));
         }
         else {
@@ -2334,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);
                                 }
                             }
                         };
@@ -2435,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,
@@ -2776,7 +3083,7 @@ class Form extends Container {
         if (!validate_form || this.validate().length === 0) {
             const payload = action?.payload || {};
             const successEventName = payload?.success ? payload?.success : 'submitSuccess';
-            const failureEventName = payload?.error ? payload?.error : 'submitFailure';
+            const failureEventName = payload?.error ? payload?.error : 'submitError';
             submit(context, successEventName, failureEventName, payload?.submit_as, payload?.data);
         }
     }
@@ -2852,379 +3159,101 @@ class RuleEngine {
     }
     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
-            };
+        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 {
@@ -3449,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') {
@@ -4078,6 +4106,17 @@ class Checkbox extends Field {
         baseConstraints.required = requiredConstraint(this.offValue());
         return baseConstraints;
     }
+    _applyDefaults() {
+        if (typeof this._jsonModel.checked === 'boolean') {
+            if (this._jsonModel.checked) {
+                this._jsonModel.default = this._jsonModel.enum?.[0];
+            }
+            else {
+                this._jsonModel.default = this._jsonModel.enum?.[1];
+            }
+        }
+        super._applyDefaults();
+    }
     _getDefaults() {
         return {
             ...super._getDefaults(),
@@ -4087,7 +4126,43 @@ class Checkbox extends Field {
     get enum() {
         return this._jsonModel.enum || [];
     }
+    updateDataNodeAndTypedValue(val) {
+        const changes = super.updateDataNodeAndTypedValue(val);
+        const valueChange = changes.find((c) => c.propertyName === 'value');
+        if (valueChange) {
+            const oldChecked = valueChange.prevValue === this._jsonModel.enum?.[0];
+            const newChecked = valueChange.currentValue === this._jsonModel.enum?.[0];
+            if (oldChecked !== newChecked) {
+                changes.push({
+                    propertyName: 'checked',
+                    prevValue: oldChecked,
+                    currentValue: newChecked
+                });
+            }
+        }
+        return changes;
+    }
+    set checked(check) {
+        if (check) {
+            this.value = this._jsonModel.enum?.[0];
+        }
+        else {
+            this.value = this._jsonModel.enum?.[1];
+        }
+    }
+    get checked() {
+        return this.value === this._jsonModel.enum?.[0];
+    }
+    getState(isRepeatableChild = false, forRestore = false) {
+        return {
+            ...super.getState(isRepeatableChild, forRestore),
+            checked: this.checked
+        };
+    }
 }
+__decorate([
+    dependencyTracked()
+], Checkbox.prototype, "checked", null);
 
 class CheckboxGroup extends Field {
     constructor(params, _options) {
@@ -4259,9 +4334,13 @@ const createFormInstance = (formModel, callback, logLevel = 'error', fModel = un
 const defaultOptions = {
     logLevel: 'error'
 };
-const restoreFormInstance = (formModel, { logLevel } = defaultOptions) => {
+const restoreFormInstance = (formModel, data = null, { logLevel } = defaultOptions) => {
     try {
         const form = new Form({ ...formModel }, FormFieldFactory, new RuleEngine(), new EventQueue(new Logger(logLevel)), logLevel, 'restore');
+        if (data) {
+            form._bindToDataModel(new DataGroup('$form', data));
+            form.syncDataAndFormModel(form.getDataNode());
+        }
         form.getEventQueue().empty();
         return form;
     }