@formio/js 5.0.0-rc.27 → 5.0.0-rc.28

package/lib/mjs/components/_classes/nested/NestedComponent.js

@@ -3,6 +3,7 @@ import _ from 'lodash';
 import Field from '../field/Field';
 import Components from '../../Components';
 import { getArrayFromComponentPath, getStringFromComponentPath, getRandomComponentId } from '../../../utils/utils';
+import { process as processAsync, processSync } from '@formio/core';
 export default class NestedComponent extends Field {
     static schema(...extend) {
         return Field.schema({
@@ -30,7 +31,7 @@ export default class NestedComponent extends Field {
     collapse(value) {
         const promise = this.redraw();
         if (!value) {
-            this.checkValidity(this.data, !this.pristine, null, this.pristine);
+            this.checkValidity(this.data, !this.pristine);
         }
         return promise;
     }
@@ -188,6 +189,14 @@ export default class NestedComponent extends Field {
      */
     getComponent(path, fn, originalPath) {
         originalPath = originalPath || getStringFromComponentPath(path);
+        if (this.componentsMap.hasOwnProperty(originalPath)) {
+            if (fn) {
+                return fn(this.componentsMap[originalPath]);
+            }
+            else {
+                return this.componentsMap[originalPath];
+            }
+        }
         path = getArrayFromComponentPath(path);
         const pathStr = originalPath;
         const newPath = _.clone(path);
@@ -242,26 +251,6 @@ export default class NestedComponent extends Field {
         });
         return comp;
     }
-    /**
-     * Return a path of component's value.
-     *
-     * @param {Object} component - The component instance.
-     * @return {string} - The component's value path.
-     */
-    calculateComponentPath(component) {
-        let path = '';
-        if (component.component.key) {
-            let thisPath = this;
-            while (thisPath && !thisPath.allowData && thisPath.parent) {
-                thisPath = thisPath.parent;
-            }
-            const rowIndex = component.row ? `[${Number.parseInt(component.row)}]` : '';
-            path = thisPath.path ? `${thisPath.path}${rowIndex}.` : '';
-            path += component._parentPath && component.component.shouldIncludeSubFormPath ? component._parentPath : '';
-            path += component.component.key;
-            return path;
-        }
-    }
     /**
      * Create a new component and add it to the components array.
      *
@@ -282,14 +271,7 @@ export default class NestedComponent extends Field {
         if (!(options.display === 'pdf' && this.builderMode)) {
             component.id = getRandomComponentId();
         }
-        if (!this.isInputComponent && this.component.shouldIncludeSubFormPath) {
-            component.shouldIncludeSubFormPath = true;
-        }
         const comp = Components.create(component, options, data, true);
-        const path = this.calculateComponentPath(comp);
-        if (path) {
-            comp.path = path;
-        }
         comp.init();
         if (component.internal) {
             return comp;
@@ -362,9 +344,6 @@ export default class NestedComponent extends Field {
     addComponent(component, data, before, noAdd) {
         data = data || this.data;
         this.components = this.components || [];
-        if (this.options.parentPath) {
-            component.shouldIncludeSubFormPath = true;
-        }
         component = this.hook('addComponent', component, data, before, noAdd);
         const comp = this.createComponent(component, this.options, data, before ? before : null);
         if (noAdd) {
@@ -451,7 +430,7 @@ export default class NestedComponent extends Field {
         return Promise.all(promises);
     }
     /**
-     * Remove a component from the components array.
+     * Remove a component from the components array and from the children object
      *
      * @param {Component} component - The component to remove from the components.
      * @param {Array<Component>} components - An array of components to remove this component from.
@@ -460,6 +439,9 @@ export default class NestedComponent extends Field {
         components = components || this.components;
         component.destroy(all);
         _.remove(components, { id: component.id });
+        if (this.componentsMap[component.path]) {
+            delete this.componentsMap[component.path];
+        }
     }
     /**
      * Removes a component provided the API key of that component.
@@ -508,13 +490,13 @@ export default class NestedComponent extends Field {
             return comp.updateValue(null, flags) || changed;
         }, super.updateValue(value, flags));
     }
-    shouldSkipValidation(data, dirty, row) {
+    shouldSkipValidation(data, row, flags) {
         // Nested components with no input should not be validated.
         if (!this.component.input) {
             return true;
         }
         else {
-            return super.shouldSkipValidation(data, dirty, row);
+            return super.shouldSkipValidation(data, row, flags);
         }
     }
     checkData(data, flags, row, components) {
@@ -525,11 +507,8 @@ export default class NestedComponent extends Field {
         flags = flags || {};
         row = row || this.data;
         components = components && _.isArray(components) ? components : this.getComponents();
-        const isValid = components.reduce((valid, comp) => {
-            return comp.checkData(data, flags, row) && valid;
-        }, super.checkData(data, flags, row));
-        this.checkModal(isValid, this.isDirty);
-        return isValid;
+        super.checkData(data, flags, row);
+        components.forEach((comp) => comp.checkData(data, flags, row));
     }
     checkConditions(data, flags, row) {
         // check conditions of parent component first, because it may influence on visibility of it's children
@@ -567,7 +546,7 @@ export default class NestedComponent extends Field {
      * @return {*}
      */
     beforeSubmit() {
-        return Promise.all(this.getComponents().map((comp) => comp.beforeSubmit()));
+        return Promise.allSettled(this.getComponents().map((comp) => comp.beforeSubmit()));
     }
     calculateValue(data, flags, row) {
         // Do not iterate into children and calculateValues if this nested component is conditionally hidden.
@@ -582,23 +561,75 @@ export default class NestedComponent extends Field {
     isValid(data, dirty) {
         return this.getComponents().reduce((valid, comp) => comp.isValid(data, dirty) && valid, super.isValid(data, dirty));
     }
-    checkChildComponentsValidity(data, dirty, row, silentCheck, isParentValid) {
-        return this.getComponents().reduce((check, comp) => comp.checkValidity(data, dirty, row, silentCheck) && check, isParentValid);
-    }
-    checkValidity(data, dirty, row, silentCheck) {
-        if (!this.checkCondition(row, data)) {
-            this.setCustomValidity('');
-            return true;
+    validationProcessor({ scope, data, row, instance }, flags) {
+        const { dirty } = flags;
+        if (!instance) {
+            return;
+        }
+        instance.checkComponentValidity(data, dirty, row, flags, scope.errors);
+        if (instance.processOwnValidation) {
+            scope.noRecurse = true;
         }
-        const isValid = this.checkChildComponentsValidity(data, dirty, row, silentCheck, super.checkValidity(data, dirty, row, silentCheck));
-        this.checkModal(isValid, dirty);
-        return isValid;
+    }
+    /**
+     * Perform a validation on all child components of this nested component.
+     * @param {*} components
+     * @param {*} data
+     * @param {*} flags
+     * @returns
+     */
+    validateComponents(components, data, flags = {}) {
+        components = components || this.component.components;
+        data = data || this.rootValue;
+        const { async, dirty, process } = flags;
+        const processorContext = {
+            process: process || 'unknown',
+            components,
+            instances: this.componentsMap,
+            data: data,
+            scope: { errors: [] },
+            processors: [
+                (context) => this.validationProcessor(context, flags),
+                ({ instance, component, components }) => {
+                    // If we just validated the last component, and there are errors from our parent, then we need to show a model of those errors.
+                    if (instance &&
+                        instance.parent &&
+                        (component === components[components.length - 1]) &&
+                        instance.parent.componentModal) {
+                        instance.parent.checkModal(instance.parent.childErrors, dirty);
+                    }
+                }
+            ]
+        };
+        return async ? processAsync(processorContext).then((scope) => scope.errors) : processSync(processorContext).errors;
+    }
+    /**
+     * Validate a nested component with data, or its own internal data.
+     * @param {*} data
+     * @param {*} flags
+     * @returns
+     */
+    validate(data, flags = {}) {
+        data = data || this.rootValue;
+        return this.validateComponents(this.getComponents().map((component) => component.component), data, flags);
+    }
+    checkComponentValidity(data, dirty, row, flags = {}, allErrors = []) {
+        this.childErrors = [];
+        return super.checkComponentValidity(data, dirty, row, flags, allErrors);
+    }
+    checkValidity(data, dirty, row, silentCheck, childErrors = []) {
+        console.log('Deprecation warning:  Component.checkValidity() will be deprecated in 6.x version of renderer. Use "validate" method instead.');
+        childErrors.push(...this.validate(data, { dirty, silentCheck }));
+        return this.checkComponentValidity(data, dirty, row, { dirty, silentCheck }, childErrors) && childErrors.length === 0;
     }
     checkAsyncValidity(data, dirty, row, silentCheck) {
+        console.log('Deprecation warning:  Component.checkAsyncValidity() will be deprecated in 6.x version of renderer.');
         return this.ready.then(() => {
-            const promises = [super.checkAsyncValidity(data, dirty, row, silentCheck)];
-            this.eachComponent((component) => promises.push(component.checkAsyncValidity(data, dirty, row, silentCheck)));
-            return Promise.all(promises).then((results) => results.reduce((valid, result) => (valid && result), true));
+            return this.validate(data, { dirty, silentCheck, async: true }).then((childErrors) => {
+                return this.checkComponentValidity(data, dirty, row, { dirty, silentCheck, async: true }, childErrors).then((valid) => {
+                    return valid && childErrors.length === 0;
+                });
+            });
         });
     }
     setPristine(pristine) {
@@ -632,8 +663,11 @@ export default class NestedComponent extends Field {
         components.forEach((comp) => this.removeComponent(comp, this.components, all));
         this.components = [];
     }
+    get visibleErrors() {
+        return this.getComponents().reduce((errors, comp) => errors.concat(comp.visibleErrors || []), super.visibleErrors);
+    }
     get errors() {
-        const thisErrors = this.error ? [this.error] : [];
+        const thisErrors = super.errors;
         return this.getComponents()
             .reduce((errors, comp) => errors.concat(comp.errors || []), thisErrors)
             .filter(err => err.level !== 'hidden');
@@ -673,9 +707,6 @@ export default class NestedComponent extends Field {
         if (!value) {
             return false;
         }
-        if (value.submitAsDraft && !value.submit) {
-            flags.noValidate = true;
-        }
         return this.getComponents().reduce((changed, component) => {
             return this.setNestedValue(component, value, flags, changed) || changed;
         }, false);

package/lib/mjs/components/_classes/nestedarray/NestedArrayComponent.d.ts

@@ -5,10 +5,11 @@ export default class NestedArrayComponent extends NestedDataComponent {
     prevHasAddButton: any;
     checkAddButtonChanged(): void;
     checkData(data: any, flags: any, row: any): any;
-    checkRows(method: any, data: any, opts: any, defaultValue: any, silentCheck: any): any;
-    checkRow(method: any, data: any, opts: any, row: any, components: any, silentCheck: any): any;
+    processRows(method: any, data: any, opts: any, defaultValue: any, silentCheck: any): any;
+    validate(data: any, flags?: {}): any;
+    processRow(method: any, data: any, opts: any, row: any, components: any, silentCheck: any): any;
     hasAddButton(): any;
-    getComponent(path: any, fn: any, originalPath: any): any[];
+    getComponent(path: any, fn: any, originalPath: any): any;
     everyComponent(fn: any, rowIndex: any, options: any): void;
     getComponents(rowIndex: any): any;
 }

package/lib/mjs/components/_classes/nestedarray/NestedArrayComponent.js

@@ -1,6 +1,6 @@
 'use strict';
 import _ from 'lodash';
-import { componentValueTypes } from '../../../utils/utils';
+import { componentValueTypes, getStringFromComponentPath } from '../../../utils/utils';
 import Component from '../component/Component';
 import NestedDataComponent from '../nesteddata/NestedDataComponent';
 export default class NestedArrayComponent extends NestedDataComponent {
@@ -40,19 +40,23 @@ export default class NestedArrayComponent extends NestedDataComponent {
         flags = flags || {};
         row = row || this.data;
         this.checkAddButtonChanged();
-        return this.checkRows('checkData', data, flags, Component.prototype.checkData.call(this, data, flags, row));
+        return this.processRows('checkData', data, flags, Component.prototype.checkData.call(this, data, flags, row));
     }
-    checkRows(method, data, opts, defaultValue, silentCheck) {
+    processRows(method, data, opts, defaultValue, silentCheck) {
         return this.iteratableRows.reduce((valid, row, rowIndex) => {
             if (!opts?.rowIndex || opts?.rowIndex === rowIndex) {
-                return this.checkRow(method, data, opts, row.data, row.components, silentCheck) && valid;
+                return this.processRow(method, data, opts, row.data, row.components, silentCheck) && valid;
             }
             else {
                 return valid;
             }
         }, defaultValue);
     }
-    checkRow(method, data, opts, row, components, silentCheck) {
+    validate(data, flags = {}) {
+        data = data || this.data;
+        return this.validateComponents([this.component], data, flags);
+    }
+    processRow(method, data, opts, row, components, silentCheck) {
         if (opts?.isolateRow) {
             silentCheck = true;
             opts.noRefresh = true;
@@ -77,6 +81,15 @@ export default class NestedArrayComponent extends NestedDataComponent {
             }, 'show'));
     }
     getComponent(path, fn, originalPath) {
+        originalPath = originalPath || getStringFromComponentPath(path);
+        if (this.componentsMap.hasOwnProperty(originalPath)) {
+            if (fn) {
+                return fn(this.componentsMap[originalPath]);
+            }
+            else {
+                return this.componentsMap[originalPath];
+            }
+        }
         path = Array.isArray(path) ? path : [path];
         let key = path.shift();
         const remainingPath = path;

package/lib/mjs/components/builder.js

@@ -37,7 +37,6 @@ import TagsForm from './tags/Tags.form';
 import TextAreaForm from './textarea/TextArea.form';
 import TextfieldForm from './textfield/TextField.form';
 import TimeForm from './time/Time.form';
-import TreeForm from './tree/Tree.form';
 import UnknownForm from './unknown/Unknown.form';
 import UrlForm from './url/Url.form';
 import WellForm from './well/Well.form';
@@ -79,7 +78,6 @@ Components.tags.editForm = TagsForm;
 Components.textarea.editForm = TextAreaForm;
 Components.textfield.editForm = TextfieldForm;
 Components.time.editForm = TimeForm;
-Components.tree.editForm = TreeForm;
 Components.unknown.editForm = UnknownForm;
 Components.url.editForm = UrlForm;
 Components.well.editForm = WellForm;

package/lib/mjs/components/button/Button.js

@@ -190,7 +190,7 @@ export default class ButtonComponent extends Field {
             const isSilent = flags && flags.silent;
             //check root validity only if disableOnInvalid is set and when it is not possible to make submission because of validation errors
             if (flags && flags.noValidate && (this.component.disableOnInvalid || this.hasError)) {
-                isValid = flags.rootValidity || (this.root ? this.root.checkValidity(this.root.data, null, null, true) : true);
+                isValid = flags.rootValidity || (this.root ? (this.root.validate(this.root.data, { dirty: false, silentCheck: true }).length === 0) : true);
                 flags.rootValidity = isValid;
             }
             this.isDisabledOnInvalid = this.component.disableOnInvalid && (isSilent || !isValid);
@@ -278,6 +278,7 @@ export default class ButtonComponent extends Field {
                 event.stopPropagation();
                 this.loading = true;
                 this.emit('submitButton', {
+                    noValidate: this.component.state === 'draft',
                     state: this.component.state || 'submitted',
                     component: this.component,
                     instance: this

package/lib/mjs/components/columns/Columns.d.ts

@@ -22,6 +22,7 @@ export default class ColumnsComponent extends NestedComponent {
      * @return {Array.<ColumnComponent[]>}
      */
     groupByRow(): Array<ColumnComponent[]>;
+    checkData(data: any, flags: any, row: any, components: any): void;
     detach(all: any): void;
 }
 import NestedComponent from '../_classes/nested/NestedComponent';

package/lib/mjs/components/columns/Columns.js

@@ -65,7 +65,7 @@ export default class ColumnsComponent extends NestedComponent {
             if (!column.size) {
                 column.size = 'md';
             }
-            column.currentWidth = column.width || 0;
+            column.currentWidth = this.options.condensedMode ? this.gridSize : column.width || 0;
             // Ensure there is a components array.
             if (!Array.isArray(column.components)) {
                 column.components = [];
@@ -134,14 +134,13 @@ export default class ColumnsComponent extends NestedComponent {
         return _.concat(result.rows, [result.stack]);
     }
     checkData(data, flags, row, components) {
-        const isValid = super.checkData(data, flags, row, components);
+        super.checkData(data, flags, row, components);
         if (this.component.autoAdjust && this.options.display !== 'pdf') {
             const redraw = this.justify();
             if (redraw) {
                 this.redraw();
             }
         }
-        return isValid;
     }
     detach(all) {
         super.detach(all);

package/lib/mjs/components/columns/editForm/Columns.edit.display.d.ts

@@ -5,8 +5,29 @@ declare const _default: ({
     type?: undefined;
     input?: undefined;
     label?: undefined;
-    addAnother?: undefined;
+    placeholder?: undefined;
     tooltip?: undefined;
+    validate?: undefined;
+    autofocus?: undefined;
+    overrideEditForm?: undefined;
+    addAnother?: undefined;
+    reorder?: undefined;
+    components?: undefined;
+} | {
+    weight: number;
+    type: string;
+    input: boolean;
+    key: string;
+    label: string;
+    placeholder: string;
+    tooltip: string;
+    validate: {
+        required: boolean;
+    };
+    autofocus: boolean;
+    overrideEditForm: boolean;
+    ignore?: undefined;
+    addAnother?: undefined;
     reorder?: undefined;
     components?: undefined;
 } | {
@@ -43,6 +64,10 @@ declare const _default: ({
         data?: undefined;
     })[];
     ignore?: undefined;
+    placeholder?: undefined;
+    validate?: undefined;
+    autofocus?: undefined;
+    overrideEditForm?: undefined;
 } | {
     weight: number;
     type: string;
@@ -51,6 +76,10 @@ declare const _default: ({
     key: string;
     input: boolean;
     ignore?: undefined;
+    placeholder?: undefined;
+    validate?: undefined;
+    autofocus?: undefined;
+    overrideEditForm?: undefined;
     addAnother?: undefined;
     reorder?: undefined;
     components?: undefined;

package/lib/mjs/components/columns/editForm/Columns.edit.display.js

@@ -31,6 +31,24 @@ export default [
         key: 'tableView',
         ignore: true
     },
+    {
+        key: 'hideLabel',
+        ignore: true
+    },
+    {
+        weight: 0,
+        type: 'textfield',
+        input: true,
+        key: 'label',
+        label: 'Label',
+        placeholder: 'Field Label',
+        tooltip: 'The label for this field.',
+        validate: {
+            required: true
+        },
+        autofocus: true,
+        overrideEditForm: true
+    },
     {
         weight: 150,
         type: 'datagrid',
@@ -94,5 +112,9 @@ export default [
         tooltip: 'Will automatically adjust columns based on if nested components are hidden.',
         key: 'autoAdjust',
         input: true
-    }
+    },
+    {
+        key: 'hideLabel',
+        ignore: true
+    },
 ];

package/lib/mjs/components/container/Container.d.ts

@@ -10,6 +10,7 @@ export default class ContainerComponent extends NestedDataComponent {
     };
     constructor(...args: any[]);
     addComponents(data: any, options: any): void;
+    checkData(data: any, flags: any, row: any, components: any): void;
     focus(): void;
 }
 import NestedDataComponent from '../_classes/nesteddata/NestedDataComponent';

package/lib/mjs/components/container/Container.js

@@ -54,12 +54,8 @@ export default class ContainerComponent extends NestedDataComponent {
         flags = flags || {};
         row = row || this.data;
         components = components && _.isArray(components) ? components : this.getComponents();
-        return components.reduce((valid, comp) => {
-            return comp.checkData(data, flags, this.dataValue) && valid;
-        }, Component.prototype.checkData.call(this, data, flags, row));
-    }
-    checkChildComponentsValidity(data, dirty, row, silentCheck, isParentValid) {
-        return super.checkChildComponentsValidity(data, dirty, this.dataValue, silentCheck, isParentValid);
+        Component.prototype.checkData.call(this, data, flags, row);
+        components.forEach((comp) => comp.checkData(data, flags, this.dataValue));
     }
     focus() {
         const focusableElements = getFocusableElements(this.element);

package/lib/mjs/components/content/Content.d.ts

@@ -4,6 +4,7 @@ export default class ContentComponent extends Component {
         group: string;
         icon: string;
         preview: boolean;
+        showPreview: boolean;
         documentation: string;
         weight: number;
         schema: any;

package/lib/mjs/components/content/Content.js

@@ -16,6 +16,7 @@ export default class ContentComponent extends Component {
             group: 'layout',
             icon: 'html5',
             preview: false,
+            showPreview: false,
             documentation: '/userguide/form-building/layout-components#content',
             weight: 5,
             schema: ContentComponent.schema()

package/lib/mjs/components/datagrid/DataGrid.d.ts

@@ -70,14 +70,6 @@ export default class DataGridComponent extends NestedArrayComponent {
     setRowComponentsData(rowIndex: any, rowData: any): void;
     createRows(init: any, rebuild: any): boolean;
     createRowComponents(row: any, rowIndex: any): {};
-    /**
-     * Checks the validity of this datagrid.
-     *
-     * @param data
-     * @param dirty
-     * @return {*}
-     */
-    checkValidity(data: any, dirty: any, row: any, silentCheck: any): any;
     checkColumns(data: any, flags?: {}): {
         rebuild: boolean;
         show: boolean;

package/lib/mjs/components/datagrid/DataGrid.js

@@ -1,6 +1,7 @@
 import _ from 'lodash';
 import NestedArrayComponent from '../_classes/nestedarray/NestedArrayComponent';
 import { fastCloneDeep, getFocusableElements } from '../../utils/utils';
+import { Components } from '../Components';
 export default class DataGridComponent extends NestedArrayComponent {
     static schema(...extend) {
         return NestedArrayComponent.schema({
@@ -344,10 +345,13 @@ export default class DataGridComponent extends NestedArrayComponent {
     }
     focusOnNewRowElement(row) {
         Object.keys(row).find((key) => {
-            const focusableElements = getFocusableElements(row[key].element);
-            if (focusableElements && focusableElements[0]) {
-                focusableElements[0].focus();
-                return true;
+            const element = row[key].element;
+            if (element) {
+                const focusableElements = getFocusableElements(element);
+                if (focusableElements && focusableElements[0]) {
+                    focusableElements[0].focus();
+                    return true;
+                }
             }
             return false;
         });
@@ -387,7 +391,7 @@ export default class DataGridComponent extends NestedArrayComponent {
             }
             component.rowIndex = rowIndex;
             component.row = `${rowIndex}-${colIndex}`;
-            component.path = this.calculateComponentPath(component);
+            component.path = Components.getComponentPath(component);
         });
     }
     updateRowsComponents(rowIndex) {
@@ -470,27 +474,6 @@ export default class DataGridComponent extends NestedArrayComponent {
         });
         return components;
     }
-    /**
-     * Checks the validity of this datagrid.
-     *
-     * @param data
-     * @param dirty
-     * @return {*}
-     */
-    checkValidity(data, dirty, row, silentCheck) {
-        data = data || this.rootValue;
-        row = row || this.data;
-        if (!this.checkCondition(row, data)) {
-            this.setCustomValidity('');
-            return true;
-        }
-        if (!this.checkComponentValidity(data, dirty, row, { silentCheck })) {
-            return false;
-        }
-        const isValid = this.checkRows('checkValidity', data, dirty, true, silentCheck);
-        this.checkModal(isValid, dirty);
-        return isValid;
-    }
     checkColumns(data, flags = {}) {
         data = data || this.rootValue;
         let show = false;

package/lib/mjs/components/datamap/DataMap.js

@@ -3,6 +3,7 @@ import DataGridComponent from '../datagrid/DataGrid';
 import _ from 'lodash';
 import EventEmitter from 'eventemitter3';
 import { componentValueTypes, getComponentSavedTypes, uniqueKey } from '../../utils/utils';
+import { Components } from '../Components';
 export default class DataMapComponent extends DataGridComponent {
     static schema(...extend) {
         return Component.schema({
@@ -235,7 +236,7 @@ export default class DataMapComponent extends DataGridComponent {
             delete dataValue[key];
             const comp = components[this.valueKey];
             comp.component.key = newKey;
-            comp.path = this.calculateComponentPath(comp);
+            comp.path = Components.calculateComponentPath(comp);
             key = newKey;
         });
         const valueComponent = _.clone(this.component.valueComponent);

package/lib/mjs/components/datetime/DateTime.js

@@ -128,8 +128,6 @@ export default class DateTimeComponent extends Input {
             ...customOptions,
         };
         /* eslint-enable camelcase */
-        // Add the validators date.
-        this.validators.push('date');
     }
     get defaultSchema() {
         return DateTimeComponent.schema();

package/lib/mjs/components/day/Day.js

@@ -49,10 +49,10 @@ export default class DayComponent extends Field {
         return getComponentSavedTypes(schema) || [componentValueTypes.string];
     }
     constructor(component, options, data) {
-        if (component.maxDate) {
+        if (component.maxDate && component.maxDate.indexOf('moment(') === -1) {
             component.maxDate = moment(component.maxDate, 'YYYY-MM-DD').toISOString();
         }
-        if (component.minDate) {
+        if (component.minDate && component.minDate.indexOf('moment(') === -1) {
             component.minDate = moment(component.minDate, 'YYYY-MM-DD').toISOString();
         }
         super(component, options, data);
@@ -209,7 +209,6 @@ export default class DayComponent extends Field {
     }
     init() {
         super.init();
-        this.validators = this.validators.concat(['day', 'maxDate', 'minDate', 'minYear', 'maxYear']);
         const minYear = this.component.fields.year.minYear;
         const maxYear = this.component.fields.year.maxYear;
         this.component.maxYear = maxYear;