@aemforms/af-core 0.15.0

package/lib/Form.d.ts

@@ -0,0 +1,413 @@
+import Container from './Container';
+import { Action, FieldJson, FieldModel, FieldsetJson, FieldsetModel, FormJson, FormModel, Items } from './types';
+import FormMetaData from './FormMetaData';
+import EventQueue from './controller/EventQueue';
+import RuleEngine from './rules/RuleEngine';
+declare type LogFunction = 'info' | 'warn' | 'error';
+/**
+ * Logging levels.
+ */
+export declare type LogLevel = 'off' | LogFunction;
+/**
+ * @private
+ */
+export declare class Logger {
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    log(msg: string, level: LogFunction): void;
+    private logLevel;
+    constructor(logLevel?: LogLevel);
+}
+/**
+ * Defines `form model` which implements {@link FormModel | form model}
+ */
+declare class Form extends Container<FormJson> implements FormModel {
+    private _ruleEngine;
+    private _eventQueue;
+    /**
+     * @private
+     */
+    private _fields;
+    /**
+     * @private
+     */
+    _ids: Generator<string, void, string>;
+    /**
+     * @private
+     */
+    private _invalidFields;
+    private _logger;
+    /**
+     * @param n
+     * @param _ruleEngine
+     * @param _eventQueue
+     * @param logLevel
+     * @private
+     */
+    constructor(n: FormJson, _ruleEngine: RuleEngine, _eventQueue?: EventQueue, logLevel?: LogLevel);
+    get logger(): Logger;
+    private dataRefRegex;
+    get metaData(): FormMetaData;
+    get action(): string | undefined;
+    protected _createChild(child: FieldsetJson | FieldJson): FieldModel | FieldsetModel;
+    importData(dataModel: any): void;
+    exportData(): any;
+    /**
+     * Returns the current state of the form
+     *
+     * To access the form data and attachments, one needs to use the `data` and `attachments` property.
+     * For example,
+     * ```
+     * const data = form.getState().data
+     * const attachments = form.getState().attachments
+     * ```
+     */
+    getState(): {
+        description?: string | undefined;
+    } & import("./types").RulesJson & {
+        enumNames?: string[] | undefined;
+        enum?: any[] | undefined;
+    } & {
+        accept?: string[] | undefined;
+        enforceEnum?: boolean | undefined;
+        exclusiveMinimum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        format?: string | undefined;
+        maxFileSize?: string | number | undefined;
+        maxLength?: number | undefined;
+        maximum?: number | undefined;
+        maxItems?: number | undefined;
+        minLength?: number | undefined;
+        minimum?: number | undefined;
+        minItems?: number | undefined;
+        pattern?: string | undefined;
+        required?: boolean | undefined;
+        step?: number | undefined;
+        type?: string | undefined;
+        validationExpression?: string | undefined;
+    } & {
+        dataRef?: string | null | undefined;
+        ':type'?: string | undefined;
+        label?: import("./types").Label | undefined;
+        enabled?: boolean | undefined;
+        visible?: boolean | undefined;
+        name?: string | undefined;
+        constraintMessages?: import("./types").ConstraintsMessages | undefined;
+        fieldType?: string | undefined;
+        errorMessage?: string | undefined;
+        properties?: {
+            [key: string]: any;
+        } | undefined;
+    } & {
+        items: (FieldJson | import("./types").ContainerJson)[];
+        initialItems?: number | undefined;
+    } & {
+        metadata?: import("./types").MetaDataJson | undefined;
+        data?: any;
+        title?: string | undefined;
+        action?: string | undefined;
+        adaptiveForm?: string | undefined;
+    } & {
+        ':type': string;
+        items: ({
+            description?: string | undefined;
+            rules?: Items<string> | undefined;
+            events?: Items<string | string[] | undefined> | undefined;
+            enumNames?: string[] | undefined;
+            enum?: any[] | undefined;
+            accept?: string[] | undefined;
+            enforceEnum?: boolean | undefined;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            format?: string | undefined;
+            maxFileSize?: string | number | undefined;
+            maxLength?: number | undefined;
+            maximum?: number | undefined;
+            maxItems?: number | undefined;
+            minLength?: number | undefined;
+            minimum?: number | undefined;
+            minItems?: number | undefined;
+            pattern?: string | undefined;
+            required?: boolean | undefined;
+            step?: number | undefined;
+            type?: string | undefined;
+            validationExpression?: string | undefined;
+            dataRef?: string | null | undefined;
+            ':type': string;
+            label?: import("./types").Label | undefined;
+            enabled?: boolean | undefined;
+            visible?: boolean | undefined;
+            name?: string | undefined;
+            constraintMessages?: import("./types").ConstraintsMessages | undefined;
+            fieldType?: string | undefined;
+            errorMessage?: string | undefined;
+            properties?: {
+                [key: string]: any;
+            } | undefined;
+            placeholder?: string | undefined;
+            readOnly?: boolean | undefined;
+            valid?: boolean | undefined;
+            default?: any;
+            value?: any;
+            emptyValue?: "" | "undefined" | "null" | undefined;
+            id: string;
+        } | {
+            description?: string | undefined;
+            rules?: Items<string> | undefined;
+            events?: Items<string | string[] | undefined> | undefined;
+            enumNames?: string[] | undefined;
+            enum?: any[] | undefined;
+            accept?: string[] | undefined;
+            enforceEnum?: boolean | undefined;
+            exclusiveMinimum?: number | undefined;
+            exclusiveMaximum?: number | undefined;
+            format?: string | undefined;
+            maxFileSize?: string | number | undefined;
+            maxLength?: number | undefined;
+            maximum?: number | undefined;
+            maxItems?: number | undefined;
+            minLength?: number | undefined;
+            minimum?: number | undefined;
+            minItems?: number | undefined;
+            pattern?: string | undefined;
+            required?: boolean | undefined;
+            step?: number | undefined;
+            type?: "object" | "array" | undefined;
+            validationExpression?: string | undefined;
+            dataRef?: string | null | undefined;
+            ':type'?: string | undefined;
+            label?: import("./types").Label | undefined;
+            enabled?: boolean | undefined;
+            visible?: boolean | undefined;
+            name?: string | undefined;
+            constraintMessages?: import("./types").ConstraintsMessages | undefined;
+            fieldType?: string | undefined;
+            errorMessage?: string | undefined;
+            properties?: {
+                [key: string]: any;
+            } | undefined;
+            items: (FieldJson | import("./types").ContainerJson)[] & (({
+                description?: string | undefined;
+            } & import("./types").RulesJson & {
+                enumNames?: string[] | undefined;
+                enum?: any[] | undefined;
+            } & {
+                accept?: string[] | undefined;
+                enforceEnum?: boolean | undefined;
+                exclusiveMinimum?: number | undefined;
+                exclusiveMaximum?: number | undefined;
+                format?: string | undefined;
+                maxFileSize?: string | number | undefined;
+                maxLength?: number | undefined;
+                maximum?: number | undefined;
+                maxItems?: number | undefined;
+                minLength?: number | undefined;
+                minimum?: number | undefined;
+                minItems?: number | undefined;
+                pattern?: string | undefined;
+                required?: boolean | undefined;
+                step?: number | undefined;
+                type?: string | undefined;
+                validationExpression?: string | undefined;
+            } & {
+                dataRef?: string | null | undefined;
+                ':type'?: string | undefined;
+                label?: import("./types").Label | undefined;
+                enabled?: boolean | undefined;
+                visible?: boolean | undefined;
+                name?: string | undefined;
+                constraintMessages?: import("./types").ConstraintsMessages | undefined;
+                fieldType?: string | undefined;
+                errorMessage?: string | undefined;
+                properties?: {
+                    [key: string]: any;
+                } | undefined;
+            } & {
+                placeholder?: string | undefined;
+            } & {
+                readOnly?: boolean | undefined;
+                valid?: boolean | undefined;
+                default?: any;
+                value?: any;
+                emptyValue?: "" | "undefined" | "null" | undefined;
+            } & {
+                id: string;
+                ':type': string;
+            }) | ({
+                description?: string | undefined;
+            } & import("./types").RulesJson & {
+                enumNames?: string[] | undefined;
+                enum?: any[] | undefined;
+            } & {
+                accept?: string[] | undefined;
+                enforceEnum?: boolean | undefined;
+                exclusiveMinimum?: number | undefined;
+                exclusiveMaximum?: number | undefined;
+                format?: string | undefined;
+                maxFileSize?: string | number | undefined;
+                maxLength?: number | undefined;
+                maximum?: number | undefined;
+                maxItems?: number | undefined;
+                minLength?: number | undefined;
+                minimum?: number | undefined;
+                minItems?: number | undefined;
+                pattern?: string | undefined;
+                required?: boolean | undefined;
+                step?: number | undefined;
+                type?: string | undefined;
+                validationExpression?: string | undefined;
+            } & {
+                dataRef?: string | null | undefined;
+                ':type'?: string | undefined;
+                label?: import("./types").Label | undefined;
+                enabled?: boolean | undefined;
+                visible?: boolean | undefined;
+                name?: string | undefined;
+                constraintMessages?: import("./types").ConstraintsMessages | undefined;
+                fieldType?: string | undefined;
+                errorMessage?: string | undefined;
+                properties?: {
+                    [key: string]: any;
+                } | undefined;
+            } & {
+                items: (FieldJson | import("./types").ContainerJson)[];
+                initialItems?: number | undefined;
+            } & {
+                id: string;
+                items: (({
+                    description?: string | undefined;
+                } & import("./types").RulesJson & {
+                    enumNames?: string[] | undefined;
+                    enum?: any[] | undefined;
+                } & {
+                    accept?: string[] | undefined;
+                    enforceEnum?: boolean | undefined;
+                    exclusiveMinimum?: number | undefined;
+                    exclusiveMaximum?: number | undefined;
+                    format?: string | undefined;
+                    maxFileSize?: string | number | undefined;
+                    maxLength?: number | undefined;
+                    maximum?: number | undefined;
+                    maxItems?: number | undefined;
+                    minLength?: number | undefined;
+                    minimum?: number | undefined;
+                    minItems?: number | undefined;
+                    pattern?: string | undefined;
+                    required?: boolean | undefined;
+                    step?: number | undefined;
+                    type?: string | undefined;
+                    validationExpression?: string | undefined;
+                } & {
+                    dataRef?: string | null | undefined;
+                    ':type'?: string | undefined;
+                    label?: import("./types").Label | undefined;
+                    enabled?: boolean | undefined;
+                    visible?: boolean | undefined;
+                    name?: string | undefined;
+                    constraintMessages?: import("./types").ConstraintsMessages | undefined;
+                    fieldType?: string | undefined;
+                    errorMessage?: string | undefined;
+                    properties?: {
+                        [key: string]: any;
+                    } | undefined;
+                } & {
+                    placeholder?: string | undefined;
+                } & {
+                    readOnly?: boolean | undefined;
+                    valid?: boolean | undefined;
+                    default?: any;
+                    value?: any;
+                    emptyValue?: "" | "undefined" | "null" | undefined;
+                } & {
+                    id: string;
+                    ':type': string;
+                }) | ({
+                    description?: string | undefined;
+                } & import("./types").RulesJson & {
+                    enumNames?: string[] | undefined;
+                    enum?: any[] | undefined;
+                } & {
+                    accept?: string[] | undefined;
+                    enforceEnum?: boolean | undefined;
+                    exclusiveMinimum?: number | undefined;
+                    exclusiveMaximum?: number | undefined;
+                    format?: string | undefined;
+                    maxFileSize?: string | number | undefined;
+                    maxLength?: number | undefined;
+                    maximum?: number | undefined;
+                    maxItems?: number | undefined;
+                    minLength?: number | undefined;
+                    minimum?: number | undefined;
+                    minItems?: number | undefined;
+                    pattern?: string | undefined;
+                    required?: boolean | undefined;
+                    step?: number | undefined;
+                    type?: string | undefined;
+                    validationExpression?: string | undefined;
+                } & {
+                    dataRef?: string | null | undefined;
+                    ':type'?: string | undefined;
+                    label?: import("./types").Label | undefined;
+                    enabled?: boolean | undefined;
+                    visible?: boolean | undefined;
+                    name?: string | undefined;
+                    constraintMessages?: import("./types").ConstraintsMessages | undefined;
+                    fieldType?: string | undefined;
+                    errorMessage?: string | undefined;
+                    properties?: {
+                        [key: string]: any;
+                    } | undefined;
+                } & {
+                    items: (FieldJson | import("./types").ContainerJson)[];
+                    initialItems?: number | undefined;
+                } & any))[];
+            }))[];
+            initialItems?: number | undefined;
+            id: string;
+        })[];
+        id: string;
+    };
+    get type(): string;
+    isTransparent(): boolean;
+    get form(): FormModel;
+    get ruleEngine(): RuleEngine;
+    getUniqueId(): string;
+    /**
+     * @param field
+     * @private
+     */
+    fieldAdded(field: FieldModel | FieldsetModel): void;
+    validate(): import("./types").ValidationError[];
+    /**
+     * Checks if the given form is valid or not
+     * @returns `true`, if form is valid, `false` otherwise
+     */
+    isValid(): boolean;
+    /**
+     * @param field
+     * @private
+     */
+    dispatch(action: Action): void;
+    /**
+     * @param action
+     * @private
+     */
+    executeAction(action: Action): void;
+    /**
+     * @param action
+     * @param context
+     * @private
+     */
+    submit(action: Action, context: any): void;
+    getElement(id: string): FieldModel | FieldsetModel | this;
+    /**
+     * @private
+     */
+    getEventQueue(): EventQueue;
+    get name(): string;
+    get value(): null;
+    get id(): string;
+    get title(): string;
+}
+export default Form;

