@aemforms/af-core 0.22.25 → 0.22.26

package/lib/esm/Node.js

@@ -0,0 +1,16 @@
+import { getProperty } from './utils/JsonUtils.js';
+class Node {
+    _jsonModel;
+    constructor(inputModel) {
+        this._jsonModel = {
+            ...inputModel
+        };
+    }
+    getP(key, def) {
+        return getProperty(this._jsonModel, key, def);
+    }
+    get isContainer() {
+        return false;
+    }
+}
+export default Node;

package/lib/esm/Scriptable.d.ts

@@ -0,0 +1,17 @@
+import { Action, RulesJson, ScriptableField } from './types/index.js';
+import { BaseNode } from './BaseNode.js';
+declare abstract class Scriptable<T extends RulesJson> extends BaseNode<T> implements ScriptableField {
+    private _events;
+    private _rules;
+    getRules(): import("./types/Json.js").Items<string>;
+    private getCompiledRule;
+    private getCompiledEvent;
+    private applyUpdates;
+    protected executeAllRules(context: any): void;
+    private getExpressionScope;
+    private executeEvent;
+    executeRule(event: Action, context: any): void;
+    executeExpression(expr: string): any;
+    executeAction(action: Action): void;
+}
+export default Scriptable;

package/lib/esm/Scriptable.js

@@ -0,0 +1,163 @@
+import { BaseNode, editableProperties } from './BaseNode.js';
+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);
+                }
+                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`);
+            }
+        }
+        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];
+            }
+            if (typeof eString !== 'undefined' && eString.length > 0) {
+                this._events[eName] = eString.map(x => {
+                    try {
+                        return this.ruleEngine.compileRule(x);
+                    }
+                    catch (e) {
+                        this.form.logger.error(`Unable to compile expression \`"${eName}" : "${eString}"\` Exception : ${e}`);
+                    }
+                    return null;
+                }).filter(x => x !== null);
+            }
+        }
+        return this._events[eName] || [];
+    }
+    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);
+                }
+            }
+        });
+    }
+    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) {
+                        this[prop] = newVal;
+                    }
+                    else {
+                        this.form.logger.warn(`${prop} is not a valid editable property.`);
+                    }
+                }
+            });
+        }
+    }
+    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';
+                }
+                prop = prop;
+                if (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;
+    }
+    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);
+        return this.ruleEngine.execute(node, this.getExpressionScope(), ruleContext);
+    }
+    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);
+    }
+}
+export default Scriptable;

package/lib/esm/controller/EventQueue.d.ts

@@ -0,0 +1,17 @@
+import { Action, BaseJson } from '../types/index.js';
+import { BaseNode } from '../BaseNode.js';
+import { Logger } from './Logger.js';
+declare class EventQueue {
+    private logger;
+    static readonly MAX_EVENT_CYCLE_COUNT = 10;
+    private _runningEventCount;
+    private _isProcessing;
+    private _pendingEvents;
+    constructor(logger?: Logger);
+    get length(): number;
+    get isProcessing(): boolean;
+    isQueued<T extends BaseJson>(node: BaseNode<T>, event: Action): boolean;
+    queue<T extends BaseJson>(node: BaseNode<T>, events: Action | Action[], priority?: boolean): void;
+    runPendingQueue(): void;
+}
+export default EventQueue;

package/lib/esm/controller/EventQueue.js

