@aemforms/af-core 0.22.102 → 0.22.104

package/esm/afb-events.js

@@ -1 +1,186 @@
-export { A as AddInstance, i as AddItem, B as Blur, k as Change, j as Click, C as CustomEvent, a as ExecuteRule, m as FieldChanged, t as Focus, F as FormLoad, I as Initialize, r as Invalid, g as RemoveInstance, R as RemoveItem, h as Reset, f as Save, e as Submit, b as SubmitError, c as SubmitFailure, S as SubmitSuccess, U as UIChange, q as Valid, V as ValidationComplete, p as propertyChange } from './Events-f062426b.js';
+var EventSource;
+(function (EventSource) {
+    EventSource["CODE"] = "code";
+    EventSource["UI"] = "ui";
+})(EventSource || (EventSource = {}));
+class ActionImpl {
+    _metadata;
+    _type;
+    _payload;
+    _target;
+    _currentTarget;
+    constructor(payload, type, _metadata) {
+        this._metadata = _metadata;
+        this._payload = payload;
+        this._type = type;
+    }
+    get type() {
+        return this._type;
+    }
+    get payload() {
+        return this._payload;
+    }
+    get metadata() {
+        return this._metadata;
+    }
+    get target() {
+        return this._target;
+    }
+    get currentTarget() {
+        return this._currentTarget;
+    }
+    get isCustomEvent() {
+        return false;
+    }
+    payloadToJson() {
+        return this.payload;
+    }
+    toJson() {
+        return {
+            payload: this.payloadToJson(),
+            type: this.type,
+            isCustomEvent: this.isCustomEvent
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJson());
+    }
+}
+class Change extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'change', { dispatch });
+    }
+    withAdditionalChange(change) {
+        return new Change(this.payload.changes.concat(change.payload.changes), this.metadata);
+    }
+}
+class UIChange extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'uiChange', { dispatch });
+    }
+}
+class Invalid extends ActionImpl {
+    constructor(payload = {}) {
+        super(payload, 'invalid', {});
+    }
+}
+class Valid extends ActionImpl {
+    constructor(payload = {}) {
+        super(payload, 'valid', {});
+    }
+}
+class ExecuteRule extends ActionImpl {
+    constructor(payload = {}, dispatch = false) {
+        super(payload, 'executeRule', { dispatch });
+    }
+}
+const propertyChange = (propertyName, currentValue, prevValue) => {
+    return new Change({
+        changes: [
+            {
+                propertyName,
+                currentValue,
+                prevValue
+            }
+        ]
+    });
+};
+class Initialize extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'initialize', { dispatch });
+    }
+}
+class FormLoad extends ActionImpl {
+    constructor() {
+        super({}, 'load', { dispatch: false });
+    }
+}
+class Click extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'click', { dispatch });
+    }
+}
+class Blur extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'blur', { dispatch });
+    }
+}
+class ValidationComplete extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'validationComplete', { dispatch });
+    }
+}
+class Focus extends ActionImpl {
+    constructor() {
+        super({}, 'focus', { dispatch: false });
+    }
+}
+class Submit extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'submit', { dispatch });
+    }
+}
+class Save extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'save', { dispatch });
+    }
+}
+class SubmitSuccess extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'submitSuccess', { dispatch });
+    }
+}
+class SubmitFailure extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'submitFailure', { dispatch });
+    }
+}
+class SubmitError extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'submitError', { dispatch });
+    }
+}
+class Reset extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'reset', { dispatch });
+    }
+}
+class FieldChanged extends ActionImpl {
+    constructor(changes, field, eventSource = EventSource.CODE) {
+        super({
+            field,
+            changes,
+            eventSource
+        }, 'fieldChanged');
+    }
+}
+class CustomEvent extends ActionImpl {
+    constructor(eventName, payload = {}, dispatch = false) {
+        super(payload, eventName, { dispatch });
+    }
+    get isCustomEvent() {
+        return true;
+    }
+}
+class AddItem extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'addItem');
+    }
+}
+class RemoveItem extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'removeItem');
+    }
+}
+class AddInstance extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'addInstance');
+    }
+}
+class RemoveInstance extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'removeInstance');
+    }
+}
+
+export { AddInstance, AddItem, Blur, Change, Click, CustomEvent, ExecuteRule, FieldChanged, Focus, FormLoad, Initialize, Invalid, RemoveInstance, RemoveItem, Reset, Save, Submit, SubmitError, SubmitFailure, SubmitSuccess, UIChange, Valid, ValidationComplete, propertyChange };

