@aemforms/af-core 0.22.25 → 0.22.26

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/esm/Container.js

@@ -0,0 +1,290 @@
+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;
+};
+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;
+    }
+    ruleNodeReference() {
+        return this._childrenReference;
+    }
+    get items() {
+        return this._children;
+    }
+    get maxItems() {
+        return this._jsonModel.maxItems;
+    }
+    set maxItems(m) {
+        this._jsonModel.maxItems = m;
+        const minItems = this._jsonModel.minItems || 1;
+        const itemsLength = this._children.length;
+        const items2Remove = Math.min(itemsLength - m, itemsLength - minItems);
+        if (items2Remove > 0) {
+            for (let i = 0; i < items2Remove; i++) {
+                this.getDataNode().$removeDataNode(m + i);
+                this._childrenReference.pop();
+            }
+            const elems = this._children.splice(m, items2Remove);
+            this.notifyDependents(propertyChange('items', elems, null));
+        }
+    }
+    get minItems() {
+        return this._jsonModel.minItems;
+    }
+    hasDynamicItems() {
+        return this._itemTemplate != null;
+    }
+    get isContainer() {
+        return true;
+    }
+    _activeChild = null;
+    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) {
+        const self = this;
+        const { parent = this } = options;
+        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);
+                    }
+                    if (self.hasDynamicItems()) {
+                        self.ruleEngine.trackDependency(self);
+                        if (this._children[name] !== undefined) {
+                            return this._children[name].getRuleNode();
+                        }
+                    }
+                    else {
+                        return child.getRuleNode();
+                    }
+                },
+                configurable: true,
+                enumerable: true
+            });
+        }
+    }
+    _addChild(itemJson, index, cloneIds = false) {
+        let nonTransparentParent = this;
+        while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
+            nonTransparentParent = nonTransparentParent.parent;
+        }
+        if (typeof index !== 'number' || index > nonTransparentParent._children.length) {
+            index = this._children.length;
+        }
+        const form = this.form;
+        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 {
+            this._children.splice(index, 0, retVal);
+        }
+        return retVal;
+    }
+    indexOf(f) {
+        return this._children.indexOf(f);
+    }
+    defaultDataModel(name) {
+        const type = this._jsonModel.type || undefined;
+        if (type === undefined) {
+            return undefined;
+        }
+        else {
+            const instance = type === 'array' ? [] : {};
+            return new DataGroup(name, instance, type);
+        }
+    }
+    _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 = deepClone(items[0]);
+            if (typeof (this._jsonModel.minItems) !== 'number') {
+                this._jsonModel.minItems = 0;
+            }
+            if (typeof (this._jsonModel.maxItems) !== 'number') {
+                this._jsonModel.maxItems = -1;
+            }
+            if (typeof (this._jsonModel.initialItems) !== 'number') {
+                this._jsonModel.initialItems = Math.max(1, this._jsonModel.minItems);
+            }
+            for (let i = 0; i < this._jsonModel.initialItems; i++) {
+                const child = this._addChild(this._itemTemplate);
+                child._initialize();
+            }
+        }
+        else if (items.length > 0) {
+            items.forEach((item) => {
+                const child = this._addChild(item);
+                child._initialize();
+            });
+            this._jsonModel.minItems = this._children.length;
+            this._jsonModel.maxItems = this._children.length;
+            this._jsonModel.initialItems = this._children.length;
+        }
+        else {
+            this.form.logger.warn('A container exists with no items.');
+        }
+        this.setupRuleNode();
+    }
+    addItem(action) {
+        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 instanceIndex = action.payload;
+                const retVal = this._addChild(this._itemTemplate, action.payload, true);
+                if (typeof instanceIndex !== 'number' || instanceIndex > this._children.length) {
+                    instanceIndex = this._children.length;
+                }
+                const _data = retVal.defaultDataModel(instanceIndex);
+                if (_data) {
+                    dataNode.$addDataNode(instanceIndex, _data);
+                }
+                retVal._initialize();
+                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());
+                }
+            }
+        }
+    }
+    removeItem(action) {
+        if ((action.type === 'removeItem' || action.type == 'removeInstance') && this._itemTemplate != null) {
+            if (this._children.length == 0) {
+                return;
+            }
+            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) {
+                this._childrenReference.pop();
+                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(propertyChange('items', null, state));
+            }
+        }
+    }
+    queueEvent(action) {
+        super.queueEvent(action);
+        if (action.metadata?.dispatch) {
+            this.items.forEach(x => {
+                x.queueEvent(action);
+            });
+        }
+    }
+    reset() {
+        this.items.forEach(x => {
+            x.reset();
+        });
+    }
+    validate() {
+        return this.items.flatMap(x => {
+            return x.validate();
+        }).filter(x => x.fieldName !== '');
+    }
+    dispatch(action) {
+        super.dispatch(action);
+    }
+    importData(contextualDataModel) {
+        this._bindToDataModel(contextualDataModel);
+        const dataNode = this.getDataNode() || contextualDataModel;
+        this.syncDataAndFormModel(dataNode);
+    }
+    syncDataAndFormModel(contextualDataModel) {
+        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;
+            let items2Add = Math.min(dataLength - itemsLength, maxItems - itemsLength);
+            const items2Remove = Math.min(itemsLength - dataLength, itemsLength - minItems);
+            while (items2Add > 0) {
+                items2Add--;
+                const child = this._addChild(this._itemTemplate);
+                child._initialize();
+            }
+            if (items2Remove > 0) {
+                this._children.splice(dataLength, items2Remove);
+                for (let i = 0; i < items2Remove; i++) {
+                    this._childrenReference.pop();
+                }
+            }
+        }
+        this._children.forEach(x => {
+            x.importData(contextualDataModel);
+        });
+    }
+    get activeChild() {
+        return this._activeChild;
+    }
+    set activeChild(c) {
+        if (c !== this._activeChild) {
+            let activeChild = this._activeChild;
+            while (activeChild instanceof Container) {
+                const temp = activeChild.activeChild;
+                activeChild.activeChild = null;
+                activeChild = temp;
+            }
+            const change = propertyChange('activeChild', c, this._activeChild);
+            this._activeChild = c;
+            if (this.parent && c !== null) {
+                this.parent.activeChild = this;
+            }
+            this._jsonModel.activeChild = c?.id;
+            this.notifyDependents(change);
+        }
+    }
+}
+__decorate([
+    dependencyTracked()
+], Container.prototype, "maxItems", null);
+__decorate([
+    dependencyTracked()
+], Container.prototype, "minItems", null);
+__decorate([
+    dependencyTracked()
+], Container.prototype, "activeChild", null);
+export default Container;