package/lib/Form.js

@@ -0,0 +1,247 @@
+"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.Logger = void 0;
+const Container_1 = __importDefault(require("./Container"));
+const FormMetaData_1 = __importDefault(require("./FormMetaData"));
+const Fieldset_1 = require("./Fieldset");
+const EventQueue_1 = __importDefault(require("./controller/EventQueue"));
+const FormUtils_1 = require("./utils/FormUtils");
+const DataGroup_1 = __importDefault(require("./data/DataGroup"));
+const FunctionRuntime_1 = require("./rules/FunctionRuntime");
+const controller_1 = require("./controller");
+const levels = {
+    off: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+};
+/**
+ * @private
+ */
+class Logger {
+    constructor(logLevel = 'off') {
+        this.logLevel = levels[logLevel];
+    }
+    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);
+        }
+    }
+}
+exports.Logger = Logger;
+/**
+ * Defines `form model` which implements {@link FormModel | form model}
+ */
+class Form extends Container_1.default {
+    /**
+     * @param n
+     * @param _ruleEngine
+     * @param _eventQueue
+     * @param logLevel
+     * @private
+     */
+    constructor(n, _ruleEngine, _eventQueue = new EventQueue_1.default(), logLevel = 'off') {
+        //@ts-ignore
+        super(n, {});
+        this._ruleEngine = _ruleEngine;
+        this._eventQueue = _eventQueue;
+        /**
+         * @private
+         */
+        this._fields = {};
+        /**
+         * @private
+         */
+        this._invalidFields = [];
+        this.dataRefRegex = /("[^"]+?"|[^.]+?)(?:\.|$)/g;
+        this._logger = new Logger(logLevel);
+        this.queueEvent(new controller_1.Initialize());
+        this.queueEvent(new controller_1.ExecuteRule());
+        this._ids = (0, FormUtils_1.IdGenerator)();
+        this._bindToDataModel(new DataGroup_1.default('$form', {}));
+        this._initialize();
+    }
+    get logger() {
+        return this._logger;
+    }
+    get metaData() {
+        const metaData = this._jsonModel.metadata || {};
+        return new FormMetaData_1.default(metaData);
+    }
+    get action() {
+        return this._jsonModel.action;
+    }
+    _createChild(child) {
+        return (0, Fieldset_1.createChild)(child, { form: this, parent: this });
+    }
+    importData(dataModel) {
+        this._bindToDataModel(new DataGroup_1.default('$form', dataModel));
+        this.syncDataAndFormModel(this.getDataNode());
+        this._eventQueue.runPendingQueue();
+    }
+    exportData() {
+        var _a;
+        return (_a = this.getDataNode()) === null || _a === void 0 ? void 0 : _a.$value;
+    }
+    /**
+     * Returns the current state of the form
+     *
+     * To access the form data and attachments, one needs to use the `data` and `attachments` property.
+     * For example,
+     * ```
+     * const data = form.getState().data
+     * const attachments = form.getState().attachments
+     * ```
+     */
+    getState() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const res = super.getState();
+        res.id = '$form';
+        Object.defineProperty(res, 'data', {
+            get: function () {
+                return self.exportData();
+            }
+        });
+        Object.defineProperty(res, 'attachments', {
+            get: function () {
+                return (0, FormUtils_1.getAttachments)(self);
+            }
+        });
+        return res;
+    }
+    get type() {
+        return 'object';
+    }
+    isTransparent() {
+        return false;
+    }
+    get form() {
+        return this;
+    }
+    get ruleEngine() {
+        return this._ruleEngine;
+    }
+    getUniqueId() {
+        if (this._ids == null) {
+            return '';
+        }
+        return this._ids.next().value;
+    }
+    /**
+     * @param field
+     * @private
+     */
+    fieldAdded(field) {
+        this._fields[field.id] = field;
+        field.subscribe((action) => {
+            if (this._invalidFields.indexOf(action.target.id) === -1) {
+                this._invalidFields.push(action.target.id);
+            }
+        }, 'invalid');
+        field.subscribe((action) => {
+            const index = this._invalidFields.indexOf(action.target.id);
+            if (index > -1) {
+                this._invalidFields.splice(index, 1);
+            }
+        }, 'valid');
+        field.subscribe((action) => {
+            //@ts-ignore
+            const field = action.target.getState();
+            if (field) {
+                const fieldChangedAction = new controller_1.FieldChanged(action.payload.changes, field);
+                this.dispatch(fieldChangedAction);
+            }
+        });
+    }
+    validate() {
+        const validationErrors = super.validate();
+        // trigger event on form so that user's can customize their application
+        this.dispatch(new controller_1.ValidationComplete(validationErrors));
+        return validationErrors;
+    }
+    /**
+     * Checks if the given form is valid or not
+     * @returns `true`, if form is valid, `false` otherwise
+     */
+    isValid() {
+        return this._invalidFields.length === 0;
+    }
+    /**
+     * @param field
+     * @private
+     */
+    dispatch(action) {
+        if (action.type === 'submit') {
+            super.queueEvent(action);
+            this._eventQueue.runPendingQueue();
+        }
+        else {
+            super.dispatch(action);
+        }
+    }
+    /**
+     * @param action
+     * @private
+     */
+    executeAction(action) {
+        if (action.type !== 'submit' || this._invalidFields.length === 0) {
+            super.executeAction(action);
+        }
+    }
+    /**
+     * @param action
+     * @param context
+     * @private
+     */
+    submit(action, context) {
+        // if no errors, only then submit
+        if (this.validate().length === 0) {
+            (0, FunctionRuntime_1.submit)(context, action.payload.success, action.payload.error, action.payload.submit_as, action.payload.data);
+        }
+    }
+    getElement(id) {
+        if (id == this.id) {
+            return this;
+        }
+        return this._fields[id];
+    }
+    /**
+     * @private
+     */
+    getEventQueue() {
+        return this._eventQueue;
+    }
+    get name() {
+        return '$form';
+    }
+    get value() {
+        return null;
+    }
+    get id() {
+        return '$form';
+    }
+    get title() {
+        return this._jsonModel.title || '';
+    }
+}
+exports.default = Form;

