@aemforms/af-core 0.15.0

package/LICENSE

@@ -0,0 +1,5 @@
+Copyright 2022 Adobe, Inc.
+
+Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# Introduction
+
+The core module containing the model to interpret Adaptive Form JSON Definition and execute rules/expressions
+specified in that.
+
+## Usage
+
+Save it as a dependency
+```
+npm i --save @aemforms/af-core
+```
+
+### Create a new Form from JSON
+```
+import {createFormInstance} from '@aemforms/af-core';
+const formJson = {..}
+const form = createFormInstance(formJson)
+
+//import data in the form
+form.importData({})
+
+//export data after form is being filled by the user
+const data = form.exportData()
+
+```
+
+### Validate form Data
+
+```
+import {validateFormInstance} from '@aemforms/af-core';
+const formJson = {..}
+const data = {...}
+const valid = validateFormInstance(formJson, data)
+```

package/lib/BaseNode.d.ts

@@ -0,0 +1,117 @@
+import { Action, BaseJson, BaseModel, callbackFn, ContainerModel, FormModel, Primitives, ValidationError } from './types';
+import DataGroup from './data/DataGroup';
+import DataValue from './data/DataValue';
+export declare const target: unique symbol;
+/**
+ * Defines a generic base class which all objects of form runtime model should extend from.
+ * @typeparam T type of the form object which extends from {@link BaseJson | base type}
+ */
+export declare abstract class BaseNode<T extends BaseJson> implements BaseModel {
+    private _options;
+    private _ruleNode;
+    private _callbacks;
+    private _dependents;
+    protected _jsonModel: T & {
+        id: string;
+    };
+    private _tokens;
+    get isContainer(): boolean;
+    /**
+     * @constructor
+     * @param params
+     * @param _options
+     * @private
+     */
+    constructor(params: T, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    abstract value: Primitives;
+    protected setupRuleNode(): void;
+    /**
+     * @private
+     */
+    ruleNodeReference(): this;
+    /**
+     * @private
+     */
+    getRuleNode(): any;
+    private getFromRule;
+    get id(): string;
+    get index(): number;
+    get parent(): ContainerModel;
+    get type(): string | undefined;
+    get fieldType(): string;
+    get ':type'(): string;
+    get name(): string | undefined;
+    get description(): string | undefined;
+    set description(d: string | undefined);
+    get dataRef(): string | null | undefined;
+    get visible(): boolean | undefined;
+    set visible(v: boolean | undefined);
+    get form(): FormModel;
+    get ruleEngine(): import("./rules/RuleEngine").default;
+    get label(): import("./types").Label | undefined;
+    set label(l: import("./types").Label | undefined);
+    /**
+     * Transparent form fields are meant only for creation of view. They are also not part of data
+     */
+    isTransparent(): boolean;
+    getState(): T & {
+        ':type': string;
+        id: string;
+    };
+    /**
+     * @private
+     */
+    subscribe(callback: callbackFn, eventName?: string): {
+        unsubscribe: () => void;
+    };
+    /**
+     * @private
+     */
+    addDependent(action: Action): void;
+    /**
+     * @private
+     */
+    removeDependent(action: Action): void;
+    abstract validate(): Array<ValidationError>;
+    abstract executeAction(action: Action): any;
+    /**
+     * @private
+     */
+    queueEvent(action: Action): void;
+    dispatch(action: Action): void;
+    /**
+     * @private
+     */
+    notifyDependents(action: Action): void;
+    /**
+     * @param prop
+     * @param newValue
+     * @private
+     */
+    _setProperty<T>(prop: string, newValue: T, notify?: boolean): any;
+    /**
+     * @private
+     */
+    _bindToDataModel(contextualDataModel?: DataGroup): void;
+    private _data?;
+    /**
+     * @private
+     */
+    getDataNode(): DataValue | undefined;
+    get properties(): {
+        [key: string]: any;
+    };
+    set properties(p: {
+        [key: string]: any;
+    });
+    abstract defaultDataModel(name: string | number): DataValue | undefined;
+    abstract importData(a: DataGroup): any;
+    /**
+     * called after the node is inserted in the parent
+     * @private
+     */
+    _initialize(): void;
+}

package/lib/BaseNode.js

@@ -0,0 +1,368 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNode = exports.target = void 0;
+const controller_1 = require("./controller");
+const DataRefParser_1 = require("./utils/DataRefParser");
+const EmptyDataValue_1 = __importDefault(require("./data/EmptyDataValue"));
+/**
+ * Implementation of action with target
+ * @private
+ */
+class ActionImplWithTarget {
+    /**
+     * @constructor
+     * @param _action
+     * @param _target
+     * @private
+     */
+    constructor(_action, _target) {
+        this._action = _action;
+        this._target = _target;
+    }
+    get type() {
+        return this._action.type;
+    }
+    get payload() {
+        return this._action.payload;
+    }
+    get metadata() {
+        return this._action.metadata;
+    }
+    get target() {
+        return this._target;
+    }
+    get isCustomEvent() {
+        return this._action.isCustomEvent;
+    }
+    get originalAction() {
+        return this._action.originalAction;
+    }
+    toString() {
+        return this._action.toString();
+    }
+}
+exports.target = Symbol('target');
+/**
+ * Defines a generic base class which all objects of form runtime model should extend from.
+ * @typeparam T type of the form object which extends from {@link BaseJson | base type}
+ */
+class BaseNode {
+    /**
+     * @constructor
+     * @param params
+     * @param _options
+     * @private
+     */
+    constructor(params, 
+    //@ts_ignore
+    _options) {
+        this._options = _options;
+        this._callbacks = {};
+        this._dependents = [];
+        this._tokens = [];
+        this._jsonModel = Object.assign(Object.assign({}, params), { 
+            //@ts-ignore
+            id: 'id' in params ? params.id : this.form.getUniqueId() });
+    }
+    get isContainer() {
+        return false;
+    }
+    setupRuleNode() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        this._ruleNode = new Proxy(this.ruleNodeReference(), {
+            get: (ruleNodeReference, prop) => {
+                return self.getFromRule(ruleNodeReference, prop);
+            }
+        });
+    }
+    /**
+     * @private
+     */
+    ruleNodeReference() {
+        return this;
+    }
+    /**
+     * @private
+     */
+    getRuleNode() {
+        return this._ruleNode;
+    }
+    getFromRule(ruleNodeReference, prop) {
+        if (prop === Symbol.toPrimitive || (prop === 'valueOf' && !ruleNodeReference.hasOwnProperty('valueOf'))) {
+            return this.valueOf;
+        }
+        else if (prop === exports.target) {
+            return this;
+        }
+        else if (typeof (prop) === 'string') {
+            //look for property
+            if (prop.startsWith('$')) {
+                prop = prop.substr(1);
+                //@todo: create a list of properties that are allowed
+                //@ts-ignore
+                // return only non functional properties in this object
+                if (typeof this[prop] !== 'function') {
+                    //@ts-ignore
+                    return this[prop];
+                }
+            }
+            else {
+                //look in the items
+                if (ruleNodeReference.hasOwnProperty(prop)) {
+                    return ruleNodeReference[prop];
+                }
+                else if (typeof ruleNodeReference[prop] === 'function') { //todo : create allow list of functions
+                    //to support panel instanceof Array panel1.map(..)
+                    return ruleNodeReference[prop];
+                }
+            }
+        }
+    }
+    get id() {
+        return this._jsonModel.id;
+    }
+    get index() {
+        return this.parent.indexOf(this);
+    }
+    get parent() {
+        return this._options.parent;
+    }
+    get type() {
+        return this._jsonModel.type;
+    }
+    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() {
+        return this._jsonModel.visible;
+    }
+    set visible(v) {
+        if (v !== this._jsonModel.visible) {
+            const changeAction = (0, controller_1.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 = (0, controller_1.propertyChange)('label', l, this._jsonModel.label);
+            this._jsonModel = Object.assign(Object.assign({}, this._jsonModel), { label: l });
+            this.notifyDependents(changeAction);
+        }
+    }
+    /**
+     * Transparent form fields are meant only for creation of view. They are also not part of data
+     */
+    isTransparent() {
+        var _a, _b;
+        // named form fields are not transparent
+        // @ts-ignore
+        // handling repeatable use-case where first item of array can be unnamed
+        const isNonTransparent = ((_a = this.parent) === null || _a === void 0 ? void 0 : _a._jsonModel.type) === 'array' && ((_b = this.parent) === null || _b === void 0 ? void 0 : _b.items.length) === 1;
+        return !this._jsonModel.name && !isNonTransparent;
+    }
+    getState() {
+        return Object.assign(Object.assign({}, this._jsonModel), { ':type': this[':type'] });
+    }
+    /**
+     * @private
+     */
+    subscribe(callback, eventName = 'change') {
+        this._callbacks[eventName] = this._callbacks[eventName] || [];
+        this._callbacks[eventName].push(callback);
+        //console.log(`subscription added : ${this._elem.id}, count : ${this._callbacks[eventName].length}`);
+        return {
+            unsubscribe: () => {
+                this._callbacks[eventName] = this._callbacks[eventName].filter(x => x !== callback);
+                //console.log(`subscription removed : ${this._elem.id}, count : ${this._callbacks[eventName].length}`);
+            }
+        };
+    }
+    /**
+     * @private
+     */
+    addDependent(action) {
+        if (this._dependents.find(({ node }) => node === action.payload) === undefined) {
+            const subscription = this.subscribe((change) => {
+                const changes = change.payload.changes;
+                const propsToLook = ['value', 'items'];
+                // @ts-ignore
+                const isPropChanged = changes.findIndex(x => {
+                    return propsToLook.indexOf(x.propertyName) > -1;
+                }) > -1;
+                if (isPropChanged) {
+                    action.payload.dispatch(new controller_1.ExecuteRule());
+                }
+            });
+            this._dependents.push({ node: action.payload, subscription });
+        }
+    }
+    /**
+     * @private
+     */
+    removeDependent(action) {
+        const index = this._dependents.findIndex(({ node }) => node === action.payload);
+        if (index > -1) {
+            this._dependents[index].subscription.unsubscribe();
+            this._dependents.splice(index, 1);
+        }
+    }
+    /**
+     * @private
+     */
+    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();
+    }
+    /**
+     * @private
+     */
+    notifyDependents(action) {
+        const handlers = this._callbacks[action.type] || [];
+        handlers.forEach(x => {
+            x(new ActionImplWithTarget(action, this));
+        });
+    }
+    /**
+     * @param prop
+     * @param newValue
+     * @private
+     */
+    _setProperty(prop, newValue, notify = true) {
+        //@ts-ignore
+        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 {
+            // @ts-ignore
+            isValueSame = oldValue === newValue;
+        }
+        if (!isValueSame) {
+            //@ts-ignore
+            this._jsonModel[prop] = newValue;
+            const changeAction = (0, controller_1.propertyChange)(prop, newValue, oldValue);
+            if (notify) {
+                this.notifyDependents(changeAction);
+            }
+            return changeAction.payload.changes;
+        }
+        return [];
+    }
+    /**
+     * @private
+     */
+    _bindToDataModel(contextualDataModel) {
+        if (this.id === '$form') {
+            this._data = contextualDataModel;
+            return;
+        }
+        const dataRef = this._jsonModel.dataRef;
+        let _data;
+        if (dataRef === null) {
+            _data = EmptyDataValue_1.default;
+        }
+        else if (dataRef !== undefined) {
+            if (this._tokens.length === 0) {
+                this._tokens = (0, DataRefParser_1.tokenize)(dataRef);
+            }
+            let searchData = contextualDataModel;
+            if (this._tokens[0].type === DataRefParser_1.TOK_GLOBAL) {
+                searchData = this.form.getDataNode();
+            }
+            if (typeof searchData !== 'undefined') {
+                const name = this._tokens[this._tokens.length - 1].value;
+                const create = this.defaultDataModel(name);
+                _data = (0, DataRefParser_1.resolveData)(searchData, this._tokens, create);
+            }
+        }
+        else {
+            if (contextualDataModel != null) {
+                const name = this._jsonModel.name || '';
+                const key = contextualDataModel.$type === 'array' ? this.index : name;
+                if (key !== '') {
+                    const create = this.defaultDataModel(key);
+                    if (create !== undefined) {
+                        _data = contextualDataModel.$getDataNode(key) || create;
+                        contextualDataModel.$addDataNode(key, _data);
+                    }
+                }
+                else {
+                    _data = EmptyDataValue_1.default;
+                }
+            }
+        }
+        if (!this.isContainer) {
+            _data = _data === null || _data === void 0 ? void 0 : _data.$convertToDataValue();
+        }
+        _data === null || _data === void 0 ? void 0 : _data.$bindToField(this);
+        this._data = _data;
+    }
+    /**
+     * @private
+     */
+    getDataNode() {
+        if (this._data === undefined) {
+            return this.parent.getDataNode();
+        }
+        return this._data;
+    }
+    get properties() {
+        return this._jsonModel.properties || {};
+    }
+    set properties(p) {
+        this._setProperty('properties', Object.assign({}, p));
+    }
+    /**
+     * called after the node is inserted in the parent
+     * @private
+     */
+    _initialize() {
+        if (typeof this._data === 'undefined') {
+            const dataNode = this.parent.getDataNode();
+            this._bindToDataModel(dataNode);
+        }
+    }
+}
+exports.BaseNode = BaseNode;

