@aemforms/af-core 0.22.18 → 0.22.20

package/lib/esm/Checkbox.d.ts

@@ -0,0 +1,79 @@
+import Field from './Field.js';
+declare class Checkbox extends Field {
+    private offValue;
+    _getConstraintObject(): {
+        enum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        accept: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        exclusiveMinimum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        exclusiveMaximum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        format: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxFileSize: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxLength: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maximum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        maxItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minLength: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minimum: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        minItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        pattern: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        required: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        type: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+        uniqueItems: (constraint: any, inputVal: any) => {
+            valid: boolean;
+            value: any;
+        };
+    };
+    protected _getDefaults(): {
+        enforceEnum: boolean;
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        type: string | undefined;
+    };
+    get enum(): any[];
+}
+export default Checkbox;

package/lib/esm/Checkbox.js

@@ -0,0 +1,27 @@
+import Field from './Field.js';
+import { Constraints } from './utils/ValidationUtils.js';
+const requiredConstraint = (offValue) => (constraint, value) => {
+    const valid = Constraints.required(constraint, value).valid && (!constraint || value != offValue);
+    return { valid, value };
+};
+class Checkbox extends Field {
+    offValue() {
+        const opts = this.enum;
+        return opts.length > 1 ? opts[1] : null;
+    }
+    _getConstraintObject() {
+        const baseConstraints = { ...super._getConstraintObject() };
+        baseConstraints.required = requiredConstraint(this.offValue());
+        return baseConstraints;
+    }
+    _getDefaults() {
+        return {
+            ...super._getDefaults(),
+            enforceEnum: true
+        };
+    }
+    get enum() {
+        return this._jsonModel.enum || [];
+    }
+}
+export default Checkbox;

package/lib/{CheckboxGroup.d.ts → esm/CheckboxGroup.d.ts}

@@ -1,22 +1,10 @@
-import Field from './Field';
-import { ContainerModel, FieldJson, FormModel } from './types';
-/**
- * Implementation of CheckBoxGroup runtime model which extends from {@link Field | field}
- */
+import Field from './Field.js';
+import { ContainerModel, FieldJson, FormModel } from './types/index.js';
 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;

package/lib/esm/CheckboxGroup.js

@@ -0,0 +1,23 @@
+import Field from './Field.js';
+class CheckboxGroup extends Field {
+    constructor(params, _options) {
+        super(params, _options);
+    }
+    _getFallbackType() {
+        const fallbackType = super._getFallbackType();
+        if (typeof fallbackType === 'string') {
+            return `${fallbackType}[]`;
+        }
+        else {
+            return 'string[]';
+        }
+    }
+    _getDefaults() {
+        return {
+            ...super._getDefaults(),
+            enforceEnum: true,
+            enum: []
+        };
+    }
+}
+export default CheckboxGroup;

package/lib/esm/Container.d.ts

@@ -0,0 +1,53 @@
+import { Action, BaseModel, ContainerJson, ContainerModel, FieldModel, FieldsetModel, FormModel, IFormFieldFactory, RulesJson } from './types/index.js';
+import Scriptable from './Scriptable.js';
+import DataGroup from './data/DataGroup.js';
+declare abstract class Container<T extends ContainerJson & RulesJson> extends Scriptable<T> implements ContainerModel {
+    protected _children: Array<FieldModel | FieldsetModel>;
+    protected _childrenReference: any;
+    private _itemTemplate;
+    private fieldFactory;
+    constructor(json: T, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+        fieldFactory: IFormFieldFactory;
+    });
+    ruleNodeReference(): any;
+    get items(): (FieldModel | FieldsetModel)[];
+    get maxItems(): number;
+    set maxItems(m: number);
+    get minItems(): number;
+    hasDynamicItems(): boolean;
+    get isContainer(): boolean;
+    private _activeChild;
+    getState(): T & {
+        items: any[];
+        properties: {
+            [key: string]: any;
+        };
+        index: number;
+        parent: undefined;
+        qualifiedName: any;
+        events: {};
+        rules: {};
+        repeatable: boolean | undefined;
+        ':type': string;
+        id: string;
+    };
+    private _createChild;
+    private _addChildToRuleNode;
+    private _addChild;
+    indexOf(f: FieldModel | FieldsetModel): number;
+    defaultDataModel(name: string): DataGroup | undefined;
+    _initialize(): void;
+    addItem(action: Action): void;
+    removeItem(action: Action): void;
+    queueEvent(action: Action): void;
+    reset(): void;
+    validate(): import("./types/Model.js").ValidationError[];
+    dispatch(action: Action): void;
+    importData(contextualDataModel: DataGroup): void;
+    syncDataAndFormModel(contextualDataModel?: DataGroup): void;
+    get activeChild(): BaseModel | null;
+    set activeChild(c: BaseModel | null);
+}
+export default Container;