package/esm/afb-runtime.js

@@ -1,4 +1,4 @@
-import { E as EventSource, p as propertyChange, a as ExecuteRule, I as Initialize, R as RemoveItem, S as SubmitSuccess, C as CustomEvent, b as SubmitError, c as SubmitFailure, d as CaptchaDisplayMode, e as Submit, f as Save, g as RemoveInstance, A as AddInstance, h as Reset, i as AddItem, j as Click, k as Change, F as FormLoad, l as FocusOption, m as FieldChanged, V as ValidationComplete, n as constraintKeys, o as getConstraintTypeMessages, q as Valid, r as Invalid, s as ValidationError } from './Events-f062426b.js';
+import { propertyChange, ExecuteRule, Initialize, RemoveItem, SubmitSuccess, CustomEvent, SubmitError, SubmitFailure, Submit, Save, Valid, Invalid, RemoveInstance, AddInstance, Reset, AddItem, Click, Change, FormLoad, FieldChanged, ValidationComplete } from './afb-events.js';
 import Formula from '@adobe/json-formula';
 import { parseDefaultDate, datetimeToNumber, format, parseDateSkeleton, numberToDatetime, formatDate, parseDate } from '@aemforms/af-formatters';
 
@@ -9,6 +9,95 @@ function __decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
+const ConstraintType = Object.freeze({
+    PATTERN_MISMATCH: 'patternMismatch',
+    TOO_SHORT: 'tooShort',
+    TOO_LONG: 'tooLong',
+    RANGE_OVERFLOW: 'rangeOverflow',
+    RANGE_UNDERFLOW: 'rangeUnderflow',
+    TYPE_MISMATCH: 'typeMismatch',
+    VALUE_MISSING: 'valueMissing',
+    STEP_MISMATCH: 'stepMismatch',
+    FORMAT_MISMATCH: 'formatMismatch',
+    ACCEPT_MISMATCH: 'acceptMismatch',
+    FILE_SIZE_MISMATCH: 'fileSizeMismatch',
+    UNIQUE_ITEMS_MISMATCH: 'uniqueItemsMismatch',
+    MIN_ITEMS_MISMATCH: 'minItemsMismatch',
+    MAX_ITEMS_MISMATCH: 'maxItemsMismatch',
+    EXPRESSION_MISMATCH: 'expressionMismatch',
+    EXCLUSIVE_MAXIMUM_MISMATCH: 'exclusiveMaximumMismatch',
+    EXCLUSIVE_MINIMUM_MISMATCH: 'exclusiveMinimumMismatch'
+});
+const constraintKeys = Object.freeze({
+    pattern: ConstraintType.PATTERN_MISMATCH,
+    minLength: ConstraintType.TOO_SHORT,
+    maxLength: ConstraintType.TOO_LONG,
+    maximum: ConstraintType.RANGE_OVERFLOW,
+    minimum: ConstraintType.RANGE_UNDERFLOW,
+    type: ConstraintType.TYPE_MISMATCH,
+    required: ConstraintType.VALUE_MISSING,
+    step: ConstraintType.STEP_MISMATCH,
+    format: ConstraintType.FORMAT_MISMATCH,
+    accept: ConstraintType.ACCEPT_MISMATCH,
+    maxFileSize: ConstraintType.FILE_SIZE_MISMATCH,
+    uniqueItems: ConstraintType.UNIQUE_ITEMS_MISMATCH,
+    minItems: ConstraintType.MIN_ITEMS_MISMATCH,
+    maxItems: ConstraintType.MAX_ITEMS_MISMATCH,
+    validationExpression: ConstraintType.EXPRESSION_MISMATCH,
+    exclusiveMinimum: ConstraintType.EXCLUSIVE_MINIMUM_MISMATCH,
+    exclusiveMaximum: ConstraintType.EXCLUSIVE_MAXIMUM_MISMATCH
+});
+const defaultConstraintTypeMessages = Object.freeze({
+    [ConstraintType.PATTERN_MISMATCH]: 'Please match the format requested.',
+    [ConstraintType.TOO_SHORT]: 'Please lengthen this text to ${0} characters or more.',
+    [ConstraintType.TOO_LONG]: 'Please shorten this text to ${0} characters or less.',
+    [ConstraintType.RANGE_OVERFLOW]: 'Value must be less than or equal to ${0}.',
+    [ConstraintType.RANGE_UNDERFLOW]: 'Value must be greater than or equal to ${0}.',
+    [ConstraintType.TYPE_MISMATCH]: 'Please enter a valid value.',
+    [ConstraintType.VALUE_MISSING]: 'Please fill in this field.',
+    [ConstraintType.STEP_MISMATCH]: 'Please enter a valid value.',
+    [ConstraintType.FORMAT_MISMATCH]: 'Specify the value in allowed format : ${0}.',
+    [ConstraintType.ACCEPT_MISMATCH]: 'The specified file type not supported.',
+    [ConstraintType.FILE_SIZE_MISMATCH]: 'File too large. Reduce size and try again.',
+    [ConstraintType.UNIQUE_ITEMS_MISMATCH]: 'All the items must be unique.',
+    [ConstraintType.MIN_ITEMS_MISMATCH]: 'Specify a number of items equal to or greater than ${0}.',
+    [ConstraintType.MAX_ITEMS_MISMATCH]: 'Specify a number of items equal to or less than ${0}.',
+    [ConstraintType.EXPRESSION_MISMATCH]: 'Please enter a valid value.',
+    [ConstraintType.EXCLUSIVE_MINIMUM_MISMATCH]: 'Value must be greater than ${0}.',
+    [ConstraintType.EXCLUSIVE_MAXIMUM_MISMATCH]: 'Value must be less than ${0}.'
+});
+let customConstraintTypeMessages = {};
+const getConstraintTypeMessages = () => {
+    return {
+        ...defaultConstraintTypeMessages,
+        ...customConstraintTypeMessages
+    };
+};
+
+var EventSource;
+(function (EventSource) {
+    EventSource["CODE"] = "code";
+    EventSource["UI"] = "ui";
+})(EventSource || (EventSource = {}));
+class ValidationError {
+    fieldName;
+    errorMessages;
+    constructor(fieldName = '', errorMessages = []) {
+        this.errorMessages = errorMessages;
+        this.fieldName = fieldName;
+    }
+}
+var FocusOption;
+(function (FocusOption) {
+    FocusOption["NEXT_ITEM"] = "nextItem";
+    FocusOption["PREVIOUS_ITEM"] = "previousItem";
+})(FocusOption || (FocusOption = {}));
+var CaptchaDisplayMode;
+(function (CaptchaDisplayMode) {
+    CaptchaDisplayMode["INVISIBLE"] = "invisible";
+    CaptchaDisplayMode["VISIBLE"] = "visible";
+})(CaptchaDisplayMode || (CaptchaDisplayMode = {}));
+
 const objToMap = (o) => new Map(Object.entries(o));
 const stringViewTypes = objToMap({ 'date': 'date-input', 'data-url': 'file-input', 'binary': 'file-input' });
 const typeToViewTypes = objToMap({
@@ -1157,6 +1246,7 @@ class BaseNode {
     _jsonModel;
     _tokens = [];
     _eventSource = EventSource.CODE;
+    _fragment = '$form';
     get isContainer() {
         return false;
     }
@@ -1167,6 +1257,15 @@ class BaseNode {
             ...params,
             id: 'id' in params ? params.id : this.form.getUniqueId()
         };
+        if (this.parent?.isFragment) {
+            this._fragment = this.parent.qualifiedName;
+        }
+        else if (this.parent?.fragment) {
+            this._fragment = this.parent.fragment;
+        }
+    }
+    get fragment() {
+        return this._fragment;
     }
     setupRuleNode() {
         const self = this;
@@ -1588,7 +1687,11 @@ class Scriptable extends BaseNode {
             const eString = rule || this.getRules()[eName];
             if (typeof eString === 'string' && eString.length > 0) {
                 try {
-                    this._rules[eName] = this.ruleEngine.compileRule(eString, this.lang);
+                    let updatedRule = eString;
+                    if (this.fragment !== '$form') {
+                        updatedRule = eString.replaceAll('$form', this.fragment);
+                    }
+                    this._rules[eName] = this.ruleEngine.compileRule(updatedRule, this.lang);
                 }
                 catch (e) {
                     this.form.logger.error(`Unable to compile rule \`"${eName}" : "${eString}"\` Exception : ${e}`);
@@ -1609,7 +1712,11 @@ class Scriptable extends BaseNode {
             if (typeof eString !== 'undefined' && eString.length > 0) {
                 this._events[eName] = eString.map(x => {
                     try {
-                        return this.ruleEngine.compileRule(x, this.lang);
+                        let updatedExpr = x;
+                        if (this.fragment !== '$form') {
+                            updatedExpr = x.replaceAll('$form', this.fragment);
+                        }
+                        return this.ruleEngine.compileRule(updatedExpr, this.lang);
                     }
                     catch (e) {
                         this.form.logger.error(`Unable to compile expression \`"${eName}" : "${eString}"\` Exception : ${e}`);
@@ -1646,7 +1753,7 @@ class Scriptable extends BaseNode {
             entries.forEach(([prop, rule]) => {
                 const node = this.getCompiledRule(prop, rule);
                 if (node) {
-                    const newVal = this.ruleEngine.execute(node, scope, context, true);
+                    const newVal = this.ruleEngine.execute(node, scope, context, true, rule);
                     if (editableProperties.indexOf(prop) > -1) {
                         const oldAndNewValueAreEmpty = this.isEmpty() && this.isEmpty(newVal) && prop === 'value';
                         if (!oldAndNewValueAreEmpty) {
@@ -1701,10 +1808,10 @@ class Scriptable extends BaseNode {
         });
         return scope;
     }
-    executeEvent(context, node) {
+    executeEvent(context, node, eString) {
         let updates;
         if (node) {
-            updates = this.ruleEngine.execute(node, this.getExpressionScope(), context);
+            updates = this.ruleEngine.execute(node, this.getExpressionScope(), context, false, eString);
         }
         if (typeof updates !== 'undefined' && updates != null) {
             this.applyUpdates(updates);
@@ -1723,7 +1830,7 @@ class Scriptable extends BaseNode {
             'field': this
         };
         const node = this.ruleEngine.compileRule(expr, this.lang);
-        return this.ruleEngine.execute(node, this.getExpressionScope(), ruleContext);
+        return this.ruleEngine.execute(node, this.getExpressionScope(), ruleContext, false, expr);
     }
     change(event, context) {
         if (this.form.changeEventBehaviour === 'deps') {
@@ -1745,10 +1852,20 @@ class Scriptable extends BaseNode {
         const eventName = action.isCustomEvent ? `custom:${action.type}` : action.type;
         const funcName = action.isCustomEvent ? `custom_${action.type}` : action.type;
         const node = this.getCompiledEvent(eventName);
+        const events = this._jsonModel.events?.[eventName];
         if (funcName in this && typeof this[funcName] === 'function') {
             this[funcName](action, context);
         }
-        node.forEach((n) => this.executeEvent(context, n));
+        node.forEach((n, index) => {
+            let eString = '';
+            if (Array.isArray(events)) {
+                eString = events[index];
+            }
+            else if (typeof events === 'string') {
+                eString = events;
+            }
+            this.executeEvent(context, n, eString);
+        });
         if (action.target === this) {
             this.notifyDependents(action);
         }
@@ -1763,8 +1880,11 @@ class Container extends Scriptable {
     _childrenReference;
     _itemTemplate = null;
     fieldFactory;
+    _isFragment = false;
+    _insideFragment = false;
     constructor(json, _options) {
         super(json, { form: _options.form, parent: _options.parent, mode: _options.mode });
+        this._isFragment = this._jsonModel?.properties?.['fd:fragment'] === true;
         this.fieldFactory = _options.fieldFactory;
     }
     _getDefaults() {
@@ -1969,6 +2089,9 @@ class Container extends Scriptable {
         return this._jsonModel.type == 'array' && this.getDataNode() != null &&
             (items.length === 1 || (items.length > 0 && items[0].repeatable == true && mode === 'restore'));
     }
+    get isFragment() {
+        return this._isFragment || this._jsonModel?.properties?.['fd:fragment'];
+    }
     _initialize(mode) {
         super._initialize(mode);
         const items = this._jsonModel.items || [];
@@ -2043,19 +2166,7 @@ class Container extends Scriptable {
         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 = null;
-                let instanceData = null;
-                if (typeof action.payload === 'number') {
-                    instanceIndex = action.payload;
-                }
-                else if (typeof action.payload === 'object') {
-                    if ('index' in action.payload) {
-                        instanceIndex = action.payload.index;
-                    }
-                    if ('data' in action.payload) {
-                        instanceData = action.payload.data;
-                    }
-                }
+                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;
@@ -2071,9 +2182,6 @@ class Container extends Scriptable {
                 for (let i = instanceIndex + 1; i < this._children.length; i++) {
                     this._children[i].dispatch(new ExecuteRule());
                 }
-                if (instanceData) {
-                    retVal.importData(instanceData);
-                }
             }
         }
     }
@@ -2127,21 +2235,14 @@ class Container extends Scriptable {
     dispatch(action) {
         super.dispatch(action);
     }
-    createDataGroup(dataModel) {
-        const dataGroup = new DataGroup(this._data.$name, dataModel, this._data.$type, this._data.parent);
-        try {
-            this._data.parent?.$addDataNode(dataGroup.$name, dataGroup, true);
-        }
-        catch (e) {
-            this.form.logger.error(`Unable to set items for container '${this.qualifiedName}' with data model '${dataModel}': ${e.message}`);
-            return null;
-        }
-        return dataGroup;
-    }
     importData(dataModel) {
         if (typeof this._data !== 'undefined' && this.type === 'array' && Array.isArray(dataModel)) {
-            const dataGroup = this.createDataGroup(dataModel);
-            if (!dataGroup) {
+            const dataGroup = new DataGroup(this._data.$name, dataModel, this._data.$type, this._data.parent);
+            try {
+                this._data.parent?.$addDataNode(dataGroup.$name, dataGroup, true);
+            }
+            catch (e) {
+                this.form.logger.error(`unable to setItems for ${this.qualifiedName} : ${e}`);
                 return;
             }
             this._data = dataGroup;
@@ -2158,13 +2259,6 @@ class Container extends Scriptable {
                 this.notifyDependents(propertyChange('items', null, item.getState()));
             });
         }
-        if (typeof this._data !== 'undefined' && this.type === 'object') {
-            const dataGroup = this.createDataGroup(dataModel);
-            if (!dataGroup) {
-                return;
-            }
-            this.syncDataAndFormModel(dataGroup);
-        }
     }
     syncDataAndFormModel(contextualDataModel) {
         const result = {
@@ -2610,26 +2704,32 @@ const multipartFormData = (data, attachments) => {
     }
     return formData;
 };
-const createAction = (name, payload = {}) => {
+const createAction = (name, payload = {}, dispatch = false) => {
     switch (name) {
         case 'change':
-            return new Change(payload);
+            return new Change(payload, dispatch);
         case 'submit':
-            return new Submit(payload);
+            return new Submit(payload, dispatch);
         case 'save':
-            return new Save(payload);
+            return new Save(payload, dispatch);
         case 'click':
-            return new Click(payload);
+            return new Click(payload, dispatch);
         case 'addItem':
             return new AddItem(payload);
         case 'removeItem':
             return new RemoveItem(payload);
         case 'reset':
-            return new Reset(payload);
+            return new Reset(payload, dispatch);
         case 'addInstance':
             return new AddInstance(payload);
         case 'removeInstance':
             return new RemoveInstance(payload);
+        case 'invalid':
+            return new Invalid(payload);
+        case 'valid':
+            return new Valid(payload);
+        case 'initialize':
+            return new Initialize(payload, dispatch);
         default:
             console.error('invalid action');
     }
@@ -2703,8 +2803,8 @@ class FunctionRuntimeImpl {
                                     const args = [target, flag];
                                     return FunctionRuntimeImpl.getInstance().getFunctions().setFocus._func.call(undefined, args, data, interpreter);
                                 },
-                                dispatchEvent: (target, eventName, payload) => {
-                                    const args = [target, eventName, payload];
+                                dispatchEvent: (target, eventName, payload, dispatch) => {
+                                    const args = [target, eventName, payload, dispatch];
                                     return FunctionRuntimeImpl.getInstance().getFunctions().dispatchEvent._func.call(undefined, args, data, interpreter);
                                 },
                                 getFiles: (qualifiedName) => {
@@ -2963,9 +3063,13 @@ class FunctionRuntimeImpl {
             dispatchEvent: {
                 _func: (args, data, interpreter) => {
                     const element = args[0];
+                    if (element === null && typeof interpreter !== 'string') {
+                        interpreter.debug.push('Invalid argument passed in dispatchEvent. An element is expected');
+                        return {};
+                    }
                     let eventName = valueOf(args[1]);
                     let payload = args.length > 2 ? valueOf(args[2]) : undefined;
-                    let dispatch = false;
+                    let dispatch = args.length > 3 ? valueOf(args[3]) : false;
                     if (typeof element === 'string') {
                         payload = eventName;
                         eventName = element;
@@ -2976,7 +3080,7 @@ class FunctionRuntimeImpl {
                         event = new CustomEvent(eventName.substring('custom:'.length), payload, dispatch);
                     }
                     else {
-                        event = createAction(eventName, payload);
+                        event = createAction(eventName, payload, dispatch);
                     }
                     if (event != null) {
                         if (typeof element === 'string') {
@@ -3105,6 +3209,9 @@ class Form extends Container {
     get action() {
         return this._jsonModel.action;
     }
+    get isFragment() {
+        return false;
+    }
     importData(dataModel) {
         this.bindToDataModel(new DataGroup('$form', dataModel));
         this.syncDataAndFormModel(this.getDataNode());
@@ -3432,7 +3539,7 @@ class RuleEngine {
         const formula = new Formula(this.customFunctions, getStringToNumberFn(locale), this.debugInfo);
         return { formula, ast: formula.compile(rule, this._globalNames) };
     }
-    execute(node, data, globals, useValueOf = false) {
+    execute(node, data, globals, useValueOf = false, eString) {
         const { formula, ast } = node;
         const oldContext = this._context;
         this._context = globals;
@@ -3443,8 +3550,11 @@ class RuleEngine {
         catch (err) {
             this._context?.form?.logger?.error(err);
         }
-        while (this.debugInfo.length > 0) {
-            this._context?.form?.logger?.debug(this.debugInfo.pop());
+        if (this.debugInfo.length) {
+            this._context?.form?.logger?.warn(`Form rule expression string: ${eString}`);
+            while (this.debugInfo.length > 0) {
+                this._context?.form?.logger?.warn(this.debugInfo.pop());
+            }
         }
         let finalRes = res;
         if (useValueOf) {

package/esm/types/src/BaseNode.d.ts

@@ -20,12 +20,14 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     };
     private _tokens;
     _eventSource: EventSource;
+    protected _fragment: string;
     get isContainer(): boolean;
     constructor(params: T, _options: {
         form: FormModel;
         parent: ContainerModel;
         mode?: 'create' | 'restore';
     });
+    get fragment(): string;
     abstract value: Primitives;
     abstract reset(): any;
     protected setupRuleNode(): void;

package/esm/types/src/Container.d.ts

@@ -6,6 +6,8 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
     protected _childrenReference: any;
     private _itemTemplate;
     private fieldFactory;
+    private _isFragment;
+    private _insideFragment;
     constructor(json: T, _options: {
         form: FormModel;
         parent: ContainerModel;
@@ -56,6 +58,7 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
     indexOf(f: FieldModel | FieldsetModel): number;
     defaultDataModel(name: string): DataGroup | undefined;
     _canHaveRepeatingChildren(mode?: FormCreationMode): boolean;
+    get isFragment(): any;
     _initialize(mode?: FormCreationMode): void;
     private _initializeSiteContainer;
     addItem(action: Action): void;
@@ -64,7 +67,6 @@ declare abstract class Container<T extends ContainerJson & RulesJson> extends Sc
     reset(): void;
     validate(): import("./types/Model").ValidationError[];
     dispatch(action: Action): void;
-    createDataGroup(dataModel: any): DataGroup | null;
     importData(dataModel: any): void;
     syncDataAndFormModel(contextualDataModel?: DataGroup): any;
     get activeChild(): BaseModel | null;

package/esm/types/src/Form.d.ts

@@ -26,6 +26,7 @@ declare class Form extends Container<FormJson> implements FormModel {
     private dataRefRegex;
     get metaData(): FormMetaData;
     get action(): string | undefined;
+    get isFragment(): boolean;
     importData(dataModel: any): void;
     exportData(): any;
     setAdditionalSubmitMetadata(metadata: Record<string, any>): void;

package/esm/types/src/controller/Events.d.ts

@@ -1,4 +1,8 @@
-import { Action, BaseJson, FieldModel, FieldsetModel, FormModel, ValidationError, EventSource } from '../types/index';
+import { Action, BaseJson, FieldModel, FieldsetModel, FormModel, ValidationError } from '../types/index';
+declare enum EventSource {
+    CODE = "code",
+    UI = "ui"
+}
 declare class ActionImpl implements Action {
     private _metadata?;
     protected _type: string;
@@ -32,10 +36,6 @@ export type UIChangePayload = {
     value?: any;
     checked?: boolean;
 };
-export type AddItemPayload = {
-    index: number;
-    data: Record<string, any>;
-};
 export declare class Change extends ActionImpl {
     constructor(payload: ChangePayload, dispatch?: boolean);
     withAdditionalChange(change: Change): Change;
@@ -97,13 +97,13 @@ export declare class CustomEvent extends ActionImpl {
     get isCustomEvent(): boolean;
 }
 export declare class AddItem extends ActionImpl {
-    constructor(payload?: number | AddItemPayload);
+    constructor(payload?: number);
 }
 export declare class RemoveItem extends ActionImpl {
     constructor(payload?: number);
 }
 export declare class AddInstance extends ActionImpl {
-    constructor(payload?: number | AddItemPayload);
+    constructor(payload?: number);
 }
 export declare class RemoveInstance extends ActionImpl {
     constructor(payload?: number);

package/esm/types/src/rules/RuleEngine.d.ts

@@ -10,7 +10,7 @@ declare class RuleEngine {
         formula: Formula;
         ast: any;
     };
-    execute(node: any, data: any, globals: any, useValueOf?: boolean): any;
+    execute(node: any, data: any, globals: any, useValueOf: boolean | undefined, eString: string): any;
     trackDependency(subscriber: BaseModel): void;
 }
 export default RuleEngine;