@manojadams/metaforms-core
Version:
React Library for rendering dynamic forms from json schema
1,422 lines (1,408 loc) • 158 kB
JavaScript
import React, { Fragment, useContext, useState, useMemo, useEffect, useRef } from 'react';
import EventEmitter$1, { EventEmitter } from 'eventemitter3';
import { Row as Row$1, Container } from 'layout-emotions';
import styled from '@emotion/styled';
function _extends() {
_extends = Object.assign ? Object.assign.bind() : function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
return true;
} catch (e) {
return false;
}
}
function _construct(Parent, args, Class) {
if (_isNativeReflectConstruct()) {
_construct = Reflect.construct.bind();
} else {
_construct = function _construct(Parent, args, Class) {
var a = [null];
a.push.apply(a, args);
var Constructor = Function.bind.apply(Parent, a);
var instance = new Constructor();
if (Class) _setPrototypeOf(instance, Class.prototype);
return instance;
};
}
return _construct.apply(null, arguments);
}
function _isNativeFunction(fn) {
return Function.toString.call(fn).indexOf("[native code]") !== -1;
}
function _wrapNativeSuper(Class) {
var _cache = typeof Map === "function" ? new Map() : undefined;
_wrapNativeSuper = function _wrapNativeSuper(Class) {
if (Class === null || !_isNativeFunction(Class)) return Class;
if (typeof Class !== "function") {
throw new TypeError("Super expression must either be null or a function");
}
if (typeof _cache !== "undefined") {
if (_cache.has(Class)) return _cache.get(Class);
_cache.set(Class, Wrapper);
}
function Wrapper() {
return _construct(Class, arguments, _getPrototypeOf(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, {
constructor: {
value: Wrapper,
enumerable: false,
writable: true,
configurable: true
}
});
return _setPrototypeOf(Wrapper, Class);
};
return _wrapNativeSuper(Class);
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _taggedTemplateLiteralLoose(strings, raw) {
if (!raw) {
raw = strings.slice(0);
}
strings.raw = raw;
return strings;
}
// A type of promise-like that resolves synchronously and supports only one observer
const _iteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.iterator || (Symbol.iterator = Symbol("Symbol.iterator"))) : "@@iterator";
const _asyncIteratorSymbol = /*#__PURE__*/ typeof Symbol !== "undefined" ? (Symbol.asyncIterator || (Symbol.asyncIterator = Symbol("Symbol.asyncIterator"))) : "@@asyncIterator";
// Asynchronously await a promise and pass the result to a finally continuation
function _finallyRethrows(body, finalizer) {
try {
var result = body();
} catch (e) {
return finalizer(true, e);
}
if (result && result.then) {
return result.then(finalizer.bind(null, false), finalizer.bind(null, true));
}
return finalizer(false, result);
}
var MSGS = {
ERROR_MSG: {
REQUIRED: "Is a required field",
PATTERN: "Pattern is invalid",
MIN: "Is not a valid value",
MIN_TEXT: "Minimum length is {CHARS} chars.",
MAX: "Out of range",
MAX_TEXT: "Maximum length is {CHARS} chars.",
DATE_INVALID: "Date is not valid",
EMAIL_INVALID: "Email is not valid"
}
};
var EMAIL_PATTERN = "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:.[a-zA-Z0-9-]+)*$";
var FORM_CONSTANTS = {
DEPENDENCY_KEY: "dependencies"
};
var DEFAULT_DATE_FORMAT = "dd/MM/yyyy";
var NEXT_RESPONSE_MODE = {
PAGE_DATA: "page-data",
FORM_DATA: "form-data"
};
var CHANGE_MODE = {
FORM_DATA: "form-data",
SECTION_DATA: "section-data"
};
var FIELD_DISPLAY_TYPES = {
TEXT: "text",
SELECT: "select"
};
var DEP_TYPE_OLD = {
EXISTS: "exists",
ENABLED: "enabled",
EQUALS: "equals",
LOAD: "load",
LOAD_OPTIONS: "load_options",
CHANGE: "change",
VALIDATION: "validation",
PROP_UPDATE: "prop_update",
PATTERN_MATCH_URL_LOADER: "pattern_match_url_loader"
};
var DEP_TYPE = {
EXISTS: "exists",
ENABLED: "enabled",
EQUALS: "equals",
LOAD: "load",
LOAD_OPTIONS: "loadOptions",
CHANGE: "change",
VALIDATION: "validation",
PROP_UPDATE: "propUpdate",
PATTERN_MATCH_URL_LOADER: "patternMatchUrlLoader"
};
var CHANGE_TYPE_OLD = {
URL_LOADER: "url_loader",
SETTER: "setter",
PROP_SETTER: "prop_setter",
EVENT_EMITTER: "event_emitter",
SETTER_CONDITION: "setter_condition"
};
var CHANGE_TYPE = {
URL_LOADER: "urlLoader",
SETTER: "setter",
PROP_SETTER: "propSetter",
EVENT_EMITTER: "eventEmitter",
SETTER_CONDITION: "setterCondition"
};
var URL_TYPE = {
REMOTE: "remote"
};
var _INTERNAL_VALUES = {
INPUT: "$input",
INITIAL: "$initial",
VALUE_FN: "$valueFn",
NOT_EMPTY: "$notempty",
CONDITION: "$condition"
};
var BUTTON_TYPE = {
NEXT: "next",
PREVIOUS: "previous",
SUBMIT: "submit"
};
var EVENTS = {
SUBMIT: "submit",
SWITCH: "switch",
VALIDATION_ERROR: "validation_error",
PAGE_CHANGE: "page_change",
_FIELD_CHANGE: "$field_change",
_FIELD_CLOSE: "$field_close",
_DISABLE_TAB: "$disable_tab",
_ENABLE_CURRENT_TAB: "$enable_current_tab",
_END_OF_PAGE: "$end_of_page",
_RESET_END_OF_PAGE: "$reset_end_of_page"
};
var DEFAULT = "default";
var SECTION_LAYOUT = {
DEFAULT: "default",
TABS: "tabs",
WIZARD: "wizard",
STEPPER: "stepper"
};
var FIELD_LAYOUT = {
DEFAULT: "column",
ROW: "row",
COLUMN: "column"
};
var FORM_ACTION = {
NEXT: "next",
PREVIOUS: "previous",
SUBMIT: "submit",
DEFAULT: "default",
CUSTOM: "custom",
RESET: "reset"
};
var DATA_LOADER = {
URL: "url",
URL_LOADDER: "url_loader",
OPTIONS_LOADER: "options_loader"
};
var API_METHOD = {
GET: "get",
POST: "post",
PUT: "put",
DELETE: "delete"
};
var CONTROLS = {
HEADER: "header",
PARAGRAPH: "paragraph",
LABEL: "label",
MONTH: "month",
DATE: "date",
SELECT: "select",
RADIO: "radio",
RADIO_BUTTON: "radio-button",
CHECKBOX: "checkbox",
EMAIL: "email",
NUMBER: "number",
PHONE: "phone",
PASSWORD: "password",
SEARCH: "search",
HINT: "hint",
MODALSEARCH: "modalsearch",
FILE: "file",
MULTITEXT: "multitext",
MULTISELECT: "multiselect",
TEXT: "text",
INPUT_MASK: "input-mask",
TEXT_FIELD: "text_field",
TEMPATE: "template",
TEXT_CUSTOM: "text_custom",
CURRENCY: "currency"
};
var cssClassMap = {
md: "mcol-md-",
lg: "mcol-lg-",
sm: "mcol-sm-",
xs: "mcol-",
offset: "moffset-",
"default": "mcol-md"
};
var FormUtils = /*#__PURE__*/function () {
function FormUtils() {}
FormUtils.getCssClassName = function getCssClassName(prop) {
if (!prop) {
return "";
}
var md = prop.md ? cssClassMap.md + prop.md : "";
var lg = prop.lg ? cssClassMap.lg + prop.lg : "";
var sm = prop.sm ? cssClassMap.sm + prop.sm : "";
var xs = prop.xs ? cssClassMap.xs + prop.xs : "";
var offset = prop.offset ? cssClassMap.offset + prop.offset : "";
return (offset + " " + xs + " " + sm + " " + md + " " + lg).trim();
};
FormUtils.isFormControl = function isFormControl(prop) {
if (prop.type === "section" || prop.type === "group") {
return false;
}
return true;
};
FormUtils.getVerticalSpacing = function getVerticalSpacing(theme) {
if (theme) {
switch (theme) {
case "mui":
default:
return "my-2 my-md-3";
}
}
return "";
};
FormUtils.getAlignment = function getAlignment(align) {
return align ? "wrow-" + align : "";
};
FormUtils.getPadding = function getPadding(theme) {
if (theme) {
switch (theme) {
case "bootstrap":
return "py-md-3";
case "mui":
return "py-md-3";
}
}
return "";
};
FormUtils.getUUID = function getUUID(prefix) {
if (prefix === void 0) {
prefix = "";
}
var randomNum = Math.floor(Math.random() * 100 + Date.now());
return prefix + "_" + randomNum;
};
FormUtils.hasSections = function hasSections(fields) {
return fields.find(function (field) {
return field.meta.type === "section";
}) !== undefined;
};
FormUtils.getFormDefaultButtons = function getFormDefaultButtons() {
return [{
name: FORM_ACTION.SUBMIT,
meta: {
type: FORM_ACTION.SUBMIT,
displayName: "Save",
displayType: "button",
url: "",
displayProps: {
xs: 12,
md: 2
},
className: "btn-primary my-4 d-block w-100"
}
}];
};
FormUtils.getFormGroupDefaultButtons = function getFormGroupDefaultButtons() {
return [{
name: "previous",
meta: {
type: "previous",
displayName: "Previous"
}
}, {
name: "next",
meta: {
type: "next",
displayName: "Next"
}
}, {
name: "submit",
meta: {
type: "submit",
displayName: "Submit"
}
}];
};
FormUtils.getThemeProp = function getThemeProp(theme, prop) {
if (theme.tabs && theme !== null && theme !== void 0 && theme.tabs[prop]) {
return theme.tabs[prop];
}
return "";
};
FormUtils.getNormalizedFormData = function getNormalizedFormData(formData) {
var newFormData = {};
Object.keys(formData).forEach(function (key) {
newFormData[key] = {};
Object.keys(formData[key]).forEach(function (key2) {
newFormData[key][key2] = formData[key][key2].value;
});
});
return newFormData;
};
FormUtils.getBase64 = function getBase64(file) {
return new Promise(function (resolve, reject) {
if (file) {
var fileReader = new FileReader();
fileReader.readAsDataURL(file);
fileReader.onload = function () {
return resolve(fileReader.result);
};
fileReader.onerror = reject;
} else {
resolve(null);
}
});
};
FormUtils.getFormFieldValue = function getFormFieldValue(formField) {
try {
var _exit = false;
var _this = this;
switch (formField.displayType) {
case CONTROLS.FILE:
var _temp4 = function () {
if (formField.files) {
var _temp2 = function _temp2() {
var _formField$config, _formField$config2, _name3;
var _name = (_name3 = {
name: formField.value
}, _name3[(_formField$config = formField.config) !== null && _formField$config !== void 0 && _formField$config.blob ? "files" : "filesData"] = (_formField$config2 = formField.config) !== null && _formField$config2 !== void 0 && _formField$config2.blob ? formField.files : _filesData2, _name3);
_exit = true;
return _name;
};
var _files = Array.from(formField.files);
var _filesData2;
var _temp = function (_formField$config3) {
if (!((_formField$config3 = formField.config) !== null && _formField$config3 !== void 0 && _formField$config3.blob)) {
return Promise.resolve(Promise.all(_files.map(function (_file) {
try {
return Promise.resolve(_this.getBase64(_file));
} catch (e) {
return Promise.reject(e);
}
}))).then(function (_Promise$all) {
_filesData2 = _Promise$all;
});
}
}();
return _temp && _temp.then ? _temp.then(_temp2) : _temp2(_temp);
} else return function () {
if (formField.file && formField.file instanceof File) {
var _formField$config5;
var _temp3 = function _temp3(_this$getBase) {
var _formField$config4, _name4;
var _name2 = (_name4 = {
name: _formField$value2
}, _name4[(_formField$config4 = formField.config) !== null && _formField$config4 !== void 0 && _formField$config4.blob ? "file" : "fileData"] = _this$getBase, _name4);
_exit = true;
return _name2;
};
var _formField$value2 = formField.value,
_formField$config$blo = (_formField$config5 = formField.config) === null || _formField$config5 === void 0 ? void 0 : _formField$config5.blob;
return _formField$config$blo ? _temp3(formField.file) : Promise.resolve(_this.getBase64(formField.file)).then(_temp3);
}
}();
}();
return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(function (_result) {
return _exit ? _result : null;
}) : _exit ? _temp4 : null);
default:
return Promise.resolve(formField.value);
}
} catch (e) {
return Promise.reject(e);
}
};
FormUtils.updateFormData = function updateFormData(formData, newFormData, formatter) {
var _this2 = this;
return new Promise(function (resolve) {
var allPendingUpdates = Object.keys(formData).flatMap(function (key) {
return Object.keys(formData[key]).map(function (key2) {
var prop = formData[key][key2].prop;
return _this2.getFormFieldValue(formData[key][key2]).then(function (fieldValue) {
if (prop) {
if (!newFormData[prop]) {
newFormData[prop] = {};
}
if (formatter[key2]) {
newFormData[prop][key2] = formatter[key2](fieldValue);
} else {
newFormData[prop][key2] = fieldValue;
}
} else {
if (prop !== null) {
if (formatter[key2]) {
newFormData[key2] = formatter[key2](fieldValue);
} else {
newFormData[key2] = fieldValue;
}
}
}
});
});
});
Promise.all(allPendingUpdates).then(function () {
return _this2.updateNestedFormData(newFormData);
}).then(function () {
return resolve(newFormData);
});
});
};
FormUtils.updateSectionFormData = function updateSectionFormData(formData, newFormData, formatter) {
try {
var _this3 = this;
return Promise.resolve(new Promise(function (resolve) {
if (!formData) {
resolve({});
return {};
}
var allPendingUpdates = Object.keys(formData).map(function (key) {
try {
var prop = formData[key].prop;
var formDataKey = formData[key];
return Promise.resolve(_this3.getFormFieldValue(formDataKey)).then(function (fieldValue) {
if (prop) {
if (!newFormData[prop]) {
newFormData[prop] = {};
}
if (formatter[key]) {
newFormData[prop][key] = formatter[key](fieldValue);
} else {
newFormData[prop][key] = fieldValue;
}
} else {
if (prop !== null) {
if (formatter[key]) {
newFormData[key] = formatter[key](fieldValue);
} else {
newFormData[key] = fieldValue;
}
}
}
});
} catch (e) {
return Promise.reject(e);
}
});
return Promise.all(allPendingUpdates).then(function () {
return _this3.updateNestedFormData(newFormData);
}).then(function () {
return resolve(newFormData);
});
}));
} catch (e) {
return Promise.reject(e);
}
};
FormUtils.updateNestedFormData = function updateNestedFormData(formData) {
try {
var _this4 = this;
Object.keys(formData).forEach(function (key) {
try {
var _temp6 = function () {
if (typeof formData[key] === "object") {
var props = key.split("#");
var _temp5 = function () {
if (props.length > 1) {
if (!formData[props[0]]) {
formData[props[0]] = {};
}
return Promise.resolve(_this4.updateNestedProp(formData[props[0]], props.slice(1), formData[key])).then(function () {
delete formData[key];
});
}
}();
if (_temp5 && _temp5.then) return _temp5.then(function () {});
}
}();
return Promise.resolve(_temp6 && _temp6.then ? _temp6.then(function () {}) : void 0);
} catch (e) {
return Promise.reject(e);
}
});
return Promise.resolve();
} catch (e) {
return Promise.reject(e);
}
};
FormUtils.updateNestedProp = function updateNestedProp(formData, props, value) {
try {
var _this5 = this;
var _temp8 = function () {
if (props.length > 0) {
var _temp7 = function () {
if (props.length === 1) {
if (formData) {
formData[props[0]] = value;
}
} else {
if (!formData[props[0]]) {
formData[props[0]] = {};
}
return Promise.resolve(_this5.updateNestedProp(formData[props[0]], props.slice(1), value)).then(function () {});
}
}();
if (_temp7 && _temp7.then) return _temp7.then(function () {});
}
}();
return Promise.resolve(_temp8 && _temp8.then ? _temp8.then(function () {}) : void 0);
} catch (e) {
return Promise.reject(e);
}
};
FormUtils.getSearchValue = function getSearchValue(options, value) {
if (value !== undefined && options && options.length > 0) {
return options.find(function (option) {
return option.value === value;
});
}
return value;
};
FormUtils.getDataFromValueKey = function getDataFromValueKey(data, props) {
var values = props.split("#");
var nestedData = data;
if (values) {
values.forEach(function (val) {
nestedData = nestedData[val];
});
return nestedData;
}
return data;
};
FormUtils.updateParams = function updateParams(queryParams, eventType, currentValue) {
if (queryParams && eventType) {
var updatedQueryParams = [];
queryParams.forEach(function (param) {
var key = param[0],
val = param[1];
var actualVal = val;
if (val) {
switch (val) {
case _INTERNAL_VALUES.INPUT:
case _INTERNAL_VALUES.INITIAL:
actualVal = val === eventType ? currentValue : "";
break;
}
}
updatedQueryParams.push([key, actualVal]);
});
return updatedQueryParams;
}
return queryParams;
};
FormUtils.updateBodyParams = function updateBodyParams(requestBody, requestBodyParams) {
if (requestBodyParams && requestBodyParams.length > 0) {
var stringified = JSON.stringify(requestBody);
requestBodyParams.forEach(function (param, idx) {
if (param) {
stringified = stringified.replace("$" + idx, String(param));
}
});
return JSON.parse(stringified);
}
return requestBody;
};
FormUtils.updateFieldProp = function updateFieldProp(field, prop, value) {
var props = prop.split("#");
if (props.length > 1) {
props.reduce(function (acc, item, index) {
if (index === props.length - 1) {
acc[item] = value;
} else {
if (!acc[item]) {
acc[item] = {};
}
}
return acc[item];
}, field);
} else {
if (!field[prop]) {
field[prop] = {};
}
field[prop] = value;
}
};
FormUtils.getDateString = function getDateString(date) {
var offset = date.getTimezoneOffset() * 60000;
var dateWithOffset = new Date(date.getTime() - offset);
return dateWithOffset.toISOString().substring(0, 10);
};
FormUtils.getLocalDateStringFormat = function getLocalDateStringFormat(inputDateString, inputFormat) {
if (inputDateString && inputFormat === DEFAULT_DATE_FORMAT) {
try {
var parts = inputDateString.split("/");
var mm = parts[0];
var dd = parts[1];
var yy = parts[2];
return dd + "/" + mm + "/" + yy;
} catch (error) {
return inputDateString;
}
}
return inputDateString;
};
FormUtils.cleanupSchema = function cleanupSchema(schema) {
var newFields = [];
schema.fields && schema.fields.forEach(function (field) {
if (field) {
newFields.push(field);
}
});
schema.fields = newFields;
return schema;
};
FormUtils.createFileInput = function createFileInput(fileWidthClass, fieldName, accept, displayLabel, onChangeCallback) {
var ele = document.createElement("input");
ele.setAttribute("type", "file");
ele.className = "position-absolute opacity-0 " + fileWidthClass + " h-100";
ele.setAttribute("name", fieldName);
ele.setAttribute("accept", accept || "");
ele.setAttribute("title", displayLabel || "");
ele.addEventListener("change", onChangeCallback);
return ele;
};
FormUtils.resolveButtonDependencies = function resolveButtonDependencies(deps, page) {
if (deps && deps.exists) {
var ref = deps.exists.ref;
if (!ref) {
return true;
}
switch (ref) {
case "page_number":
{
var pageNumber = page.pageNumber;
var pageNumberFromDependency = parseInt(deps.exists.value);
if (pageNumberFromDependency === pageNumber) {
return true;
}
return false;
}
}
}
return true;
};
FormUtils.getIconNameByPosition = function getIconNameByPosition(positionType, allIcons) {
if (allIcons) {
var allIconKeys = Object.keys(allIcons);
var iconMatch = allIconKeys.find(function (name) {
return allIcons[name].type === positionType;
});
return iconMatch;
}
return "";
};
return FormUtils;
}();
var MetaFormUpdater = /*#__PURE__*/function () {
function MetaFormUpdater(name, metaform) {
this.metaformMap = new Map();
this.metaformMap.set(name, metaform);
}
var _proto = MetaFormUpdater.prototype;
_proto.updateField = function updateField(section, field, value) {
var defaultForm = this.metaformMap.get(SECTION_LAYOUT.DEFAULT);
if (defaultForm) {
defaultForm.updateField(section, field, value);
}
};
_proto.setFieldError = function setFieldError(section, field, error) {
var defaultForm = this.metaformMap.get(SECTION_LAYOUT.DEFAULT);
if (defaultForm) {
defaultForm.setError(section, field, error);
}
};
_proto.updateFormField = function updateFormField(formName, section, field, value) {
var defaultForm = this.metaformMap.get(formName);
if (defaultForm) {
defaultForm.updateField(section, field, value);
}
};
_proto.setFormFieldError = function setFormFieldError(formName, section, field, error) {
var defaultForm = this.metaformMap.get(formName);
if (defaultForm) {
defaultForm.setError(section, field, error);
}
};
_proto.add = function add(name, metaform) {
this.metaformMap.set(name, metaform);
};
_proto.destroy = function destroy(name) {
if (this.metaformMap && this.metaformMap.get(name)) {
this.metaformMap["delete"](name);
}
};
return MetaFormUpdater;
}();
var metaAPI = {
metaForm: new MetaFormUpdater(SECTION_LAYOUT.DEFAULT, null)
};
var TVALUE_MAP_TYPE_REF = {
fieldValue: "fieldValue",
fieldProp: "fieldProp"
};
var MetaformEvent = /*#__PURE__*/function (_Event) {
_inheritsLoose(MetaformEvent, _Event);
function MetaformEvent() {
return _Event.apply(this, arguments) || this;
}
return MetaformEvent;
}( /*#__PURE__*/_wrapNativeSuper(Event));
var ValidationUtil = /*#__PURE__*/function () {
function ValidationUtil() {}
ValidationUtil.updateMaxError = function updateMaxError(meta, value, setError) {
var hasError = false;
var maxValue = this.getValidationValue(meta.validation, "max");
var maxErrorMsg = this.getValidationErrorMsg(meta.validation, "max") || this.getValidationErrorMsg(meta.validation, "maxDetail");
switch (meta.displayType) {
case CONTROLS.TEXT:
case CONTROLS.PASSWORD:
case CONTROLS.TEXT_FIELD:
if (value) {
var strValue = value;
var maxLength = parseInt(maxValue);
if (strValue.length > maxLength) {
var errorMsg = maxErrorMsg || MSGS.ERROR_MSG.MAX_TEXT.replace("{CHARS}", maxLength.toString());
setError(true, errorMsg);
hasError = true;
return hasError;
}
}
break;
case CONTROLS.NUMBER:
case CONTROLS.CURRENCY:
if (value) {
var _strValue = value ? value + "" : "";
var val = parseInt(_strValue);
if (val > parseInt(maxValue)) {
var _errorMsg = maxErrorMsg || MSGS.ERROR_MSG.MAX;
setError(true, _errorMsg);
hasError = true;
return hasError;
}
}
break;
case CONTROLS.MONTH:
case CONTROLS.DATE:
if (value) {
var _strValue2 = value ? value + "" : "";
var valDate = new Date(_strValue2);
var maxDate = new Date(maxValue);
if (valDate.getTime() > maxDate.getTime()) {
var _errorMsg2 = maxErrorMsg || MSGS.ERROR_MSG.MAX;
setError(true, _errorMsg2);
hasError = true;
return hasError;
}
}
}
return hasError;
};
ValidationUtil.updateMinError = function updateMinError(meta, value, setError) {
var hasError = false;
var minValue = this.getValidationValue(meta.validation, "min");
var minErrorMsg = this.getValidationErrorMsg(meta.validation, "min") || this.getValidationErrorMsg(meta.validation, "minDetail");
switch (meta.displayType) {
case CONTROLS.TEXT:
case CONTROLS.PASSWORD:
case CONTROLS.TEXT_FIELD:
if (value) {
var strValue = value;
var minLength = parseInt(minValue);
if (strValue.length < minLength) {
var errorMsg = minErrorMsg || MSGS.ERROR_MSG.MIN_TEXT.replace("{CHARS}", minLength.toString());
setError(true, errorMsg);
hasError = true;
return hasError;
}
}
break;
case CONTROLS.NUMBER:
case CONTROLS.CURRENCY:
if (value) {
var _strValue3 = value ? value + "" : "";
var val = parseInt(_strValue3);
if (val < parseInt(minValue)) {
var _errorMsg3 = minErrorMsg || MSGS.ERROR_MSG.MIN;
setError(true, _errorMsg3);
hasError = true;
return hasError;
}
}
break;
case CONTROLS.MONTH:
case CONTROLS.DATE:
if (value) {
var _strValue4 = value ? value + "" : "";
var valDate = new Date(_strValue4);
var minDate = new Date(minValue);
if (valDate.getTime() < minDate.getTime()) {
var _errorMsg4 = minErrorMsg || MSGS.ERROR_MSG.MIN;
setError(true, _errorMsg4);
hasError = true;
return hasError;
}
}
}
return hasError;
};
ValidationUtil.isEmptyField = function isEmptyField(value) {
if (value === "" || value === undefined || value === null) {
return true;
}
return false;
};
ValidationUtil.getValidationValue = function getValidationValue(validation, validationKey) {
if (!validation) {
return undefined;
}
switch (typeof validation[validationKey]) {
case "boolean":
case "string":
case "number":
return validation[validationKey];
case "object":
{
var validationProp = validation[validationKey];
return validationProp === null || validationProp === void 0 ? void 0 : validationProp.value;
}
}
return undefined;
};
ValidationUtil.getValidationErrorMsg = function getValidationErrorMsg(validation, validationKey) {
if (!validation) {
return "";
}
switch (typeof validation[validationKey]) {
case "boolean":
case "string":
case "number":
return "";
case "object":
{
var validationProp = validation[validationKey];
return validationProp === null || validationProp === void 0 ? void 0 : validationProp.errorMsg;
}
}
return "";
};
ValidationUtil.validateFormSection = function validateFormSection(form, sectionName) {
var _this = this;
var hasErrors = false;
if (form && form[sectionName]) {
Object.keys(form[sectionName]).forEach(function (field) {
var formField = form[sectionName][field];
if (formField.display) {
if (formField.isDisabled) {
formField.error.hasError = false;
formField.error.errorMsg = "";
} else {
if (formField.value !== false && formField.value !== 0) {
var _formField$validation, _formField$validation2;
if ((_formField$validation = formField.validation) !== null && _formField$validation !== void 0 && _formField$validation.required && !formField.value) {
var requiredValue = _this.getValidationValue(formField.validation, "required");
if (requiredValue) {
formField.error.hasError = true;
formField.error.errorMsg = _this.getValidationErrorMsg(formField.validation, "required") || _this.getValidationErrorMsg(formField.validation, "requiredDetail") || MSGS.ERROR_MSG.REQUIRED;
hasErrors = true;
return;
}
} else {
formField.error.hasError = false;
formField.error.errorMsg = "";
}
if (formField.value && (_formField$validation2 = formField.validation) !== null && _formField$validation2 !== void 0 && _formField$validation2.pattern) {
var patternValue = _this.getValidationValue(formField.validation, "pattern");
if (patternValue) {
var regexp = new RegExp(patternValue);
if (!regexp.test(formField.value)) {
formField.error.hasError = true;
formField.error.errorMsg = _this.getValidationErrorMsg(formField.validation, "pattern") || _this.getValidationErrorMsg(formField.validation, "patternDetail") || MSGS.ERROR_MSG.PATTERN;
hasErrors = true;
return;
} else {
formField.error.hasError = false;
formField.error.errorMsg = "";
}
}
}
if (formField.value !== undefined) {
var _formField$validation3, _formField$validation4;
if (((_formField$validation3 = formField.validation) === null || _formField$validation3 === void 0 ? void 0 : _formField$validation3.min) !== undefined) {
_this.updateMinError(formField, formField.value, function (hasError, errorMsg) {
formField.error.hasError = hasError;
formField.error.errorMsg = errorMsg;
hasErrors = true;
});
}
if (((_formField$validation4 = formField.validation) === null || _formField$validation4 === void 0 ? void 0 : _formField$validation4.max) !== undefined) {
_this.updateMaxError(formField, formField.value, function (hasError, errorMsg) {
formField.error.hasError = hasError;
formField.error.errorMsg = errorMsg;
hasErrors = true;
});
}
}
}
}
}
});
}
return hasErrors;
};
ValidationUtil.parseCondition = function parseCondition(form, condition, section) {
var _this2 = this;
var parsedCondition = "";
condition.forEach(function (c) {
var _leftOperand$section;
var leftOperand = c[0],
operator = c[1],
rightOperand = c[2],
nextCondition = c[3];
var lSection = (_leftOperand$section = leftOperand === null || leftOperand === void 0 ? void 0 : leftOperand.section) != null ? _leftOperand$section : section;
var lField = _this2.getField(form, lSection, leftOperand.ref);
var lValue = lField.value === "" ? '""' : lField.value;
var rValue;
if (rightOperand && typeof rightOperand === "object" && "ref" in rightOperand) {
var _rightOperand$section;
var rSection = (_rightOperand$section = rightOperand === null || rightOperand === void 0 ? void 0 : rightOperand.section) != null ? _rightOperand$section : section;
var rField = _this2.getField(form, rSection, rightOperand.ref);
rValue = rField.value;
} else {
rValue = rightOperand;
}
rValue = rValue === "" ? '""' : rValue;
parsedCondition += "(" + lValue + operator + rValue + ")" + (nextCondition != null ? nextCondition : "");
});
var evalCondition = parsedCondition ? Function("return " + parsedCondition) : function () {
return false;
};
return evalCondition(parsedCondition);
};
ValidationUtil.getField = function getField(form, section, field) {
return form[section][field];
};
return ValidationUtil;
}();
var DependencyUtil = /*#__PURE__*/function () {
function DependencyUtil() {}
DependencyUtil.initDependencies = function initDependencies(form, section, fields) {
var _this = this;
fields && fields.forEach(function (field) {
var _field$meta;
if (field && field !== null && field !== void 0 && (_field$meta = field.meta) !== null && _field$meta !== void 0 && _field$meta.dependencies) {
var _field$meta2;
_this.setDependencies(form, section, field.name, field === null || field === void 0 ? void 0 : (_field$meta2 = field.meta) === null || _field$meta2 === void 0 ? void 0 : _field$meta2.dependencies);
}
if (field.fields && field.fields.length > 0) {
_this.initDependencies(form, field.name, field.fields);
}
});
};
DependencyUtil.getDependencies = function getDependencies(form, section, field) {
return form[section][field]["dependencies"];
};
DependencyUtil.setDependencies = function setDependencies(form, section, field, dependencies) {
var _this2 = this;
if (!dependencies) return;
Object.keys(dependencies).forEach(function (type) {
if (dependencies[type] instanceof Array) {
dependencies[type].forEach(function (dependency) {
_this2.setDependency(form, dependency, section, type, field);
});
} else {
_this2.setDependency(form, dependencies[type], section, type, field);
}
});
};
DependencyUtil.setDependency = function setDependency(form, dependency, section, type, field) {
var ref = dependency.ref || "";
var formSection = (dependency === null || dependency === void 0 ? void 0 : dependency.section) || section;
var value = dependency === null || dependency === void 0 ? void 0 : dependency.value;
var valueFn = dependency === null || dependency === void 0 ? void 0 : dependency.valueFn;
var D_KEY = FORM_CONSTANTS.DEPENDENCY_KEY;
if (ref && !form[formSection][ref][D_KEY]) {
form[formSection][ref][D_KEY] = [];
}
var extraParams = {};
switch (type) {
case DEP_TYPE_OLD.PATTERN_MATCH_URL_LOADER:
case DEP_TYPE.PATTERN_MATCH_URL_LOADER:
extraParams = {
pattern: dependency.pattern,
changeType: dependency.type,
urlType: dependency.urlType,
defaultValue: dependency.defaultValue
};
case DEP_TYPE.LOAD:
{
var url = dependency.url;
var labelKey = dependency === null || dependency === void 0 ? void 0 : dependency.labelKey;
var valueKey = dependency === null || dependency === void 0 ? void 0 : dependency.valueKey;
var responseKey = dependency.responseKey;
var queryParams = dependency.queryParams;
var pathParams = dependency.pathParams;
form[formSection][ref][D_KEY].push(_extends({
section: section,
type: type,
field: field,
url: url,
valueKey: valueKey,
labelKey: labelKey,
responseKey: responseKey,
queryParams: queryParams,
pathParams: pathParams
}, extraParams));
}
break;
case DEP_TYPE_OLD.LOAD_OPTIONS:
case DEP_TYPE.LOAD_OPTIONS:
{
var valueMap = dependency.valueMap;
form[formSection][ref][D_KEY].push({
section: section,
type: type,
field: field,
valueMap: valueMap
});
}
break;
case DEP_TYPE.EQUALS:
{
form[formSection][ref][D_KEY].push({
section: section,
type: type,
field: field,
value: value,
currentValue: dependency.currentValue,
resetValue: dependency.resetValue
});
}
break;
case DEP_TYPE.VALIDATION:
case DEP_TYPE.CHANGE:
{
var changeType = dependency.type;
var _valueMap = dependency.valueMap;
form[formSection][ref][D_KEY].push({
section: section,
type: type,
field: field,
value: value,
valueMap: _valueMap,
changeType: changeType
});
}
break;
case DEP_TYPE_OLD.PROP_UPDATE:
case DEP_TYPE.PROP_UPDATE:
{
var propValue = dependency.propValue;
var propName = dependency.propName;
var _valueMap2 = dependency.valueMap;
form[formSection][ref][D_KEY].push({
section: section,
type: type,
field: field,
value: value,
valueMap: _valueMap2,
propName: propName,
propValue: propValue
});
}
break;
case DEP_TYPE.EXISTS:
extraParams = {
condition: dependency.condition
};
form[formSection][ref][D_KEY].push(_extends({
section: section,
type: type,
field: field,
value: value,
valueFn: valueFn
}, extraParams));
break;
default:
form[formSection][ref][D_KEY].push({
section: section,
type: type,
field: field,
value: value,
valueFn: valueFn
});
}
};
DependencyUtil.handleDependencies = function handleDependencies(metaform, section, fieldName, value, fieldDisplayed) {
var _this3 = this;
return new Promise(function (sucessCallback) {
var deps = _this3.getDependencies(metaform.form, section, fieldName);
var totalDeps = deps && deps.length > 0 ? deps.length : 0;
if (totalDeps === 0) {
sucessCallback(true);
return;
}
var resolvedDepCount = 0;
var resolved = {
next: function next() {
resolvedDepCount++;
if (resolvedDepCount === totalDeps) {
sucessCallback();
}
}
};
deps && deps.forEach(function (dep) {
var type = dep.type;
switch (type) {
case DEP_TYPE.EXISTS:
{
var depValue = dep.value;
var field = dep.field;
if (fieldDisplayed) {
if (value !== undefined) {
var _fieldDisplayed;
if (depValue === undefined) {
_fieldDisplayed = true;
metaform.setFieldDisplay(dep.section, field, _fieldDisplayed);
} else {
var conditionMatch = false;
if (Array.isArray(depValue)) {
if (depValue.indexOf(value) >= 0) {
conditionMatch = true;
}
} else {
switch (depValue) {
case _INTERNAL_VALUES.NOT_EMPTY:
conditionMatch = value !== "";
break;
case _INTERNAL_VALUES.VALUE_FN:
{
var valueFn = dep.valueFn;
if (valueFn) {
var fn = metaform.getFn(valueFn);
if (fn) {
conditionMatch = fn(value);
}
}
}
break;
case _INTERNAL_VALUES.CONDITION:
if (dep.condition) {
conditionMatch = ValidationUtil.parseCondition(metaform.form, dep.condition, dep.section || section);
}
break;
default:
conditionMatch = value === depValue;
}
}
_fieldDisplayed = conditionMatch;
metaform.setFieldDisplay(dep.section, field, conditionMatch);
}
var subfield = metaform.getField(dep.section, field);
_this3.handleDependencies(metaform, dep.section, field, subfield.value, _fieldDisplayed).then(function () {
return resolved.next();
});
} else {
resolved.next();
}
} else {
metaform.setFieldDisplay(dep.section, field, false);
var _subfield = metaform.getField(dep.section, field);
_this3.handleDependencies(metaform, dep.section, field, _subfield.value, false).then(function () {
return resolved.next();
});
}
}
break;
case DEP_TYPE.LOAD:
if (value && dep.url) {
var _dep$requestType;
var _field = dep.field;
metaform.setFieldOptions(dep.section, _field, []);
metaform.getData({
requestType: (_dep$requestType = dep.requestType) != null ? _dep$requestType : API_METHOD.GET,
requestBody: dep.requestBody,
requestBodyParams: dep.requestBodyParams,
queryParams: dep.queryParams
}, value, section).then(function (results) {
metaform.setFieldOptions(dep.section, _field, results);
resolved.next();
})["catch"](function () {
resolved.next();
});
} else {
resolved.next();
}
break;
case DEP_TYPE.LOAD_OPTIONS:
{
var _field2 = dep.field;
var valueMap = dep.valueMap;
if (valueMap !== undefined) {
if (valueMap[value]) {
metaform.setFieldOptions(dep.section, _field2, valueMap[value]);
}
}
resolved.next();
}
break;
case DEP_TYPE.ENABLED:
{
var _field3 = dep.field;
metaform.setFieldDisabled(dep.section, _field3, value !== dep.value);
resolved.next();
}
break;
case DEP_TYPE.EQUALS:
{
var _field4 = dep.field;
if (value === dep.value) {
metaform.setField(dep.section, _field4, dep.currentValue);
} else if (dep.resetValue !== undefined) {
metaform.setField(dep.section, _field4, dep.resetValue);
}
resolved.next();
}
break;
case DEP_TYPE.CHANGE:
{
var changeType = dep.changeType;
if (changeType) {
switch (changeType) {
case "setter":
if (dep.valueMap !== undefined && dep.valueMap[value] !== undefined) {
metaform.setField(dep.section, dep.field, dep.valueMap[value]);
var _field5 = metaform.getField(dep.section, dep.field);
_this3.handleDependencies(metaform, dep.section, dep.field, dep.valueMap[value], _field5.display).then(function () {
return resolved.next();
});
} else {
resolved.next();
}
break;
default:
resolved.next();
}
} else {
resolved.next();
}
}
break;
case DEP_TYPE.VALIDATION:
{
var fieldProp = metaform.getFieldProp(dep.section, dep.field, dep.type);
fieldProp[dep.changeType] = dep.valueMap[value];
metaform.setFieldProp(dep.section, dep.field, dep.type, fieldProp);
resolved.next();
}
break;
case DEP_TYPE_OLD.PATTERN_MATCH_URL_LOADER:
case DEP_TYPE.PATTERN_MATCH_URL_LOADER:
{
var _changeType = dep.changeType;
if (dep.pattern) {
var pattern = new RegExp(dep.pattern);
if (pattern.test(value)) {
if (_changeType) {
switch (_changeType) {
case CHANGE_TYPE.URL_LOADER:
{
var itemConfig = {
type: CHANGE_TYPE.URL_LOADER,
url: dep.url,
urlType: dep.urlType,
labelKey: dep.labelKey,
valueKey: dep.valueKey,
queryParams: dep.queryParams
};
metaform.getData(itemConfig, value, dep.section, _INTERNAL_VALUES.INPUT).then(function (results) {
var fieldDisplayType = metaform.getFieldProp(dep.section, dep.field, "displayType");
metaform.setDisplayTypeFieldProp(fieldDisplayType, dep.section, dep.field, results, dep);
resolved.next();
})["catch"](function (err) {
metaform.handleError(err, dep.section, dep.field);
resolved.next();
});
}
break;
default:
resolved.next();
}
} else {
resolved.next();
}
} else {
resolved.next();
}
} else {
resolved.next();
}
}
break;
case DEP_TYPE.PROP_UPDATE:
case DEP_TYPE_OLD.PROP_UPDATE:
if (dep.value !== undefined) {
if (value === dep.value) {
metaform.setFieldProp(dep.section, dep.field, dep.propName, dep.propValue);
resolved.next();
} else {
resolved.next();
}
} else if (dep.valueMap !== undefined) {
var mappedValue = dep.valueMap[value];
if (mappedValue !== undefined) {
if (typeof mappedValue !== "object") {
metaform.setFieldProp(dep.section, dep.field, dep.propName, mappedValue);
resolved.next();
} else {
var _type = mappedValue.type;
if (_type !== undefined) {
switch (_type) {
case TVALUE_MAP_TYPE_REF.fieldValue:
{
var ref = mappedValue.ref;
var fieldValue = metaform.getFieldProp(mappedValue.section || dep.section, ref, "value");
metaform.setFieldProp(dep.section, dep.field, dep.propName, fieldValue);
resolved.next();