@@ -0,0 +1,86 @@
+import { Logger } from './Logger.js';
+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}`);
+            }
+        });
+    }
+    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;
+    }
+}
+export default EventQueue;

package/lib/esm/controller/Events.d.ts

@@ -0,0 +1,85 @@
+import { Action, BaseJson, FieldModel, FieldsetModel, FormModel, ValidationError } from '../types/index.js';
+declare class ActionImpl implements Action {
+    private _metadata?;
+    protected _type: string;
+    private _payload?;
+    private _target;
+    constructor(payload: any, type: string, _metadata?: any);
+    get type(): string;
+    get payload(): any;
+    get metadata(): any;
+    get target(): FormModel | FieldModel | FieldsetModel;
+    get isCustomEvent(): boolean;
+    protected payloadToJson(): any;
+    toJson(): {
+        payload: any;
+        type: string;
+        isCustomEvent: boolean;
+    };
+    toString(): string;
+}
+export declare type ChangePayload = {
+    changes: Array<{
+        propertyName: string;
+        prevValue?: any;
+        currentValue: any;
+    }>;
+};
+export declare class Change extends ActionImpl {
+    constructor(payload: ChangePayload, dispatch?: boolean);
+    withAdditionalChange(change: Change): Change;
+}
+export declare class Invalid extends ActionImpl {
+    constructor(payload?: any);
+}
+export declare class Valid extends ActionImpl {
+    constructor(payload?: any);
+}
+export declare class ExecuteRule extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare const propertyChange: (propertyName: string, currentValue: any, prevValue?: any) => Change;
+export declare class Initialize extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class FormLoad extends ActionImpl {
+    constructor();
+}
+export declare class Click extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class Blur extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class ValidationComplete extends ActionImpl {
+    constructor(payload?: Array<ValidationError>, dispatch?: boolean);
+}
+export declare class Focus extends ActionImpl {
+    constructor();
+}
+export declare class Submit extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class Reset extends ActionImpl {
+    constructor(payload?: any, dispatch?: boolean);
+}
+export declare class FieldChanged extends ActionImpl {
+    constructor(changes: ChangePayload, field: BaseJson);
+}
+export declare class CustomEvent extends ActionImpl {
+    constructor(eventName: string, payload?: any, dispatch?: boolean);
+    get isCustomEvent(): boolean;
+}
+export declare class AddItem extends ActionImpl {
+    constructor(payload?: number);
+}
+export declare class RemoveItem extends ActionImpl {
+    constructor(payload?: number);
+}
+export declare class AddInstance extends ActionImpl {
+    constructor(payload?: number);
+}
+export declare class RemoveInstance extends ActionImpl {
+    constructor(payload?: number);
+}
+export {};

package/lib/esm/controller/Events.js

@@ -0,0 +1,149 @@
+class ActionImpl {
+    _metadata;
+    _type;
+    _payload;
+    _target;
+    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 isCustomEvent() {
+        return false;
+    }
+    payloadToJson() {
+        return this.payload;
+    }
+    toJson() {
+        return {
+            payload: this.payloadToJson(),
+            type: this.type,
+            isCustomEvent: this.isCustomEvent
+        };
+    }
+    toString() {
+        return JSON.stringify(this.toJson());
+    }
+}
+export 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);
+    }
+}
+export class Invalid extends ActionImpl {
+    constructor(payload = {}) {
+        super(payload, 'invalid', {});
+    }
+}
+export class Valid extends ActionImpl {
+    constructor(payload = {}) {
+        super(payload, 'valid', {});
+    }
+}
+export class ExecuteRule extends ActionImpl {
+    constructor(payload = {}, dispatch = false) {
+        super(payload, 'executeRule', { dispatch });
+    }
+}
+export const propertyChange = (propertyName, currentValue, prevValue) => {
+    return new Change({
+        changes: [
+            {
+                propertyName,
+                currentValue,
+                prevValue
+            }
+        ]
+    });
+};
+export class Initialize extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'initialize', { dispatch });
+    }
+}
+export class FormLoad extends ActionImpl {
+    constructor() {
+        super({}, 'load', { dispatch: false });
+    }
+}
+export class Click extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'click', { dispatch });
+    }
+}
+export class Blur extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'blur', { dispatch });
+    }
+}
+export class ValidationComplete extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'validationComplete', { dispatch });
+    }
+}
+export class Focus extends ActionImpl {
+    constructor() {
+        super({}, 'focus', { dispatch: false });
+    }
+}
+export class Submit extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'submit', { dispatch });
+    }
+}
+export class Reset extends ActionImpl {
+    constructor(payload, dispatch = false) {
+        super(payload, 'reset', { dispatch });
+    }
+}
+export class FieldChanged extends ActionImpl {
+    constructor(changes, field) {
+        super({
+            field,
+            changes
+        }, 'fieldChanged');
+    }
+}
+export class CustomEvent extends ActionImpl {
+    constructor(eventName, payload = {}, dispatch = false) {
+        super(payload, eventName, { dispatch });
+    }
+    get isCustomEvent() {
+        return true;
+    }
+}
+export class AddItem extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'addItem');
+    }
+}
+export class RemoveItem extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'removeItem');
+    }
+}
+export class AddInstance extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'addInstance');
+    }
+}
+export class RemoveInstance extends ActionImpl {
+    constructor(payload) {
+        super(payload, 'removeInstance');
+    }
+}

package/lib/esm/controller/Logger.d.ts

@@ -0,0 +1,11 @@
+export declare type LogFunction = 'info' | 'warn' | 'error' | 'debug';
+export declare type LogLevel = 'off' | LogFunction;
+export declare class Logger {
+    debug(msg: string): void;
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    log(msg: string, level: LogFunction): void;
+    private logLevel;
+    constructor(logLevel?: LogLevel);
+}

package/lib/esm/controller/Logger.js

@@ -0,0 +1,30 @@
+const levels = {
+    off: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4
+};
+export 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');
+    }
+    log(msg, level) {
+        if (this.logLevel !== 0 && this.logLevel <= levels[level]) {
+            console[level](msg);
+        }
+    }
+    logLevel;
+    constructor(logLevel = 'off') {
+        this.logLevel = levels[logLevel];
+    }
+}

package/lib/esm/data/DataGroup.d.ts

@@ -0,0 +1,20 @@
+import DataValue from './DataValue.js';
+export default class DataGroup extends DataValue {
+    $_items: {
+        [key: string]: DataValue | DataGroup;
+    } | DataValue[] | DataGroup[];
+    private createEntry;
+    constructor(_name: string | number, _value: {
+        [key: string]: any;
+    } | any[], _type?: string);
+    get $value(): Array<any> | {
+        [key: string]: any;
+    };
+    get $length(): number;
+    $convertToDataValue(): DataValue;
+    $addDataNode(name: string | number, value: DataGroup | DataValue, override?: boolean): void;
+    $removeDataNode(name: string | number): void;
+    $getDataNode(name: string | number): any;
+    $containsDataNode(name: string | number): boolean;
+    get $isDataGroup(): boolean;
+}

package/lib/esm/data/DataGroup.js

@@ -0,0 +1,77 @@
+import DataValue from './DataValue.js';
+import NullDataValue from './EmptyDataValue.js';
+export default class DataGroup extends DataValue {
+    $_items;
+    createEntry(key, value) {
+        const t = value instanceof Array ? 'array' : typeof value;
+        if (typeof value === 'object' && value != null) {
+            return new DataGroup(key, value, t);
+        }
+        else {
+            return new DataValue(key, value, t);
+        }
+    }
+    constructor(_name, _value, _type = typeof _value) {
+        super(_name, _value, _type);
+        if (_value instanceof Array) {
+            this.$_items = _value.map((value, index) => {
+                return this.createEntry(index, value);
+            });
+        }
+        else {
+            this.$_items = Object.fromEntries(Object.entries(_value).map(([key, value]) => {
+                return [key, this.createEntry(key, value)];
+            }));
+        }
+    }
+    get $value() {
+        const enabled = this.$_fields.find(x => x.enabled !== false);
+        if (!enabled && this.$_fields.length) {
+            return this.$type === 'array' ? [] : {};
+        }
+        else if (this.$type === 'array') {
+            return Object.values(this.$_items).filter(x => typeof x !== 'undefined').map(x => x.$value);
+        }
+        else {
+            return Object.fromEntries(Object.values(this.$_items).filter(x => typeof x !== 'undefined').map(x => {
+                return [x.$name, x.$value];
+            }));
+        }
+    }
+    get $length() {
+        return Object.entries(this.$_items).length;
+    }
+    $convertToDataValue() {
+        return new DataValue(this.$name, this.$value, this.$type);
+    }
+    $addDataNode(name, value, override = false) {
+        if (value !== NullDataValue) {
+            if (this.$type === 'array') {
+                const index = name;
+                if (!override) {
+                    this.$_items.splice(index, 0, value);
+                }
+                else {
+                    this.$_items[name] = value;
+                }
+            }
+            else {
+                this.$_items[name] = value;
+            }
+        }
+    }
+    $removeDataNode(name) {
+        this.$_items[name] = undefined;
+    }
+    $getDataNode(name) {
+        if (this.$_items.hasOwnProperty(name)) {
+            return this.$_items[name];
+        }
+    }
+    $containsDataNode(name) {
+        return this.$_items.hasOwnProperty(name) && typeof (this.$_items[name]) !== 'undefined';
+    }
+    get $isDataGroup() {
+        return true;
+    }
+}

package/lib/esm/data/DataValue.d.ts

@@ -0,0 +1,16 @@
+import { FieldModel } from '../types/index.js';
+export default class DataValue {
+    private $_name;
+    private $_value;
+    private $_type;
+    $_fields: Array<FieldModel>;
+    constructor($_name: string | number, $_value: any, $_type?: string);
+    valueOf(): any;
+    get $name(): string | number;
+    get $value(): any;
+    setValue(typedValue: any, originalValue: any, fromField: FieldModel): void;
+    get $type(): string;
+    $bindToField(field: FieldModel): void;
+    $convertToDataValue(): DataValue;
+    get $isDataGroup(): boolean;
+}