@aemforms/af-core 0.22.25 → 0.22.26

package/lib/esm/BaseNode.d.ts

@@ -0,0 +1,93 @@
+import { Action, BaseJson, BaseModel, callbackFn, ContainerModel, FormModel, Primitives, ValidationError } from './types/index.js';
+import DataGroup from './data/DataGroup.js';
+import DataValue from './data/DataValue.js';
+export declare const editableProperties: string[];
+export declare const dynamicProps: string[];
+export declare const staticFields: string[];
+export declare const target: unique symbol;
+export declare const qualifiedName: unique symbol;
+export declare function dependencyTracked(): (target: BaseNode<any>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare const include: (...fieldTypes: string[]) => (target: BaseNode<any>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare const exclude: (...fieldTypes: string[]) => (target: BaseNode<any>, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare abstract class BaseNode<T extends BaseJson> implements BaseModel {
+    private _options;
+    private _ruleNode;
+    private _lang?;
+    private _callbacks;
+    private _dependents;
+    protected _jsonModel: T & {
+        id: string;
+    };
+    private _tokens;
+    get isContainer(): boolean;
+    constructor(params: T, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    abstract value: Primitives;
+    abstract reset(): any;
+    protected setupRuleNode(): void;
+    ruleNodeReference(): this;
+    getRuleNode(): any;
+    private getFromRule;
+    get id(): string;
+    get index(): number;
+    get parent(): ContainerModel;
+    get type(): string | undefined;
+    get repeatable(): any;
+    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.js").default;
+    get label(): import("./types/Json.js").Label | undefined;
+    set label(l: import("./types/Json.js").Label | undefined);
+    get uniqueItems(): boolean | undefined;
+    isTransparent(): boolean;
+    getState(): T & {
+        properties: {
+            [key: string]: any;
+        };
+        index: number;
+        parent: undefined;
+        qualifiedName: any;
+        events: {};
+        rules: {};
+        repeatable: boolean | undefined;
+        ':type': string;
+        id: string;
+    };
+    subscribe(callback: callbackFn, eventName?: string): {
+        unsubscribe: () => void;
+    };
+    _addDependent(dependent: BaseModel): void;
+    removeDependent(dependent: BaseModel): void;
+    abstract validate(): Array<ValidationError>;
+    abstract executeAction(action: Action): any;
+    queueEvent(action: Action): void;
+    dispatch(action: Action): void;
+    notifyDependents(action: Action): void;
+    _setProperty<T>(prop: string, newValue: T, notify?: boolean): any;
+    _bindToDataModel(contextualDataModel: DataGroup): void;
+    private _data?;
+    getDataNode(): DataValue | undefined;
+    get language(): string | undefined;
+    get properties(): {
+        [key: string]: any;
+    };
+    set properties(p: {
+        [key: string]: any;
+    });
+    abstract defaultDataModel(name: string | number): DataValue | undefined;
+    abstract importData(a: DataGroup): any;
+    getNonTransparentParent(): ContainerModel;
+    _initialize(): void;
+    protected _applyUpdates(propNames: string[], updates: any): any;
+    get qualifiedName(): any;
+    focus(): void;
+}

package/lib/esm/BaseNode.js

@@ -0,0 +1,454 @@
+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 { ExecuteRule, propertyChange } from './controller/Events.js';
+import { resolveData, TOK_GLOBAL, tokenize } from './utils/DataRefParser.js';
+import NullDataValue from './data/EmptyDataValue.js';
+export const editableProperties = [
+    'value',
+    'label',
+    'description',
+    'visible',
+    'enabled',
+    'readOnly',
+    'enum',
+    'enumNames',
+    'required',
+    'properties',
+    'exclusiveMinimum',
+    'exclusiveMaximum',
+    'maximum',
+    'maxItems',
+    'minimum',
+    'minItems'
+];
+export const dynamicProps = [
+    ...editableProperties,
+    'valid',
+    'index',
+    'activeChild'
+];
+export const staticFields = ['plain-text', 'image'];
+class ActionImplWithTarget {
+    _action;
+    _target;
+    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();
+    }
+}
+export const target = Symbol('target');
+export const qualifiedName = Symbol('qualifiedName');
+export function dependencyTracked() {
+    return function (target, propertyKey, descriptor) {
+        const get = descriptor.get;
+        if (get != undefined) {
+            descriptor.get = function () {
+                this.ruleEngine.trackDependency(this);
+                return get.call(this);
+            };
+        }
+    };
+}
+const addOnly = (includeOrExclude) => (...fieldTypes) => (target, propertyKey, descriptor) => {
+    const get = descriptor.get;
+    if (get != undefined) {
+        descriptor.get = function () {
+            if (fieldTypes.indexOf(this.fieldType) > -1 === includeOrExclude) {
+                return get.call(this);
+            }
+            return undefined;
+        };
+    }
+    const set = descriptor.set;
+    if (set != undefined) {
+        descriptor.set = function (value) {
+            if (fieldTypes.indexOf(this.fieldType) > -1 === includeOrExclude) {
+                set.call(this, value);
+            }
+        };
+    }
+};
+export const include = addOnly(true);
+export const exclude = addOnly(false);
+export class BaseNode {
+    _options;
+    _ruleNode;
+    _lang = '';
+    _callbacks = {};
+    _dependents = [];
+    _jsonModel;
+    _tokens = [];
+    get isContainer() {
+        return false;
+    }
+    constructor(params, _options) {
+        this._options = _options;
+        this[qualifiedName] = null;
+        this._jsonModel = {
+            ...params,
+            id: 'id' in params ? params.id : this.form.getUniqueId()
+        };
+    }
+    setupRuleNode() {
+        const self = this;
+        this._ruleNode = new Proxy(this.ruleNodeReference(), {
+            get: (ruleNodeReference, prop) => {
+                return self.getFromRule(ruleNodeReference, prop);
+            }
+        });
+    }
+    ruleNodeReference() {
+        return this;
+    }
+    getRuleNode() {
+        return this._ruleNode;
+    }
+    getFromRule(ruleNodeReference, prop) {
+        if (prop === Symbol.toPrimitive || (prop === 'valueOf' && !ruleNodeReference.hasOwnProperty('valueOf'))) {
+            return this.valueOf;
+        }
+        else if (prop === target) {
+            return this;
+        }
+        else if (typeof (prop) === 'string') {
+            if (prop.startsWith('$')) {
+                prop = prop.substr(1);
+                if (typeof this[prop] !== 'function') {
+                    const retValue = this[prop];
+                    if (retValue instanceof BaseNode) {
+                        return retValue.getRuleNode();
+                    }
+                    else if (retValue instanceof Array) {
+                        return retValue.map(r => r instanceof BaseNode ? r.getRuleNode() : r);
+                    }
+                    else {
+                        return retValue;
+                    }
+                }
+            }
+            else {
+                if (ruleNodeReference.hasOwnProperty(prop)) {
+                    return ruleNodeReference[prop];
+                }
+                else if (typeof ruleNodeReference[prop] === 'function') {
+                    return ruleNodeReference[prop];
+                }
+            }
+        }
+    }
+    get id() {
+        return this._jsonModel.id;
+    }
+    get index() {
+        if (this.parent) {
+            return this.parent.indexOf(this);
+        }
+        return 0;
+    }
+    get parent() {
+        return this._options.parent;
+    }
+    get type() {
+        return this._jsonModel.type;
+    }
+    get repeatable() {
+        return this.parent?.hasDynamicItems();
+    }
+    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 = 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 = propertyChange('label', l, this._jsonModel.label);
+            this._jsonModel = {
+                ...this._jsonModel,
+                label: l
+            };
+            this.notifyDependents(changeAction);
+        }
+    }
+    get uniqueItems() {
+        return this._jsonModel.uniqueItems;
+    }
+    isTransparent() {
+        const isNonTransparent = this.parent?._jsonModel.type === 'array';
+        return !this._jsonModel.name && !isNonTransparent;
+    }
+    getState() {
+        return {
+            ...this._jsonModel,
+            properties: this.properties,
+            index: this.index,
+            parent: undefined,
+            qualifiedName: this.qualifiedName,
+            events: {},
+            rules: {},
+            repeatable: this.repeatable === true ? true : undefined,
+            ':type': this[':type']
+        };
+    }
+    subscribe(callback, eventName = 'change') {
+        this._callbacks[eventName] = this._callbacks[eventName] || [];
+        this._callbacks[eventName].push(callback);
+        return {
+            unsubscribe: () => {
+                this._callbacks[eventName] = this._callbacks[eventName].filter(x => x !== callback);
+            }
+        };
+    }
+    _addDependent(dependent) {
+        if (this._dependents.find(({ node }) => node === dependent) === undefined) {
+            const subscription = this.subscribe((change) => {
+                const changes = change.payload.changes;
+                const propsToLook = [...dynamicProps, 'items'];
+                const isPropChanged = changes.findIndex(x => {
+                    return propsToLook.indexOf(x.propertyName) > -1;
+                }) > -1;
+                if (isPropChanged) {
+                    dependent.dispatch(new ExecuteRule());
+                }
+            });
+            this._dependents.push({ node: dependent, subscription });
+        }
+    }
+    removeDependent(dependent) {
+        const index = this._dependents.findIndex(({ node }) => node === dependent);
+        if (index > -1) {
+            this._dependents[index].subscription.unsubscribe();
+            this._dependents.splice(index, 1);
+        }
+    }
+    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();
+    }
+    notifyDependents(action) {
+        const handlers = this._callbacks[action.type] || [];
+        handlers.forEach(x => {
+            x(new ActionImplWithTarget(action, this));
+        });
+    }
+    _setProperty(prop, newValue, notify = true) {
+        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 {
+            isValueSame = oldValue === newValue;
+        }
+        if (!isValueSame) {
+            this._jsonModel[prop] = newValue;
+            const changeAction = propertyChange(prop, newValue, oldValue);
+            if (notify) {
+                this.notifyDependents(changeAction);
+            }
+            return changeAction.payload.changes;
+        }
+        return [];
+    }
+    _bindToDataModel(contextualDataModel) {
+        if (this.id === '$form') {
+            this._data = contextualDataModel;
+            return;
+        }
+        const dataRef = this._jsonModel.dataRef;
+        let _data, _parent = contextualDataModel, _key = '';
+        if (dataRef === null) {
+            _data = NullDataValue;
+        }
+        else if (dataRef !== undefined) {
+            if (this._tokens.length === 0) {
+                this._tokens = tokenize(dataRef);
+            }
+            let searchData = contextualDataModel;
+            if (this._tokens[0].type === 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 = resolveData(searchData, this._tokens, create);
+                _parent = resolveData(searchData, this._tokens.slice(0, -1));
+                _key = name;
+            }
+        }
+        else {
+            if (contextualDataModel !== NullDataValue && staticFields.indexOf(this.fieldType) === -1) {
+                _parent = contextualDataModel;
+                const name = this._jsonModel.name || '';
+                const key = contextualDataModel.$type === 'array' ? this.index : name;
+                _key = key;
+                if (key !== '') {
+                    const create = this.defaultDataModel(key);
+                    if (create !== undefined) {
+                        _data = contextualDataModel.$getDataNode(key);
+                        if (_data === undefined) {
+                            _data = create;
+                            contextualDataModel.$addDataNode(key, _data);
+                        }
+                    }
+                }
+                else {
+                    _data = undefined;
+                }
+            }
+        }
+        if (_data) {
+            if (!this.isContainer && _parent !== NullDataValue && _data !== NullDataValue) {
+                _data = _data?.$convertToDataValue();
+                _parent.$addDataNode(_key, _data, true);
+            }
+            _data?.$bindToField(this);
+            this._data = _data;
+        }
+    }
+    _data;
+    getDataNode() {
+        return this._data;
+    }
+    get language() {
+        if (!this._lang) {
+            if (this.parent) {
+                this._lang = this.parent.language;
+            }
+            else {
+                this._lang = Intl.DateTimeFormat().resolvedOptions().locale;
+            }
+        }
+        return this._lang;
+    }
+    get properties() {
+        return this._jsonModel.properties || {};
+    }
+    set properties(p) {
+        this._setProperty('properties', { ...p });
+    }
+    getNonTransparentParent() {
+        let nonTransparentParent = this.parent;
+        while (nonTransparentParent != null && nonTransparentParent.isTransparent()) {
+            nonTransparentParent = nonTransparentParent.parent;
+        }
+        return nonTransparentParent;
+    }
+    _initialize() {
+        if (typeof this._data === 'undefined') {
+            let dataNode, parent = this.parent;
+            do {
+                dataNode = parent.getDataNode();
+                parent = parent.parent;
+            } while (dataNode === undefined);
+            this._bindToDataModel(dataNode);
+        }
+    }
+    _applyUpdates(propNames, updates) {
+        return propNames.reduce((acc, propertyName) => {
+            const currentValue = updates[propertyName];
+            const changes = this._setProperty(propertyName, currentValue, false);
+            if (changes.length > 0) {
+                acc[propertyName] = changes[0];
+            }
+            return acc;
+        }, {});
+    }
+    get qualifiedName() {
+        if (this.isTransparent()) {
+            return null;
+        }
+        if (this[qualifiedName] !== null) {
+            return this[qualifiedName];
+        }
+        const parent = this.getNonTransparentParent();
+        if (parent && parent.type === 'array') {
+            this[qualifiedName] = `${parent.qualifiedName}[${this.index}]`;
+        }
+        else {
+            this[qualifiedName] = `${parent.qualifiedName}.${this.name}`;
+        }
+        return this[qualifiedName];
+    }
+    focus() {
+        if (this.parent) {
+            this.parent.activeChild = this;
+        }
+    }
+}
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "index", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "description", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "visible", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "label", null);
+__decorate([
+    dependencyTracked()
+], BaseNode.prototype, "properties", null);

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/esm/CheckboxGroup.d.ts

@@ -0,0 +1,18 @@
+import Field from './Field.js';
+import { ContainerModel, FieldJson, FormModel } from './types/index.js';
+declare class CheckboxGroup extends Field {
+    constructor(params: FieldJson, _options: {
+        form: FormModel;
+        parent: ContainerModel;
+    });
+    protected _getFallbackType(): string | undefined;
+    protected _getDefaults(): {
+        enforceEnum: boolean;
+        enum: never[];
+        readOnly: boolean;
+        enabled: boolean;
+        visible: boolean;
+        type: string | undefined;
+    };
+}
+export default CheckboxGroup;

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;