package/lib/{Container.js → esm/Container.js}

@@ -1,44 +1,26 @@
-"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const JsonUtils_1 = require("./utils/JsonUtils");
-const Scriptable_1 = __importDefault(require("./Scriptable"));
-const controller_1 = require("./controller");
-const DataGroup_1 = __importDefault(require("./data/DataGroup"));
-const BaseNode_1 = require("./BaseNode");
-/**
- * Defines a generic container class which any form container should extend from.
- * @typeparam T type of the node which extends {@link ContainerJson} and {@link RulesJson}
- */
-class Container extends Scriptable_1.default {
-    constructor() {
-        super(...arguments);
-        this._children = [];
-        this._itemTemplate = null;
-        this._activeChild = null;
+import { deepClone } from './utils/JsonUtils.js';
+import Scriptable from './Scriptable.js';
+import { ExecuteRule, Initialize, propertyChange } from './controller/Events.js';
+import DataGroup from './data/DataGroup.js';
+import { dependencyTracked } from './BaseNode.js';
+class Container extends Scriptable {
+    _children = [];
+    _childrenReference;
+    _itemTemplate = null;
+    fieldFactory;
+    constructor(json, _options) {
+        super(json, { form: _options.form, parent: _options.parent });
+        this.fieldFactory = _options.fieldFactory;
     }
-    /**
-     * @private
-     */
     ruleNodeReference() {
         return this._childrenReference;
     }
-    //todo : this should not be public
     get items() {
         return this._children;
     }
@@ -56,46 +38,47 @@ class Container extends Scriptable_1.default {
                 this._childrenReference.pop();
             }
             const elems = this._children.splice(m, items2Remove);
-            this.notifyDependents((0, controller_1.propertyChange)('items', elems, null));
+            this.notifyDependents(propertyChange('items', elems, null));
         }
     }
     get minItems() {
         return this._jsonModel.minItems;
     }
-    /**
-     * returns whether the items in the Panel can repeat or not
-     */
     hasDynamicItems() {
         return this._itemTemplate != null;
     }
     get isContainer() {
         return true;
     }
-    /**
-     * Returns the current container state
-     */
+    _activeChild = null;
     getState() {
-        return Object.assign(Object.assign({}, super.getState()), { items: this._children.map(x => {
-                return Object.assign({}, x.getState());
-            }) });
+        return {
+            ...super.getState(),
+            items: this._children.map(x => {
+                return { ...x.getState() };
+            })
+        };
+    }
+    _createChild(child, options) {
+        const { parent = this } = options;
+        return this.fieldFactory.createField(child, {
+            form: options.form,
+            parent
+        });
     }
     _addChildToRuleNode(child, options) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
         const { parent = this } = options;
-        //the child has not been added to the array, hence using the length as new index
-        // this means unnamed panel inside repeatable named parent // this is an edge case, handling it gracefully
-        // todo: rules don't work inside repeatable array
         const name = parent.type == 'array' ? parent._children.length + '' : child.name || '';
         if (name.length > 0) {
             Object.defineProperty(parent._childrenReference, name, {
                 get: () => {
                     if (child.isContainer && child.hasDynamicItems()) {
-                        self.ruleEngine.trackDependency(child); //accessing dynamic panel directly
+                        self.ruleEngine.trackDependency(child);
                     }
                     if (self.hasDynamicItems()) {
-                        self.ruleEngine.trackDependency(self); //accessing a child of dynamic panel
-                        if (this._children[name] !== undefined) { // pop function calls this getter in order to return the item
+                        self.ruleEngine.trackDependency(self);
+                        if (this._children[name] !== undefined) {
                             return this._children[name].getRuleNode();
                         }
                     }
@@ -109,26 +92,25 @@ class Container extends Scriptable_1.default {
         }
     }
     _addChild(itemJson, index, cloneIds = false) {
-        // get first non transparent parent
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let nonTransparentParent = this;
         while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
-            // @ts-ignore
             nonTransparentParent = nonTransparentParent.parent;
         }
         if (typeof index !== 'number' || index > nonTransparentParent._children.length) {
             index = this._children.length;
         }
         const form = this.form;
-        const itemTemplate = Object.assign({ index }, (0, JsonUtils_1.deepClone)(itemJson, cloneIds ? () => { return form.getUniqueId(); } : undefined));
-        //@ts-ignore
-        const retVal = this._createChild(itemTemplate, { parent: this, index });
+        const itemTemplate = {
+            index,
+            ...deepClone(itemJson, cloneIds ? () => { return form.getUniqueId(); } : undefined)
+        };
+        const retVal = this._createChild(itemTemplate, { parent: this, form: this.form });
+        this.form.fieldAdded(retVal);
         this._addChildToRuleNode(retVal, { parent: nonTransparentParent });
         if (index === this._children.length) {
             this._children.push(retVal);
         }
         else {
-            // @ts-ignore
             this._children.splice(index, 0, retVal);
         }
         return retVal;
@@ -136,9 +118,6 @@ class Container extends Scriptable_1.default {
     indexOf(f) {
         return this._children.indexOf(f);
     }
-    /**
-     * @private
-     */
     defaultDataModel(name) {
         const type = this._jsonModel.type || undefined;
         if (type === undefined) {
@@ -146,19 +125,16 @@ class Container extends Scriptable_1.default {
         }
         else {
             const instance = type === 'array' ? [] : {};
-            return new DataGroup_1.default(name, instance, type);
+            return new DataGroup(name, instance, type);
         }
     }
-    /**
-     * @private
-     */
     _initialize() {
         super._initialize();
         const items = this._jsonModel.items || [];
         this._jsonModel.items = [];
         this._childrenReference = this._jsonModel.type == 'array' ? [] : {};
         if (this._jsonModel.type == 'array' && items.length === 1 && this.getDataNode() != null) {
-            this._itemTemplate = (0, JsonUtils_1.deepClone)(items[0]);
+            this._itemTemplate = deepClone(items[0]);
             if (typeof (this._jsonModel.minItems) !== 'number') {
                 this._jsonModel.minItems = 0;
             }
@@ -169,7 +145,6 @@ class Container extends Scriptable_1.default {
                 this._jsonModel.initialItems = Math.max(1, this._jsonModel.minItems);
             }
             for (let i = 0; i < this._jsonModel.initialItems; i++) {
-                //@ts-ignore
                 const child = this._addChild(this._itemTemplate);
                 child._initialize();
             }
@@ -188,106 +163,83 @@ class Container extends Scriptable_1.default {
         }
         this.setupRuleNode();
     }
-    /**
-     * @private
-     */
     addItem(action) {
-        if (action.type === 'addItem' && this._itemTemplate != null) {
-            //@ts-ignore
+        if ((action.type === 'addItem' || action.type == 'addInstance') && this._itemTemplate != null) {
             if ((this._jsonModel.maxItems === -1) || (this._children.length < this._jsonModel.maxItems)) {
                 const dataNode = this.getDataNode();
-                let index = action.payload;
-                if (typeof index !== 'number' || index > this._children.length) {
-                    index = this._children.length;
-                }
+                let instanceIndex = action.payload;
                 const retVal = this._addChild(this._itemTemplate, action.payload, true);
-                const _data = retVal.defaultDataModel(index);
+                if (typeof instanceIndex !== 'number' || instanceIndex > this._children.length) {
+                    instanceIndex = this._children.length;
+                }
+                const _data = retVal.defaultDataModel(instanceIndex);
                 if (_data) {
-                    dataNode.$addDataNode(index, _data);
+                    dataNode.$addDataNode(instanceIndex, _data);
                 }
                 retVal._initialize();
-                this.notifyDependents((0, controller_1.propertyChange)('items', retVal.getState(), null));
-                retVal.dispatch(new controller_1.Initialize());
-                retVal.dispatch(new controller_1.ExecuteRule());
-                for (let i = index + 1; i < this._children.length; i++) {
-                    this._children[i].dispatch(new controller_1.ExecuteRule());
+                this.notifyDependents(propertyChange('items', retVal.getState(), null));
+                retVal.dispatch(new Initialize());
+                retVal.dispatch(new ExecuteRule());
+                for (let i = instanceIndex + 1; i < this._children.length; i++) {
+                    this._children[i].dispatch(new ExecuteRule());
                 }
             }
         }
     }
-    /**
-     * @private
-     */
     removeItem(action) {
-        if (action.type === 'removeItem' && this._itemTemplate != null) {
+        if ((action.type === 'removeItem' || action.type == 'removeInstance') && this._itemTemplate != null) {
             if (this._children.length == 0) {
-                //can't remove item if there isn't any
                 return;
             }
-            const index = typeof action.payload === 'number' ? action.payload : this._children.length - 1;
-            const state = this._children[index].getState();
-            //@ts-ignore
+            let instanceIndex = action.payload;
+            if (typeof instanceIndex !== 'number') {
+                instanceIndex = this._children.length - 1;
+            }
+            const state = this._children[instanceIndex].getState();
             if (this._children.length > this._jsonModel.minItems) {
-                // clear child
-                //remove field
                 this._childrenReference.pop();
-                this._children.splice(index, 1);
-                this.getDataNode().$removeDataNode(index);
-                for (let i = index; i < this._children.length; i++) {
-                    this._children[i].dispatch(new controller_1.ExecuteRule());
+                this._children.splice(instanceIndex, 1);
+                this.getDataNode().$removeDataNode(instanceIndex);
+                for (let i = instanceIndex; i < this._children.length; i++) {
+                    this._children[i].dispatch(new ExecuteRule());
                 }
-                this.notifyDependents((0, controller_1.propertyChange)('items', null, state));
+                this.notifyDependents(propertyChange('items', null, state));
             }
         }
     }
-    /**
-     * @private
-     */
     queueEvent(action) {
-        var _a;
         super.queueEvent(action);
-        if ((_a = action.metadata) === null || _a === void 0 ? void 0 : _a.dispatch) {
+        if (action.metadata?.dispatch) {
             this.items.forEach(x => {
-                //@ts-ignore
                 x.queueEvent(action);
             });
         }
     }
+    reset() {
+        this.items.forEach(x => {
+            x.reset();
+        });
+    }
     validate() {
         return this.items.flatMap(x => {
             return x.validate();
         }).filter(x => x.fieldName !== '');
     }
-    /**
-     * @private
-     */
     dispatch(action) {
         super.dispatch(action);
     }
-    /**
-     * @private
-     */
     importData(contextualDataModel) {
         this._bindToDataModel(contextualDataModel);
         const dataNode = this.getDataNode() || contextualDataModel;
         this.syncDataAndFormModel(dataNode);
     }
-    /**
-     * prefill the form with data on the given element
-     * @param dataModel
-     * @param contextualDataModel
-     * @param operation
-     * @private
-     */
     syncDataAndFormModel(contextualDataModel) {
-        if ((contextualDataModel === null || contextualDataModel === void 0 ? void 0 : contextualDataModel.$type) === 'array' && this._itemTemplate != null) {
-            const dataLength = contextualDataModel === null || contextualDataModel === void 0 ? void 0 : contextualDataModel.$value.length;
+        if (contextualDataModel?.$type === 'array' && this._itemTemplate != null) {
+            const dataLength = contextualDataModel?.$value.length;
             const itemsLength = this._children.length;
             const maxItems = this._jsonModel.maxItems === -1 ? dataLength : this._jsonModel.maxItems;
             const minItems = this._jsonModel.minItems;
-            //@ts-ignore
             let items2Add = Math.min(dataLength - itemsLength, maxItems - itemsLength);
-            //@ts-ignore
             const items2Remove = Math.min(itemsLength - dataLength, itemsLength - minItems);
             while (items2Add > 0) {
                 items2Add--;
@@ -316,23 +268,23 @@ class Container extends Scriptable_1.default {
                 activeChild.activeChild = null;
                 activeChild = temp;
             }
-            const change = (0, controller_1.propertyChange)('activeChild', c, this._activeChild);
+            const change = propertyChange('activeChild', c, this._activeChild);
             this._activeChild = c;
             if (this.parent && c !== null) {
                 this.parent.activeChild = this;
             }
-            this._jsonModel.activeChild = c === null || c === void 0 ? void 0 : c.id;
+            this._jsonModel.activeChild = c?.id;
             this.notifyDependents(change);
         }
     }
 }
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Container.prototype, "maxItems", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Container.prototype, "minItems", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Container.prototype, "activeChild", null);
-exports.default = Container;
+export default Container;

package/lib/{DateField.d.ts → esm/DateField.d.ts}

@@ -1,4 +1,4 @@
-import Field from './Field';
+import Field from './Field.js';
 declare class DateField extends Field {
     protected _applyDefaults(): void;
 }

package/lib/esm/DateField.js

@@ -0,0 +1,21 @@
+import Field from './Field.js';
+import { formatDate, parseDateSkeleton } from '@aemforms/af-formatters';
+class DateField extends Field {
+    _applyDefaults() {
+        super._applyDefaults();
+        const locale = new Intl.DateTimeFormat().resolvedOptions().locale;
+        if (!this._jsonModel.editFormat) {
+            this._jsonModel.editFormat = 'short';
+        }
+        if (!this._jsonModel.displayFormat) {
+            this._jsonModel.displayFormat = this._jsonModel.editFormat;
+        }
+        if (!this._jsonModel.placeholder) {
+            this._jsonModel.placeholder = parseDateSkeleton(this._jsonModel.editFormat, locale);
+        }
+        if (!this._jsonModel.description) {
+            this._jsonModel.description = `To enter today's date use ${formatDate(new Date(), locale, this._jsonModel.editFormat)}`;
+        }
+    }
+}
+export default DateField;