package/lib/Checkbox.d.ts

@@ -0,0 +1,80 @@
+import Field from './Field';
+/**
+ * Implementation of check box runtime model which extends from {@link Field | field} model
+ */
+declare class Checkbox extends Field {
+    private offValue;
+    /**
+     * @private
+     */
+    _getConstraintObject(): {
+        type: (constraint: string, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        format: (constraint: string, input: string) => {
+            valid: boolean;
+            value: string;
+        };
+        minimum: (constraint: number, value: number) => {
+            valid: boolean;
+            value: number;
+        };
+        maximum: (constraint: number, value: number) => {
+            valid: boolean;
+            value: number;
+        };
+        exclusiveMinimum: (constraint: number, value: number) => {
+            valid: boolean;
+            value: number;
+        };
+        exclusiveMaximum: (constraint: number, value: number) => {
+            valid: boolean;
+            value: number;
+        };
+        minItems: <T>(constraint: number, value: T[]) => {
+            valid: boolean;
+            value: T[];
+        };
+        maxItems: <T_1>(constraint: number, value: T_1[]) => {
+            valid: boolean;
+            value: T_1[];
+        };
+        uniqueItems: <T_2>(constraint: boolean, value: T_2[]) => {
+            valid: boolean;
+            value: T_2[];
+        };
+        minLength: (constraint: number, value: string) => {
+            value: string;
+            valid: boolean;
+        };
+        maxLength: (constraint: number, value: string) => {
+            value: string;
+            valid: boolean;
+        };
+        pattern: (constraint: string | RegExp, value: string) => {
+            valid: boolean;
+            value: string;
+        };
+        required: (constraint: boolean, value: any) => {
+            valid: boolean;
+            value: any;
+        };
+        enum: (constraint: any[], value: any) => {
+            valid: boolean;
+            value: any;
+        };
+    };
+    protected _getDefaults(): {
+        enforceEnum: boolean;
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        type: string | undefined;
+    };
+    /**
+     * Returns the `enum` constraints from the json
+     */
+    get enum(): any[];
+}
+export default Checkbox;

package/lib/Checkbox.js

@@ -0,0 +1,49 @@
+"use strict";
+/*
+ * Copyright 2022 Adobe, Inc.
+ *
+ * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Field_1 = __importDefault(require("./Field"));
+const ValidationUtils_1 = require("./utils/ValidationUtils");
+/**
+ * @param offValue
+ * @private
+ */
+const requiredConstraint = (offValue) => (constraint, value) => {
+    const valid = ValidationUtils_1.Constraints.required(constraint, value) && (!constraint || value != offValue);
+    return { valid, value };
+};
+/**
+ * Implementation of check box runtime model which extends from {@link Field | field} model
+ */
+class Checkbox extends Field_1.default {
+    offValue() {
+        const opts = this.enum;
+        return opts.length > 1 ? opts[1] : null;
+    }
+    /**
+     * @private
+     */
+    _getConstraintObject() {
+        const baseConstraints = Object.assign({}, super._getConstraintObject());
+        baseConstraints.required = requiredConstraint(this.offValue());
+        return baseConstraints;
+    }
+    _getDefaults() {
+        return Object.assign(Object.assign({}, super._getDefaults()), { enforceEnum: true });
+    }
+    /**
+     * Returns the `enum` constraints from the json
+     */
+    get enum() {
+        return this._jsonModel.enum || [];
+    }
+}
+exports.default = Checkbox;

package/lib/CheckboxGroup.d.ts

@@ -0,0 +1,30 @@
+import Field from './Field';
+import { ContainerModel, FieldJson, FormModel } from './types';
+/**
+ * Implementation of CheckBoxGroup runtime model which extends from {@link Field | field}
+ */
+declare class CheckboxGroup extends Field {
+    /**
+     * @param params
+     * @param _options
+     * @private
+     */
+    constructor(params: FieldJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    /**
+     * converts the fallback type, if required, to an array. Since checkbox-group has an array type
+     * @protected
+     */
+    protected _getFallbackType(): string | undefined;
+    protected _getDefaults(): {
+        enforceEnum: boolean;
+        enum: never[];
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        type: string | undefined;
+    };
+}
+export default CheckboxGroup;