@aemforms/af-core 0.22.23 → 0.22.25

package/lib/esm/Field.js

@@ -1,692 +0,0 @@
-/*************************************************************************
-* ADOBE CONFIDENTIAL
-* ___________________
-*
-* Copyright 2022 Adobe
-* All Rights Reserved.
-*
-* NOTICE: All information contained herein is, and remains
-* the property of Adobe and its suppliers, if any. The intellectual
-* and technical concepts contained herein are proprietary to Adobe
-* and its suppliers and are protected by all applicable intellectual
-* property laws, including trade secret and copyright laws.
-* Dissemination of this information or reproduction of this material
-* is strictly forbidden unless prior written permission is obtained
-* from Adobe.
-
-* Adobe permits you to use and modify this file solely in accordance with
-* the terms of the Adobe license agreement accompanying it.
-*************************************************************************/
-
-import { _ as __decorate, s as staticFields, t as target, d as dependencyTracked, e as exclude, i as include } from './BaseNode-dc59ab07.js';
-import { ValidationError } from './types/Model.js';
-import { Constraints, coerceType, ValidConstraints } from './utils/ValidationUtils.js';
-import { Initialize, ExecuteRule, Change, Valid, Invalid, propertyChange } from './controller/Events.js';
-import Scriptable from './Scriptable.js';
-import { defaultFieldTypes } from './utils/SchemaUtils.js';
-import DataValue from './data/DataValue.js';
-import NullDataValue from './data/EmptyDataValue.js';
-import { format } from '@aemforms/af-formatters';
-import './utils/DataRefParser.js';
-import './data/DataGroup.js';
-import './utils/FormUtils.js';
-import './utils/JsonUtils.js';
-import './types/Json.js';
-import './FileObject.js';
-
-const validTypes = ['string', 'number', 'boolean', 'file', 'string[]', 'number[]', 'boolean[]', 'file[]', 'array', 'object'];
-class Field extends Scriptable {
-    constructor(params, _options) {
-        super(params, _options);
-        this._applyDefaults();
-        this.queueEvent(new Initialize());
-        this.queueEvent(new ExecuteRule());
-    }
-    _ruleNodeReference = [];
-    _initialize() {
-        super._initialize();
-        this.setupRuleNode();
-    }
-    ruleNodeReference() {
-        if (this.type?.endsWith('[]')) {
-            this._ruleNodeReference = [];
-        }
-        else {
-            this._ruleNodeReference = this;
-        }
-        return this._ruleNodeReference;
-    }
-    _getDefaults() {
-        return {
-            readOnly: false,
-            enabled: true,
-            visible: true,
-            type: this._getFallbackType()
-        };
-    }
-    _getFallbackType() {
-        const type = this._jsonModel.type;
-        let finalType = type;
-        if (typeof type !== 'string' || validTypes.indexOf(type) === -1) {
-            const _enum = this.enum;
-            finalType = typeof (_enum?.[0]);
-            if (finalType === 'undefined' && typeof this._jsonModel.default !== 'undefined') {
-                if (this._jsonModel.default instanceof Array && this._jsonModel.default.length > 0) {
-                    finalType = `${typeof (this._jsonModel.default[0])}[]`;
-                }
-                else {
-                    finalType = typeof (this._jsonModel.default);
-                }
-            }
-            if (finalType.indexOf('undefined') === 0) {
-                const typeMappings = {
-                    'text-input': 'string',
-                    'multiline-input': 'string',
-                    'number-input': 'number',
-                    'date-input': 'string',
-                    'plain-text': 'string',
-                    'image': 'string',
-                    'checkbox': 'boolean'
-                };
-                finalType = typeMappings[this.fieldType];
-            }
-        }
-        return finalType;
-    }
-    _applyDefaults() {
-        Object.entries(this._getDefaults()).map(([key, value]) => {
-            if (this._jsonModel[key] === undefined && value !== undefined) {
-                this._jsonModel[key] = value;
-            }
-        });
-        this.coerceParam('required', 'boolean');
-        this.coerceParam('readOnly', 'boolean');
-        this.coerceParam('enabled', 'boolean');
-        const type = this._jsonModel.type;
-        if (typeof type !== 'string' || validTypes.indexOf(type) === -1) {
-            this._jsonModel.type = this._getFallbackType();
-        }
-        if (['plain-text', 'image'].indexOf(this.fieldType) === -1) {
-            this._jsonModel.value = undefined;
-        }
-        const value = this._jsonModel.value;
-        if (value === undefined) {
-            const typedRes = Constraints.type(this.getInternalType() || 'string', this._jsonModel.default);
-            this._jsonModel.value = typedRes.value;
-        }
-        if (this._jsonModel.type !== 'string') {
-            this.unset('emptyValue');
-        }
-        if (this._jsonModel.fieldType === undefined) {
-            this.form.logger.error('fieldType property is mandatory. Please ensure all the fields have a fieldType');
-            if (this._jsonModel.viewType) {
-                if (this._jsonModel.viewType.startsWith('custom:')) {
-                    this.form.logger.error('viewType property has been removed. For custom types, use :type property');
-                }
-                else {
-                    this.form.logger.error('viewType property has been removed. Use fieldType property');
-                }
-                this._jsonModel.fieldType = this._jsonModel.viewType;
-            }
-            else {
-                this._jsonModel.fieldType = defaultFieldTypes(this._jsonModel);
-            }
-        }
-        if (this._jsonModel.enum === undefined) {
-            const type = this._jsonModel.type;
-            if (type === 'boolean') {
-                this._jsonModel.enum = [true, false];
-            }
-        }
-        else {
-            if (typeof this._jsonModel.enumNames === 'undefined') {
-                this._jsonModel.enumNames = this._jsonModel.enum.map(_ => _.toString());
-            }
-            while (this._jsonModel.enumNames.length < this._jsonModel.enum.length) {
-                this._jsonModel.enumNames.push(this._jsonModel.enum[this._jsonModel.enumNames.length].toString());
-            }
-        }
-        const props = ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'];
-        if (this._jsonModel.type !== 'string') {
-            this.unset('format', 'pattern', 'minLength', 'maxLength');
-        }
-        else if (this._jsonModel.fieldType === 'date-input') {
-            this._jsonModel.format = 'date';
-        }
-        this.coerceParam('minLength', 'number');
-        this.coerceParam('maxLength', 'number');
-        if (this._jsonModel.type !== 'number' && this._jsonModel.format !== 'date') {
-            this.unset('step', ...props);
-        }
-        props.forEach(c => {
-            this.coerceParam(c, this._jsonModel.type);
-        });
-        if (typeof this._jsonModel.step !== 'number') {
-            this.coerceParam('step', 'number');
-        }
-    }
-    unset(...props) {
-        props.forEach(p => this._jsonModel[p] = undefined);
-    }
-    coerceParam(param, type) {
-        const val = this._jsonModel[param];
-        if (typeof val !== 'undefined' && typeof val !== type) {
-            this.form.logger.info(`${param} is not of type ${type}. Trying to coerce.`);
-            try {
-                this._jsonModel[param] = coerceType(val, type);
-            }
-            catch (e) {
-                this.form.logger.warn(e);
-                this.unset(param);
-            }
-        }
-    }
-    get editFormat() {
-        return this.withCategory(this._jsonModel.editFormat);
-    }
-    get displayFormat() {
-        return this.withCategory(this._jsonModel.displayFormat);
-    }
-    get placeholder() {
-        return this._jsonModel.placeholder;
-    }
-    get readOnly() {
-        return this._jsonModel.readOnly;
-    }
-    set readOnly(e) {
-        this._setProperty('readOnly', e);
-    }
-    get enabled() {
-        return this._jsonModel.enabled;
-    }
-    set enabled(e) {
-        this._setProperty('enabled', e);
-    }
-    get valid() {
-        return this._jsonModel.valid;
-    }
-    get emptyValue() {
-        if (this._jsonModel.emptyValue === 'null') {
-            return null;
-        }
-        else if (this._jsonModel.emptyValue === '' && this.type === 'string') {
-            return '';
-        }
-        else {
-            return undefined;
-        }
-    }
-    get enum() {
-        return this._jsonModel.enum;
-    }
-    set enum(e) {
-        this._setProperty('enum', e);
-    }
-    get enumNames() {
-        return this._jsonModel.enumNames;
-    }
-    set enumNames(e) {
-        this._setProperty('enumNames', e);
-    }
-    get required() {
-        return this._jsonModel.required || false;
-    }
-    set required(r) {
-        this._setProperty('required', r);
-    }
-    get maximum() {
-        if (this.type === 'number' || this.format === 'date') {
-            return this._jsonModel.maximum;
-        }
-    }
-    set maximum(m) {
-        if (this.type === 'number' || this.format === 'date') {
-            this._setProperty('maximum', m);
-        }
-    }
-    get minimum() {
-        if (this.type === 'number' || this.format === 'date') {
-            return this._jsonModel.minimum;
-        }
-    }
-    set minimum(m) {
-        if (this.type === 'number' || this.format === 'date') {
-            this._setProperty('minimum', m);
-        }
-    }
-    isEmpty() {
-        return this._jsonModel.value === undefined || this._jsonModel.value === null || this._jsonModel.value === '';
-    }
-    withCategory(df) {
-        if (df) {
-            const hasCategory = df?.match(/^(?:date|num)\|/);
-            if (hasCategory === null) {
-                if (this.format === 'date') {
-                    df = `date|${df}`;
-                }
-                else if (this.type === 'number') {
-                    df = `num|${df}`;
-                }
-                return df;
-            }
-        }
-        return df;
-    }
-    get editValue() {
-        const df = this.editFormat;
-        if (df && this.isNotEmpty(this.value) && this.valid !== false) {
-            try {
-                return format(this.value, this.language, df);
-            }
-            catch (e) {
-                return this.value;
-            }
-        }
-        else {
-            return this.value;
-        }
-    }
-    get displayValue() {
-        const df = this.displayFormat;
-        if (df && this.isNotEmpty(this.value) && this.valid !== false) {
-            try {
-                return format(this.value, this.language, df);
-            }
-            catch (e) {
-                return this.value;
-            }
-        }
-        else {
-            return this.value;
-        }
-    }
-    getDataNodeValue(typedValue) {
-        return this.isEmpty() ? this.emptyValue : typedValue;
-    }
-    updateDataNodeAndTypedValue(val) {
-        const dataNode = this.getDataNode();
-        if (staticFields.indexOf(this.fieldType) > -1 && typeof dataNode !== 'undefined') {
-            return;
-        }
-        const Constraints = this._getConstraintObject();
-        const typeRes = Constraints.type(this.getInternalType() || 'string', val);
-        const changes = this._setProperty('value', typeRes.value, false);
-        if (changes.length > 0) {
-            this._updateRuleNodeReference(typeRes.value);
-            if (typeof dataNode !== 'undefined') {
-                dataNode.setValue(this.getDataNodeValue(this._jsonModel.value), this._jsonModel.value, this);
-            }
-        }
-        return changes;
-    }
-    get value() {
-        if (this._jsonModel.value === undefined) {
-            return null;
-        }
-        else {
-            return this._jsonModel.value;
-        }
-    }
-    set value(v) {
-        const changes = this.updateDataNodeAndTypedValue(v);
-        let uniqueRes = { valid: true };
-        if (changes?.length > 0) {
-            let updates = {};
-            const typeRes = Constraints.type(this.getInternalType() || 'string', v);
-            if (this.parent.uniqueItems && this.parent.type === 'array') {
-                uniqueRes = Constraints.uniqueItems(this.parent.uniqueItems, this.parent.getDataNode().$value);
-            }
-            if (typeRes.valid && uniqueRes.valid) {
-                updates = this.evaluateConstraints();
-            }
-            else {
-                const changes = {
-                    'valid': typeRes.valid && uniqueRes.valid,
-                    'errorMessage': typeRes.valid && uniqueRes.valid ? '' : this.getErrorMessage('type')
-                };
-                updates = this._applyUpdates(['valid', 'errorMessage'], changes);
-            }
-            if (updates.valid) {
-                this.triggerValidationEvent(updates);
-            }
-            const changeAction = new Change({ changes: changes.concat(Object.values(updates)) });
-            this.dispatch(changeAction);
-        }
-    }
-    reset() {
-        const changes = this.updateDataNodeAndTypedValue(this.default);
-        if (changes.length > 0) {
-            const validationStateChanges = {
-                'valid': undefined,
-                'errorMessage': ''
-            };
-            const updates = this._applyUpdates(['valid', 'errorMessage'], validationStateChanges);
-            const changeAction = new Change({ changes: changes.concat(Object.values(updates)) });
-            this.dispatch(changeAction);
-        }
-    }
-    _updateRuleNodeReference(value) {
-        if (this.type?.endsWith('[]')) {
-            if (value != null) {
-                value.forEach((val, index) => {
-                    this._ruleNodeReference[index] = val;
-                });
-                while (value.length !== this._ruleNodeReference.length) {
-                    this._ruleNodeReference.pop();
-                }
-            }
-            else {
-                while (this._ruleNodeReference.length !== 0) {
-                    this._ruleNodeReference.pop();
-                }
-            }
-        }
-    }
-    getInternalType() {
-        return this.type;
-    }
-    valueOf() {
-        const obj = this[target];
-        const actualField = obj === undefined ? this : obj;
-        actualField.ruleEngine.trackDependency(actualField);
-        return actualField._jsonModel.value || null;
-    }
-    toString() {
-        const obj = this[target];
-        const actualField = obj === undefined ? this : obj;
-        return actualField._jsonModel.value?.toString() || '';
-    }
-    getErrorMessage(constraint) {
-        return this._jsonModel.constraintMessages?.[constraint] || '';
-    }
-    get errorMessage() {
-        return this._jsonModel.errorMessage;
-    }
-    get screenReaderText() {
-        return this._jsonModel.screenReaderText;
-    }
-    _getConstraintObject() {
-        return Constraints;
-    }
-    isArrayType() {
-        return this.type ? this.type.indexOf('[]') > -1 : false;
-    }
-    checkEnum(value, constraints) {
-        if (this._jsonModel.enforceEnum === true && value != null) {
-            const fn = constraints.enum;
-            if (value instanceof Array && this.isArrayType()) {
-                return value.every(x => fn(this.enum || [], x).valid);
-            }
-            else {
-                return fn(this.enum || [], value).valid;
-            }
-        }
-        return true;
-    }
-    checkStep() {
-        const value = this._jsonModel.value;
-        const step = this._jsonModel.step;
-        if (typeof step === 'number') {
-            const prec = step.toString().split('.')?.[1]?.length || 0;
-            const factor = Math.pow(10, prec);
-            const fStep = step * factor;
-            const fVal = value * factor;
-            const iv = this._jsonModel.minimum || this._jsonModel.default || 0;
-            const fIVal = iv * factor;
-            const qt = (fVal - fIVal) / fStep;
-            const valid = Math.abs(fVal - fIVal) % fStep < .001;
-            let next, prev;
-            if (!valid) {
-                next = (Math.ceil(qt) * fStep + fIVal) / factor;
-                prev = (next - fStep) / factor;
-            }
-            return {
-                valid,
-                next,
-                prev
-            };
-        }
-        return {
-            valid: true
-        };
-    }
-    checkValidationExpression() {
-        if (typeof this._jsonModel.validationExpression === 'string') {
-            return this.executeExpression(this._jsonModel.validationExpression);
-        }
-        return true;
-    }
-    getConstraints() {
-        switch (this.type) {
-            case 'string':
-                switch (this.format) {
-                    case 'date':
-                        return ValidConstraints.date;
-                    case 'binary':
-                        return ValidConstraints.file;
-                    case 'data-url':
-                        return ValidConstraints.file;
-                    default:
-                        return ValidConstraints.string;
-                }
-            case 'file':
-                return ValidConstraints.file;
-            case 'number':
-            case 'integer':
-                return ValidConstraints.number;
-        }
-        if (this.isArrayType()) {
-            return ValidConstraints.array;
-        }
-        return [];
-    }
-    get format() {
-        if (typeof this._jsonModel.format === 'undefined') {
-            if (this.type === 'string') {
-                switch (this.fieldType) {
-                    case 'date-input':
-                        this._jsonModel.format = 'date';
-                        break;
-                    case 'file-input':
-                        this._jsonModel.format = 'data-url';
-                        break;
-                }
-            }
-        }
-        return this._jsonModel.format;
-    }
-    get enforceEnum() {
-        return this._jsonModel.enforceEnum;
-    }
-    get tooltip() {
-        return this._jsonModel.tooltip;
-    }
-    get maxLength() {
-        return this._jsonModel.maxLength;
-    }
-    get minLength() {
-        return this._jsonModel.minLength;
-    }
-    get pattern() {
-        return this._jsonModel.pattern;
-    }
-    get step() {
-        if (this.type === 'number' || this.format === 'date') {
-            return this._jsonModel.step;
-        }
-    }
-    get exclusiveMinimum() {
-        if (this.type === 'number' || this.format === 'date') {
-            return this._jsonModel.exclusiveMinimum;
-        }
-    }
-    set exclusiveMinimum(eM) {
-        if (this.type === 'number' || this.format === 'date') {
-            this._jsonModel.exclusiveMinimum = eM;
-        }
-    }
-    get exclusiveMaximum() {
-        if (this.type === 'number' || this.format === 'date') {
-            return this._jsonModel.exclusiveMaximum;
-        }
-    }
-    set exclusiveMaximum(eM) {
-        if (this.type === 'number' || this.format === 'date') {
-            this._jsonModel.exclusiveMaximum = eM;
-        }
-    }
-    get default() {
-        return this._jsonModel.default;
-    }
-    isNotEmpty(value) {
-        return value != null && value !== '';
-    }
-    evaluateConstraints() {
-        let constraint = 'type';
-        const elem = this._jsonModel;
-        const value = this._jsonModel.value;
-        const Constraints = this._getConstraintObject();
-        const supportedConstraints = this.getConstraints();
-        let valid = true;
-        if (valid) {
-            valid = Constraints.required(this.required, value).valid &&
-                (this.isArrayType() && this.required ? value.length > 0 : true);
-            constraint = 'required';
-        }
-        if (valid && this.isNotEmpty(value)) {
-            const invalidConstraint = supportedConstraints.find(key => {
-                if (key in elem && elem[key] !== undefined) {
-                    const restriction = elem[key];
-                    const fn = Constraints[key];
-                    if (value instanceof Array && this.isArrayType()) {
-                        if (ValidConstraints.array.indexOf(key) !== -1) {
-                            return !fn(restriction, value).valid;
-                        }
-                        else {
-                            return value.some(x => !(fn(restriction, x).valid));
-                        }
-                    }
-                    else if (typeof fn === 'function') {
-                        return !fn(restriction, value).valid;
-                    }
-                    else {
-                        return false;
-                    }
-                }
-                else {
-                    return false;
-                }
-            });
-            if (invalidConstraint != null) {
-                valid = false;
-                constraint = invalidConstraint;
-            }
-            else {
-                valid = this.checkEnum(value, Constraints);
-                constraint = 'enum';
-                if (valid && this.type === 'number') {
-                    valid = this.checkStep().valid;
-                    constraint = 'step';
-                }
-                if (valid) {
-                    valid = this.checkValidationExpression();
-                    constraint = 'validationExpression';
-                }
-            }
-        }
-        if (!valid) {
-            this.form.logger.info(`${constraint} constraint evaluation failed ${this._jsonModel[constraint]}. Received ${this._jsonModel.value}`);
-        }
-        const changes = {
-            'valid': valid,
-            'errorMessage': valid ? '' : this.getErrorMessage(constraint)
-        };
-        return this._applyUpdates(['valid', 'errorMessage'], changes);
-    }
-    triggerValidationEvent(changes) {
-        if (changes.valid) {
-            if (this.valid) {
-                this.dispatch(new Valid());
-            }
-            else {
-                this.dispatch(new Invalid());
-            }
-        }
-    }
-    validate() {
-        const changes = this.evaluateConstraints();
-        if (changes.valid) {
-            this.triggerValidationEvent(changes);
-            this.notifyDependents(new Change({ changes: Object.values(changes) }));
-        }
-        return this.valid ? [] : [new ValidationError(this.id, [this._jsonModel.errorMessage])];
-    }
-    importData(contextualDataModel) {
-        this._bindToDataModel(contextualDataModel);
-        const dataNode = this.getDataNode();
-        if (dataNode !== undefined && dataNode !== NullDataValue && dataNode.$value !== this._jsonModel.value) {
-            const changeAction = propertyChange('value', dataNode.$value, this._jsonModel.value);
-            this._jsonModel.value = dataNode.$value;
-            this.queueEvent(changeAction);
-        }
-    }
-    defaultDataModel(name) {
-        const value = staticFields.indexOf(this.fieldType) > -1 ? undefined : this.getDataNodeValue(this._jsonModel.value);
-        return new DataValue(name, value, this.type || 'string');
-    }
-    getState() {
-        return {
-            ...super.getState(),
-            editFormat: this.editFormat,
-            displayFormat: this.displayFormat,
-            editValue: this.editValue,
-            displayValue: this.displayValue
-        };
-    }
-}
-__decorate([
-    dependencyTracked(),
-    exclude('button', 'image', 'plain-text')
-], Field.prototype, "readOnly", null);
-__decorate([
-    dependencyTracked(),
-    exclude('image', 'plain-text')
-], Field.prototype, "enabled", null);
-__decorate([
-    dependencyTracked()
-], Field.prototype, "valid", null);
-__decorate([
-    dependencyTracked()
-], Field.prototype, "enum", null);
-__decorate([
-    dependencyTracked()
-], Field.prototype, "enumNames", null);
-__decorate([
-    dependencyTracked()
-], Field.prototype, "required", null);
-__decorate([
-    include('date-input', 'number-input')
-], Field.prototype, "editValue", null);
-__decorate([
-    dependencyTracked()
-], Field.prototype, "value", null);
-__decorate([
-    include('text-input', 'date-input', 'file-input')
-], Field.prototype, "format", null);
-__decorate([
-    include('text-input')
-], Field.prototype, "maxLength", null);
-__decorate([
-    include('text-input')
-], Field.prototype, "minLength", null);
-__decorate([
-    include('text-input')
-], Field.prototype, "pattern", null);
-__decorate([
-    dependencyTracked()
-], Field.prototype, "exclusiveMinimum", null);
-__decorate([
-    dependencyTracked()
-], Field.prototype, "exclusiveMaximum", null);
-
-export { Field as default };

package/lib/esm/Fieldset.d.ts

@@ -1,16 +0,0 @@
-import Container from './Container.js';
-import { ContainerModel, FieldsetJson, FieldsetModel, FormModel, IFormFieldFactory } from './types/index.js';
-export declare class Fieldset extends Container<FieldsetJson> implements FieldsetModel {
-    constructor(params: FieldsetJson, _options: {
-        form: FormModel;
-        parent: ContainerModel;
-        fieldFactory: IFormFieldFactory;
-    });
-    private _applyDefaults;
-    get type(): "array" | "object" | undefined;
-    get items(): (import("./types/Model.js").FieldModel | FieldsetModel)[];
-    get value(): null;
-    get fieldType(): string;
-    get enabled(): boolean | undefined;
-    set enabled(e: boolean | undefined);
-}