@aemforms/af-core 0.22.136 → 0.22.138

package/esm/afb-runtime.js

@@ -205,6 +205,103 @@ const isRepeatable$1 = (obj) => {
             (obj.maxOccur !== undefined && obj.maxOccur !== 0))) || false);
 };
 
+class PropertiesManager {
+    constructor(host) {
+        this.host = host;
+        this._definedProperties = new Set();
+        this._propertiesWrapper = {};
+        this._initialized = false;
+    }
+    get properties() {
+        if (!this._initialized) {
+            this._setupInitialProperties();
+            this._initialized = true;
+        }
+        return this._propertiesWrapper;
+    }
+    set properties(p) {
+        const oldProperties = this.host._jsonModel.properties || {};
+        const newProperties = { ...p };
+        this.host._jsonModel.properties = newProperties;
+        Object.keys(newProperties).forEach(prop => {
+            this._ensurePropertyDescriptor(prop);
+        });
+        Object.keys({ ...oldProperties, ...newProperties }).forEach(prop => {
+            if (oldProperties[prop] !== newProperties[prop]) {
+                const changeAction = propertyChange(`properties.${prop}`, newProperties[prop], oldProperties[prop]);
+                this.host.notifyDependents(changeAction);
+            }
+        });
+    }
+    ensurePropertyDescriptor(propertyName) {
+        this._ensurePropertyDescriptor(propertyName);
+    }
+    _setupInitialProperties() {
+        const properties = this.host._jsonModel.properties || {};
+        Object.keys(properties).forEach(prop => {
+            this._ensurePropertyDescriptor(prop);
+        });
+        if (!this.host._jsonModel.properties) {
+            this.host._jsonModel.properties = {};
+        }
+    }
+    _ensurePropertyDescriptor(prop) {
+        if (this._definedProperties.has(prop)) {
+            return;
+        }
+        Object.defineProperty(this._propertiesWrapper, prop, {
+            get: () => {
+                if (!prop.startsWith('fd:')) {
+                    this.host.ruleEngine.trackDependency(this.host, `properties.${prop}`);
+                }
+                const properties = this.host._jsonModel.properties || {};
+                return properties[prop];
+            },
+            set: (value) => {
+                const properties = this.host._jsonModel.properties || {};
+                const oldValue = properties[prop];
+                if (oldValue !== value) {
+                    const updatedProperties = { ...properties, [prop]: value };
+                    this.host._jsonModel.properties = updatedProperties;
+                    const changeAction = propertyChange(`properties.${prop}`, value, oldValue);
+                    this.host.notifyDependents(changeAction);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        this._definedProperties.add(prop);
+    }
+    updateNestedProperty(propertyPath, value) {
+        const parts = propertyPath.split('.');
+        const topLevelProp = parts[0];
+        this._ensurePropertyDescriptor(topLevelProp);
+        const properties = this.host._jsonModel.properties || {};
+        const updatedProperties = JSON.parse(JSON.stringify(properties));
+        const currentObj = updatedProperties[topLevelProp] || {};
+        updatedProperties[topLevelProp] = currentObj;
+        let parentObj = currentObj;
+        for (let i = 1; i < parts.length - 1; i++) {
+            if (!parentObj[parts[i]]) {
+                parentObj[parts[i]] = {};
+            } else if (typeof parentObj[parts[i]] !== 'object') {
+                parentObj[parts[i]] = {};
+            }
+            parentObj = parentObj[parts[i]];
+        }
+        const finalProp = parts[parts.length - 1];
+        const oldValue = parentObj[finalProp];
+        parentObj[finalProp] = value;
+        this.host._jsonModel.properties = updatedProperties;
+        const changeAction = propertyChange(`properties.${propertyPath}`, value, oldValue);
+        this.host.notifyDependents(changeAction);
+    }
+    updateSimpleProperty(propertyName, value) {
+        this._ensurePropertyDescriptor(propertyName);
+        this._propertiesWrapper[propertyName] = value;
+    }
+}
+
 class DataValue {
     $_name;
     $_value;
@@ -1277,7 +1374,7 @@ function dependencyTracked() {
         const get = descriptor.get;
         if (get != undefined) {
             descriptor.get = function () {
-                this.ruleEngine.trackDependency(this);
+                this.ruleEngine.trackDependency(this, propertyKey);
                 return get.call(this);
             };
         }
@@ -1315,6 +1412,7 @@ class BaseNode {
     _eventSource = EventSource.CODE;
     _fragment = '$form';
     _idSet;
+    _propertiesManager;
     createIdSet() {
         return new Set();
     }
@@ -1335,6 +1433,7 @@ class BaseNode {
         else if (this.parent?.fragment) {
             this._fragment = this.parent.fragment;
         }
+        this._propertiesManager = new PropertiesManager(this);
     }
     get fragment() {
         return this._fragment;
@@ -1450,7 +1549,11 @@ class BaseNode {
         return this._jsonModel.label;
     }
     set label(l) {
-        if (l !== this._jsonModel.label) {
+        const isLabelSame = (l !== null && this._jsonModel.label !== null &&
+            typeof l === 'object' && typeof this._jsonModel.label === 'object') ?
+            JSON.stringify(l) === JSON.stringify(this._jsonModel.label) :
+            l === this._jsonModel.label;
+        if (!isLabelSame) {
             const changeAction = propertyChange('label', l, this._jsonModel.label);
             this._jsonModel = {
                 ...this._jsonModel,
@@ -1467,29 +1570,31 @@ class BaseNode {
         return !this._jsonModel.name && !isNonTransparent;
     }
     getDependents() {
-        return this._dependents.map(x => x.node.id);
+        return this._dependents.map(x => ({ id: x.node.id, propertyName: x.propertyName }));
     }
     getState(forRestore = false) {
-        return {
-            ...this._jsonModel,
-            properties: this.properties,
-            index: this.index,
-            parent: undefined,
-            qualifiedName: this.qualifiedName,
-            ...(this.repeatable === true ? {
-                repeatable: true,
-                minOccur: this.parent.minItems,
-                maxOccur: this.parent.maxItems
-            } : {}),
-            ':type': this[':type'],
-            ...(forRestore ? {
-                _dependents: this._dependents.length ? this.getDependents() : undefined,
-                allowedComponents: undefined,
-                columnClassNames: undefined,
-                columnCount: undefined,
-                gridClassNames: undefined
-            } : {})
-        };
+        return this.withDependencyTrackingControl(true, () => {
+            return {
+                ...this._jsonModel,
+                properties: this.properties,
+                index: this.index,
+                parent: undefined,
+                qualifiedName: this.qualifiedName,
+                ...(this.repeatable === true ? {
+                    repeatable: true,
+                    minOccur: this.parent.minItems,
+                    maxOccur: this.parent.maxItems
+                } : {}),
+                ':type': this[':type'],
+                ...(forRestore ? {
+                    _dependents: this._dependents.length ? this.getDependents() : undefined,
+                    allowedComponents: undefined,
+                    columnClassNames: undefined,
+                    columnCount: undefined,
+                    gridClassNames: undefined
+                } : {})
+            };
+        });
     }
     subscribe(callback, eventName = 'change') {
         this._callbacks[eventName] = this._callbacks[eventName] || [];
@@ -1500,13 +1605,14 @@ class BaseNode {
             }
         };
     }
-    _addDependent(dependent) {
+    _addDependent(dependent, propertyName) {
         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;
+                    const changedPropertyName = x.propertyName;
+                    return propsToLook.includes(changedPropertyName) || (changedPropertyName.startsWith('properties.') && propertyName === changedPropertyName);
                 }) > -1;
                 if (isPropChanged) {
                     if (this.form.changeEventBehaviour === 'deps') {
@@ -1517,7 +1623,7 @@ class BaseNode {
                     }
                 }
             });
-            this._dependents.push({ node: dependent, subscription });
+            this._dependents.push({ node: dependent, propertyName, subscription });
         }
     }
     removeDependent(dependent) {
@@ -1553,9 +1659,9 @@ class BaseNode {
         const depsToRestore = this._jsonModel._dependents;
         if (depsToRestore) {
             depsToRestore.forEach((x) => {
-                const node = this.form.getElement(x);
+                const node = this.form.getElement(x.id);
                 if (node) {
-                    this._addDependent(node);
+                    this._addDependent(node, x.propertyName);
                 }
             });
             this._jsonModel._dependents = undefined;
@@ -1682,10 +1788,13 @@ class BaseNode {
         return this._lang;
     }
     get properties() {
-        return this._jsonModel.properties || {};
+        return this._propertiesManager.properties;
     }
     set properties(p) {
-        this._setProperty('properties', { ...p });
+        this._propertiesManager.properties = p;
+    }
+    getPropertiesManager() {
+        return this._propertiesManager;
     }
     getNonTransparentParent() {
         let nonTransparentParent = this.parent;
@@ -1776,9 +1885,6 @@ __decorate([
 __decorate([
     dependencyTracked()
 ], BaseNode.prototype, "label", null);
-__decorate([
-    dependencyTracked()
-], BaseNode.prototype, "properties", null);
 
 class Scriptable extends BaseNode {
     _events = {};
@@ -2075,31 +2181,32 @@ class Container extends Scriptable {
         }) : [];
     }
     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) };
-                });
-            }
+        const isThisContainerRepeatable = this._jsonModel.type === 'array' || isRepeatable$1(this._jsonModel);
+        if (isThisContainerRepeatable) {
+            return this._children.map(x => {
+                return { ...x.getState(true, forRestore) };
+            });
         }
         else {
             return this._getFormAndSitesState(isRepeatableChild, forRestore);
         }
     }
     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
-        };
+        return this.withDependencyTrackingControl(true, () => {
+            return {
+                ...super.getState(forRestore),
+                ...(forRestore ? {
+                    ':items': undefined,
+                    ':itemsOrder': undefined
+                } : {}),
+                items: this.getItemsState(isRepeatableChild, forRestore),
+                ...((this._jsonModel.type === 'array' || isRepeatable$1(this._jsonModel)) && this._itemTemplate ? {
+                    _itemTemplate: { ...this._itemTemplate }
+                } : {}),
+                enabled: this.enabled,
+                readOnly: this.readOnly
+            };
+        });
     }
     _createChild(child, options) {
         return this.fieldFactory.createField(child, options);
@@ -2137,10 +2244,10 @@ class Container extends Scriptable {
             Object.defineProperty(parent._childrenReference, name, {
                 get: () => {
                     if (child.isContainer && child.hasDynamicItems()) {
-                        self.ruleEngine.trackDependency(child);
+                        self.ruleEngine.trackDependency(child, 'items');
                     }
                     if (self.hasDynamicItems()) {
-                        self.ruleEngine.trackDependency(self);
+                        self.ruleEngine.trackDependency(self, 'items');
                         if (this._children[name] !== undefined) {
                             return this._children[name].getRuleNode();
                         }
@@ -2205,7 +2312,8 @@ class Container extends Scriptable {
         const items = this._jsonModel.items || [];
         this._childrenReference = this._jsonModel.type == 'array' ? [] : {};
         if (this._canHaveRepeatingChildren(mode)) {
-            this._itemTemplate = deepClone(items[0]);
+            this._itemTemplate = this._jsonModel._itemTemplate || deepClone(items[0]);
+            this._jsonModel._itemTemplate = undefined;
             if (mode === 'restore') {
                 this._itemTemplate.repeatable = undefined;
             }
@@ -2390,9 +2498,8 @@ class Container extends Scriptable {
             if (items2Remove > 0) {
                 for (let i = 0; i < items2Remove; i++) {
                     this._childrenReference.pop();
-                    this._children.pop();
+                    result.removed.push(this._children.pop());
                 }
-                result.removed.push(...this._children);
             }
         }
         this._children.forEach(x => {
@@ -2536,6 +2643,9 @@ class Logger {
             console[level](msg);
         }
     }
+    isLevelEnabled(level) {
+        return this.logLevel !== 0 && this.logLevel <= levels[level];
+    }
     logLevel;
     constructor(logLevel = 'off') {
         this.logLevel = levels[logLevel];
@@ -2596,7 +2706,18 @@ class EventQueue {
             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}`);
+                let payloadAsStr = '';
+                if (e?.type === 'change' && !e?.payload?.changes.map(_ => _.propertyName).includes('activeChild')) {
+                    payloadAsStr = JSON.stringify(e.payload.changes, null, 2);
+                }
+                else if (e?.type.includes('setProperty')) {
+                    payloadAsStr = JSON.stringify(e.payload, null, 2);
+                }
+                if (this.logger.isLevelEnabled('info')) {
+                    node.withDependencyTrackingControl(true, () => {
+                        this.logger.info(`Queued event : ${e.type} node: ${node.id} - ${node.qualifiedName} - ${payloadAsStr}`);
+                    });
+                }
                 if (priority) {
                     const index = this._isProcessing ? 1 : 0;
                     this._pendingEvents.splice(index, 0, evntNode);
@@ -2689,6 +2810,13 @@ const convertQueryString = (endpoint, payload) => {
     return endpoint.includes('?') ? `${endpoint}&${params.join('&')}` : `${endpoint}?${params.join('&')}`;
 };
 
+function parsePropertyPath(keyStr) {
+    return keyStr
+        .replace(/\[/g, '.')
+        .replace(/\]/g, '')
+        .split('.')
+        .filter(Boolean);
+}
 const getCustomEventName = (name) => {
     const eName = name;
     if (eName.length > 0 && eName.startsWith('custom:')) {
@@ -3074,21 +3202,23 @@ class FunctionRuntimeImpl {
             },
             importData: {
                 _func: (args, data, interpreter) => {
-                    const inputData = args[0];
-                    const qualifiedName = args[1];
-                    if (typeof inputData === 'object' && inputData !== null && !qualifiedName) {
-                        interpreter.globals.form.importData(inputData);
-                    }
-                    else {
-                        const field = interpreter.globals.form.resolveQualifiedName(qualifiedName);
-                        if (field?.isContainer) {
-                            field.importData(inputData, qualifiedName);
+                    return interpreter.globals.form.withDependencyTrackingControl(true, () => {
+                        const inputData = args[0];
+                        const qualifiedName = args[1];
+                        if (typeof inputData === 'object' && inputData !== null && !qualifiedName) {
+                            interpreter.globals.form.importData(inputData);
                         }
                         else {
-                            interpreter.globals.form.logger.error('Invalid argument passed in importData. A container is expected');
+                            const field = interpreter.globals.form.resolveQualifiedName(qualifiedName);
+                            if (field?.isContainer) {
+                                field.importData(inputData, qualifiedName);
+                            }
+                            else {
+                                interpreter.globals.form.logger.error('Invalid argument passed in importData. A container is expected');
+                            }
                         }
-                    }
-                    return {};
+                        return {};
+                    });
                 },
                 _signature: []
             },
@@ -3153,6 +3283,49 @@ class FunctionRuntimeImpl {
                 },
                 _signature: []
             },
+            setVariable: {
+                _func: (args, data, interpreter) => {
+                    const variableName = toString(args[0]);
+                    let variableValue = args[1];
+                    const normalFieldOrPanel = args[2] || interpreter.globals.form;
+                    if (variableValue && typeof variableValue === 'object' && '$qualifiedName' in variableValue) {
+                        const variableValueElement = interpreter.globals.form.getElement(variableValue.$id);
+                        variableValue = variableValueElement._jsonModel.value;
+                    }
+                    const target = interpreter.globals.form.getElement(normalFieldOrPanel.$id);
+                    const propertiesManager = target.getPropertiesManager();
+                    propertiesManager.updateSimpleProperty(variableName, variableValue);
+                    return {};
+                },
+                _signature: []
+            },
+            getVariable: {
+                _func: (args, data, interpreter) => {
+                    const variableName = toString(args[0]);
+                    const normalFieldOrPanel = args[1] || interpreter.globals.form;
+                    if (!variableName) {
+                        return undefined;
+                    }
+                    const target = interpreter.globals.form.getElement(normalFieldOrPanel.$id);
+                    const propertiesManager = target.getPropertiesManager();
+                    if (variableName.includes('.')) {
+                        const properties = parsePropertyPath(variableName);
+                        let value = propertiesManager.properties;
+                        for (const prop of properties) {
+                            if (value === undefined || value === null) {
+                                return undefined;
+                            }
+                            value = value[prop];
+                        }
+                        return value;
+                    }
+                    else {
+                        propertiesManager.ensurePropertyDescriptor(variableName);
+                        return propertiesManager.properties[variableName];
+                    }
+                },
+                _signature: []
+            },
             request: {
                 _func: (args, data, interpreter) => {
                     const uri = toString(args[0]);
@@ -3445,6 +3618,15 @@ class FunctionRuntimeImpl {
                     return instanceManager.length - 1;
                 },
                 _signature: []
+            },
+            today: {
+                _func: () => {
+                    const MS_IN_DAY = 24 * 60 * 60 * 1000;
+                    const now = new Date(Date.now());
+                    const _today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+                    return _today / MS_IN_DAY;
+                },
+                _signature: []
             }
         };
         return { ...defaultFunctions, ...FunctionRuntimeImpl.getInstance().customFunctions };
@@ -3973,9 +4155,9 @@ class RuleEngine {
         this._context = oldContext;
         return finalRes;
     }
-    trackDependency(subscriber) {
+    trackDependency(subscriber, propertyName) {
         if (this.dependencyTracking && this._context && this._context.field !== undefined && this._context.field !== subscriber) {
-            subscriber._addDependent(this._context.field);
+            subscriber._addDependent(this._context.field, propertyName);
         }
     }
     setDependencyTracking(track) {
@@ -4474,7 +4656,7 @@ class Field extends Scriptable {
     valueOf() {
         const obj = this[target];
         const actualField = obj === undefined ? this : obj;
-        actualField.ruleEngine.trackDependency(actualField);
+        actualField.ruleEngine.trackDependency(actualField, 'value');
         return actualField._jsonModel.value || null;
     }
     toString() {

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

@@ -1,4 +1,5 @@
 import { Action, BaseJson, BaseModel, callbackFn, ContainerModel, FormCreationMode, FormModel, Primitives, ValidationError, EventSource } from './types/index';
+import { PropertiesManager } from './PropertiesManager.js';
 import DataGroup from './data/DataGroup';
 import DataValue from './data/DataValue';
 export declare const editableProperties: string[];
@@ -22,6 +23,7 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     _eventSource: EventSource;
     protected _fragment: string;
     protected _idSet: Set<string> | undefined;
+    private _propertiesManager;
     protected createIdSet(): Set<string> | undefined;
     get isContainer(): boolean;
     constructor(params: T, _options: {
@@ -56,9 +58,15 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     set label(l: import("./types/Json").Label | undefined);
     get uniqueItems(): boolean | undefined;
     isTransparent(): boolean;
-    getDependents(): string[];
+    getDependents(): {
+        id: string;
+        propertyName: string | undefined;
+    }[];
     getState(forRestore?: boolean): T & {
-        _dependents?: string[] | undefined;
+        _dependents?: {
+            id: string;
+            propertyName: string | undefined;
+        }[] | undefined;
         allowedComponents?: undefined;
         columnClassNames?: undefined;
         columnCount?: undefined;
@@ -78,7 +86,7 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     subscribe(callback: callbackFn, eventName?: string): {
         unsubscribe: () => void;
     };
-    _addDependent(dependent: BaseModel): void;
+    _addDependent(dependent: BaseModel, propertyName?: string): void;
     removeDependent(dependent: BaseModel): void;
     abstract validate(): Array<ValidationError>;
     abstract executeAction(action: Action): any;
@@ -98,6 +106,7 @@ export declare abstract class BaseNode<T extends BaseJson> implements BaseModel
     set properties(p: {
         [key: string]: any;
     });
+    getPropertiesManager(): PropertiesManager;
     abstract defaultDataModel(name: string | number): DataValue | undefined;
     abstract syncDataAndFormModel(a?: DataValue | DataGroup): any;
     getNonTransparentParent(): ContainerModel;

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

@@ -129,6 +129,8 @@ declare class Checkbox extends Field {
         errorMessage?: string | undefined;
         properties: {
             [key: string]: any;
+        } & {
+            [key: string]: any;
         };
         repeatable?: boolean | undefined;
         screenReaderText?: string | undefined;
@@ -144,7 +146,10 @@ declare class Checkbox extends Field {
         value?: any;
         displayValueExpression?: string | undefined;
         emptyValue?: "" | "undefined" | "null" | undefined;
-        _dependents?: string[] | undefined;
+        _dependents?: {
+            id: string;
+            propertyName: string | undefined;
+        }[] | undefined;
         allowedComponents?: undefined;
         columnClassNames?: undefined;
         columnCount?: undefined;