package/lib/FormInstance.d.ts

@@ -0,0 +1,26 @@
+import { LogLevel } from './Form';
+import { FormModel } from './types';
+/**
+ * Creates form instance using form model definition as per `adaptive form specification`
+ * @param formModel form model definition
+ * @param callback a callback that recieves the FormModel instance that gets executed before any event in the Form
+ * is executed
+ * @param logLevel Logging Level for the form. Setting it off will disable the logging
+ * @param fModel existing form model, this is additional optimization to prevent creation of form instance
+ * @returns {@link FormModel | form model}
+ */
+export declare const createFormInstance: (formModel: any, callback?: ((f: FormModel) => any) | undefined, logLevel?: LogLevel, fModel?: any) => FormModel;
+/**
+ * Validates Form model definition with the given data
+ * @param formModel     form model definition
+ * @param data          form data
+ * @returns `true`, if form is valid against the given form data, `false` otherwise
+ */
+export declare const validateFormInstance: (formModel: any, data: any) => boolean;
+/**
+ * Helper API to fetch form model definition from an AEM instance
+ * @param url       URL of the instance
+ * @param headers   HTTP headers to pass to the aem instance
+ * @returns promise which resolves to the form model definition
+ */
+export declare const fetchForm: (url: string, headers?: any) => Promise<string>;