package/lib/esm/DateField.d.ts

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

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;

package/lib/esm/Field.d.ts

@@ -0,0 +1,206 @@
+import { ConstraintsMessages, ContainerModel, FieldJson, FieldModel, FormModel, ValidationError } from './types/index.js';
+import Scriptable from './Scriptable.js';
+import DataValue from './data/DataValue.js';
+import DataGroup from './data/DataGroup.js';
+declare class Field extends Scriptable<FieldJson> implements FieldModel {
+    constructor(params: FieldJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    private _ruleNodeReference;
+    _initialize(): any;
+    ruleNodeReference(): any;
+    protected _getDefaults(): {
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        type: string | undefined;
+    };
+    protected _getFallbackType(): string | undefined;
+    protected _applyDefaults(): void;
+    private unset;
+    private coerceParam;
+    get editFormat(): string | undefined;
+    get displayFormat(): string | undefined;
+    get placeholder(): string | undefined;
+    get readOnly(): boolean | undefined;
+    set readOnly(e: boolean | undefined);
+    get enabled(): boolean | undefined;
+    set enabled(e: boolean | undefined);
+    get valid(): boolean | undefined;
+    get emptyValue(): "" | null | undefined;
+    get enum(): any[] | undefined;
+    set enum(e: any[] | undefined);
+    get enumNames(): string[] | undefined;
+    set enumNames(e: string[] | undefined);
+    get required(): boolean;
+    set required(r: boolean);
+    get maximum(): number | undefined;
+    set maximum(m: number | undefined);
+    get minimum(): number | undefined;
+    set minimum(m: number | undefined);
+    private isEmpty;
+    private withCategory;
+    get editValue(): any;
+    get displayValue(): any;
+    protected getDataNodeValue(typedValue: any): any;
+    private updateDataNodeAndTypedValue;
+    get value(): any;
+    set value(v: any);
+    reset(): void;
+    protected _updateRuleNodeReference(value: any): void;
+    protected getInternalType(): string | undefined;
+    valueOf(): any;
+    toString(): any;
+    getErrorMessage(constraint: keyof (ConstraintsMessages)): string;
+    get errorMessage(): string | undefined;
+    get screenReaderText(): string | undefined;
+    _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;
+        };
+    };
+    private isArrayType;
+    private checkEnum;
+    private checkStep;
+    private checkValidationExpression;
+    private getConstraints;
+    get format(): string | undefined;
+    get enforceEnum(): boolean | undefined;
+    get tooltip(): string | undefined;
+    get maxLength(): number | undefined;
+    get minLength(): number | undefined;
+    get pattern(): string | undefined;
+    get step(): number | undefined;
+    get exclusiveMinimum(): number | undefined;
+    set exclusiveMinimum(eM: number | undefined);
+    get exclusiveMaximum(): number | undefined;
+    set exclusiveMaximum(eM: number | undefined);
+    get default(): any;
+    private isNotEmpty;
+    protected evaluateConstraints(): any;
+    triggerValidationEvent(changes: any): void;
+    validate(): ValidationError[];
+    importData(contextualDataModel: DataGroup): void;
+    defaultDataModel(name: string | number): DataValue;
+    getState(): {
+        editValue: any;
+        displayValue: any;
+        description?: string | undefined;
+        rules: import("./types/Json.js").Items<string> & {};
+        events: import("./types/Json.js").Items<string | string[] | 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;
+        minOccur?: number | undefined;
+        maxOccur?: 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;
+        uniqueItems?: boolean | undefined;
+        dataRef?: string | null | undefined;
+        ':type': string;
+        label?: import("./types/Json.js").Label | undefined;
+        enabled?: boolean | undefined;
+        visible?: boolean | undefined;
+        name?: string | undefined;
+        constraintMessages?: ConstraintsMessages | undefined;
+        fieldType?: string | undefined;
+        errorMessage?: string | undefined;
+        properties: {
+            [key: string]: any;
+        };
+        repeatable: boolean | undefined;
+        screenReaderText?: string | undefined;
+        tooltip?: string | undefined;
+        altText?: string | undefined;
+        viewType?: string | undefined;
+        placeholder?: string | undefined;
+        readOnly?: boolean | undefined;
+        valid?: boolean | undefined;
+        default?: any;
+        value?: any;
+        displayFormat?: string | undefined;
+        editFormat?: string | undefined;
+        emptyValue?: "" | "undefined" | "null" | undefined;
+        index: number;
+        parent: undefined;
+        qualifiedName: any;
+        id: string;
+    };
+}
+export default Field;