kwikid-forms 0.0.0-watch

package/esm2015/lib/renderer/form-view/helpers/form-view.fields.helper.js

@@ -0,0 +1,146 @@
+import { __awaiter } from "tslib";
+import { hasKey, isNotEmpty } from "./form-view.common.helper";
+export const findFieldFromKey = (fields, key) => {
+    const field = fields.find((field) => {
+        if (field.key === key) {
+            return field;
+        }
+    });
+    return field;
+};
+export const findFieldIndexFromKey = (fields, key) => {
+    let fieldIndex;
+    fieldIndex = fields.findIndex((_) => {
+        return key === _.key;
+    });
+    return fieldIndex;
+};
+export const getSearchTextOptionsFromRemoteFile = (field, childField, formGroup) => __awaiter(void 0, void 0, void 0, function* () {
+    const parentFieldValue = formGroup.controls[field.key].value;
+    // Determine the URL of the remote file to fetch
+    let fileUrl;
+    if (childField.regexToGetJsonRemoteUrlKey) {
+        const fileKey = parentFieldValue.match(childField.regexToGetJsonRemoteUrlKey)[0];
+        fileUrl = childField.jsonRemoteUrlMapping[fileKey];
+    }
+    else {
+        fileUrl = childField.fileUrl;
+    }
+    // Return early if there is no file URL
+    if (!fileUrl)
+        return;
+    // Fetch the remote file and parse its JSON data
+    const response = yield fetch(fileUrl);
+    const data = yield response.json();
+    // Return the data for the given parent field value
+    return data[parentFieldValue];
+});
+export const getSearchTextOptionsFromFieldConfig = (field, childField, formGroup) => {
+    let options;
+    const fieldValue = formGroup.controls[field.key].value;
+    if (isNotEmpty(childField["json"])) {
+        options = childField["json"][fieldValue];
+    }
+    return options;
+};
+export const formatSearchTextOptions = (options) => {
+    return options.map(({ title }) => title);
+};
+export const formatDateToStandardFormat = (date) => {
+    let formattedDate;
+    let year = date.year;
+    let month = date.month;
+    let day = date.day;
+    formattedDate = `${day}-${month + 1}-${year}`;
+    return formattedDate;
+};
+export function highlightFieldError(field, error) {
+    field.invalid = error;
+    field.focus = error;
+    // if (!error) {
+    //   field["messages"] = field["messages"].filter(function (fieldMessage: {
+    //     type: string;
+    //     message: string;
+    //   }) {
+    //     return fieldMessage.type === "error";
+    //   });
+    // }
+    return field;
+}
+export const addMessage = (field, message) => {
+    const isDuplicateMessage = (messages, message) => {
+        return messages.some((fieldMessage) => {
+            return (fieldMessage.type === message.type &&
+                fieldMessage.message === message.message);
+        });
+    };
+    field["messages"] = [];
+    if (hasKey(field, "messages")) {
+        if (!isDuplicateMessage(field["messages"], message)) {
+            field["messages"].push({
+                type: message.type,
+                message: message.message
+            });
+        }
+    }
+    else {
+        field["messages"] = [{ type: message.type, message: message.message }];
+    }
+    return field;
+};
+export const removeMessage = (field, message) => {
+    field["messages"] = field["messages"].filter(function (fieldMessage) {
+        return fieldMessage.type !== message.type;
+    });
+    return field;
+};
+export function setFieldError(fields, errors, key, error) {
+    const fieldIndex = fields.findIndex((field) => {
+        return field.key === key;
+    });
+    const setErrorMessages = (field, errors) => {
+        const getErrorMessage = (fieldLabel, errorType) => {
+            let errorMessage = "";
+            switch (errorType) {
+                case "required":
+                    errorMessage = `${fieldLabel} is required!`;
+                    break;
+                case "pattern":
+                    errorMessage = `${fieldLabel} has wrong pattern!`;
+                    break;
+                case "email":
+                    errorMessage = `${fieldLabel} has wrong email format!`;
+                    break;
+                case "minlength":
+                    errorMessage = `${fieldLabel} has wrong length! Required minimum length: ${field.validators.minLength}`;
+                    break;
+                case "maxlength":
+                    errorMessage = `${fieldLabel} has wrong length! Required maximum length: ${field.validators.maxLength}`;
+                    break;
+                case "areEqual":
+                    errorMessage = `${fieldLabel} must be equal!`;
+                    break;
+                default:
+                    errorMessage = `${fieldLabel}: ${"error.error_name"}: ${"error.error_value"}`;
+                    break;
+            }
+            return errorMessage;
+        };
+        Object.keys(errors).forEach((error) => {
+            field = addMessage(field, {
+                type: "error",
+                message: getErrorMessage(field.label, error)
+            });
+        });
+        return field;
+    };
+    if (error) {
+        fields[fieldIndex] = setErrorMessages(fields[fieldIndex], errors);
+    }
+    else {
+        fields[fieldIndex]["messages"] = [];
+    }
+    fields[fieldIndex] = highlightFieldError(fields[fieldIndex], error);
+    return fields;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view.fields.helper.js","sourceRoot":"","sources":["../../../../../../../projects/kwikid-forms/src/lib/renderer/form-view/helpers/form-view.fields.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { TuiDay } from \"@taiga-ui/cdk\";\r\nimport { hasKey, isNotEmpty } from \"./form-view.common.helper\";\r\n\r\nexport const findFieldFromKey = (fields: any[], key: string) => {\r\n  const field = fields.find((field) => {\r\n    if (field.key === key) {\r\n      return field;\r\n    }\r\n  });\r\n\r\n  return field;\r\n};\r\n\r\nexport const findFieldIndexFromKey = (fields: any[], key: string) => {\r\n  let fieldIndex: number;\r\n\r\n  fieldIndex = fields.findIndex((_: any) => {\r\n    return key === _.key;\r\n  });\r\n\r\n  return fieldIndex;\r\n};\r\n\r\nexport const getSearchTextOptionsFromRemoteFile = async (\r\n  field: any,\r\n  childField: any,\r\n  formGroup: any\r\n): Promise<any> => {\r\n  const parentFieldValue = formGroup.controls[field.key].value;\r\n\r\n  // Determine the URL of the remote file to fetch\r\n  let fileUrl: string | undefined;\r\n  if (childField.regexToGetJsonRemoteUrlKey) {\r\n    const fileKey = parentFieldValue.match(\r\n      childField.regexToGetJsonRemoteUrlKey\r\n    )[0];\r\n    fileUrl = childField.jsonRemoteUrlMapping[fileKey];\r\n  } else {\r\n    fileUrl = childField.fileUrl;\r\n  }\r\n\r\n  // Return early if there is no file URL\r\n  if (!fileUrl) return;\r\n\r\n  // Fetch the remote file and parse its JSON data\r\n  const response = await fetch(fileUrl);\r\n  const data = await response.json();\r\n\r\n  // Return the data for the given parent field value\r\n  return data[parentFieldValue];\r\n};\r\n\r\nexport const getSearchTextOptionsFromFieldConfig = (\r\n  field: any,\r\n  childField: any,\r\n  formGroup: any\r\n): any => {\r\n  let options: any;\r\n\r\n  const fieldValue = formGroup.controls[field.key].value;\r\n\r\n  if (isNotEmpty(childField[\"json\"])) {\r\n    options = childField[\"json\"][fieldValue];\r\n  }\r\n\r\n  return options;\r\n};\r\n\r\nexport const formatSearchTextOptions = (\r\n  options: { title: string; value: string }[]\r\n): string[] => {\r\n  return options.map(({ title }) => title);\r\n};\r\n\r\nexport const formatDateToStandardFormat = (date: TuiDay): string => {\r\n  let formattedDate: string;\r\n  let year = date.year;\r\n  let month = date.month;\r\n  let day = date.day;\r\n\r\n  formattedDate = `${day}-${month + 1}-${year}`;\r\n\r\n  return formattedDate;\r\n};\r\n\r\nexport function highlightFieldError(field: any, error: any): any {\r\n  field.invalid = error;\r\n  field.focus = error;\r\n\r\n  // if (!error) {\r\n  //   field[\"messages\"] = field[\"messages\"].filter(function (fieldMessage: {\r\n  //     type: string;\r\n  //     message: string;\r\n  //   }) {\r\n  //     return fieldMessage.type === \"error\";\r\n  //   });\r\n  // }\r\n\r\n  return field;\r\n}\r\n\r\nexport const addMessage = (\r\n  field: any,\r\n  message: { type: string; message: string }\r\n): any => {\r\n  const isDuplicateMessage = (\r\n    messages: { type: string; message: string }[],\r\n    message: { type: string; message: string }\r\n  ) => {\r\n    return messages.some((fieldMessage: { type: string; message: string }) => {\r\n      return (\r\n        fieldMessage.type === message.type &&\r\n        fieldMessage.message === message.message\r\n      );\r\n    });\r\n  };\r\n\r\n  field[\"messages\"] = [];\r\n\r\n  if (hasKey(field, \"messages\")) {\r\n    if (!isDuplicateMessage(field[\"messages\"], message)) {\r\n      field[\"messages\"].push({\r\n        type: message.type,\r\n        message: message.message\r\n      });\r\n    }\r\n  } else {\r\n    field[\"messages\"] = [{ type: message.type, message: message.message }];\r\n  }\r\n\r\n  return field;\r\n};\r\nexport const removeMessage = (\r\n  field: any,\r\n  message: { type: string; message: string }\r\n): any => {\r\n  field[\"messages\"] = field[\"messages\"].filter(function (fieldMessage) {\r\n    return fieldMessage.type !== message.type;\r\n  });\r\n\r\n  return field;\r\n};\r\n\r\nexport function setFieldError(\r\n  fields: any,\r\n  errors: any,\r\n  key: string,\r\n  error: boolean\r\n) {\r\n  const fieldIndex = fields.findIndex((field: any) => {\r\n    return field.key === key;\r\n  });\r\n\r\n  const setErrorMessages = (field: any, errors: any) => {\r\n    const getErrorMessage = (fieldLabel: string, errorType: string) => {\r\n      let errorMessage: string = \"\";\r\n\r\n      switch (errorType) {\r\n        case \"required\":\r\n          errorMessage = `${fieldLabel} is required!`;\r\n          break;\r\n        case \"pattern\":\r\n          errorMessage = `${fieldLabel} has wrong pattern!`;\r\n          break;\r\n        case \"email\":\r\n          errorMessage = `${fieldLabel} has wrong email format!`;\r\n          break;\r\n        case \"minlength\":\r\n          errorMessage = `${fieldLabel} has wrong length! Required minimum length: ${field.validators.minLength}`;\r\n          break;\r\n        case \"maxlength\":\r\n          errorMessage = `${fieldLabel} has wrong length! Required maximum length: ${field.validators.maxLength}`;\r\n          break;\r\n        case \"areEqual\":\r\n          errorMessage = `${fieldLabel} must be equal!`;\r\n          break;\r\n        default:\r\n          errorMessage = `${fieldLabel}: ${\"error.error_name\"}: ${\"error.error_value\"}`;\r\n          break;\r\n      }\r\n\r\n      return errorMessage;\r\n    };\r\n\r\n    Object.keys(errors).forEach((error) => {\r\n      field = addMessage(field, {\r\n        type: \"error\",\r\n        message: getErrorMessage(field.label, error)\r\n      });\r\n    });\r\n\r\n    return field;\r\n  };\r\n\r\n  if (error) {\r\n    fields[fieldIndex] = setErrorMessages(fields[fieldIndex], errors);\r\n  } else {\r\n    fields[fieldIndex][\"messages\"] = [];\r\n  }\r\n\r\n  fields[fieldIndex] = highlightFieldError(fields[fieldIndex], error);\r\n\r\n  return fields;\r\n}\r\n"]}

package/esm2015/lib/renderer/form-view/helpers/form-view.rules.helper.js

@@ -0,0 +1,86 @@
+import { __decorate } from "tslib";
+import { EPattern, EPatternKey } from "../definitions/common/form-view.common.enum.definitions";
+import { ERuleKey } from "../definitions/rules/form-view.rules.enum.definitions";
+import { ESourceKey } from "../definitions/sources/form-view.sources.enum.definitions";
+import { log } from "../form-view.decorators";
+import { hasPath } from "./form-view.common.helper";
+import { Sources } from "./form-view.sources.helper";
+export class Rules {
+    constructor(rules, field, formData, previousFormData, allFormsData) {
+        this._field = field;
+        this._formData = formData;
+        this._previousFormData = previousFormData;
+        this._allFormsData = allFormsData;
+        this._rules = rules;
+    }
+    evaluate(rule) {
+        let ruleType = rule.key;
+        let ruleEvaluationStatus = false;
+        if (this._field.type === "radio") {
+            this._formData[this._field.key] = this._formData[this._field.key].label;
+        }
+        const source = new Sources(this._field, this._formData, this._previousFormData, this._allFormsData);
+        switch (ruleType) {
+            case ERuleKey.OBJECT_PATH_EXISTS:
+                const ruleObjectPathExists = rule;
+                const ruleObjectPathExistsObject = ruleObjectPathExists.props.object;
+                const ruleObjectPathExistsPath = ruleObjectPathExists.props.path;
+                switch (ruleObjectPathExistsObject) {
+                    case ESourceKey.ALL_FORMS_DATA:
+                        ruleEvaluationStatus = hasPath(this._allFormsData, ruleObjectPathExistsPath);
+                        break;
+                    case ESourceKey.FORM_DATA:
+                        ruleEvaluationStatus = hasPath(this._formData, ruleObjectPathExistsPath);
+                        break;
+                    case ESourceKey.PREVIOUS_FORM_DATA:
+                        ruleEvaluationStatus = hasPath(this._previousFormData, ruleObjectPathExistsPath);
+                        break;
+                    case ESourceKey.FIELD_CONFIG:
+                        ruleEvaluationStatus = hasPath(this._field, ruleObjectPathExistsPath);
+                        break;
+                    default:
+                        ruleEvaluationStatus = false;
+                        break;
+                }
+                break;
+            case ERuleKey.VALUE_CHECK:
+                const ruleValueCheck = rule;
+                const ruleValueCheckSource = ruleValueCheck.props.value.source;
+                const ruleValueCheckValue = source.getValueFromSource(ruleValueCheckSource);
+                if (ruleValueCheck.props.pattern.key === EPatternKey.CUSTOM) {
+                    var re = new RegExp(ruleValueCheck.props.pattern.pattern);
+                }
+                else {
+                    var re = new RegExp(EPattern[ruleValueCheck.props.pattern.key]);
+                }
+                ruleEvaluationStatus = re.test(ruleValueCheckValue);
+                break;
+            case ERuleKey.VALUE_CHANGE:
+                const ruleValueChange = rule;
+                const ruleValueChangeCurrentSource = ruleValueChange.props.value.current.source;
+                const ruleValueChangePreviousSource = ruleValueChange.props.value.previous.source;
+                const previousValue = source.getValueFromSource(ruleValueChangePreviousSource);
+                const currentValue = source.getValueFromSource(ruleValueChangeCurrentSource);
+                ruleEvaluationStatus = previousValue === currentValue;
+                break;
+            default:
+                break;
+        }
+        return ruleEvaluationStatus;
+    }
+    mapping() {
+        let rulesEvaluationMapping = {};
+        for (const rule of this._rules) {
+            const ruleEvaluationStatus = this.evaluate(rule);
+            rulesEvaluationMapping = Object.assign(Object.assign({}, rulesEvaluationMapping), { [rule.id]: ruleEvaluationStatus });
+        }
+        return rulesEvaluationMapping;
+    }
+}
+__decorate([
+    log
+], Rules.prototype, "evaluate", null);
+__decorate([
+    log
+], Rules.prototype, "mapping", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view.rules.helper.js","sourceRoot":"","sources":["../../../../../../../projects/kwikid-forms/src/lib/renderer/form-view/helpers/form-view.rules.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  EPattern,\r\n  EPatternKey\r\n} from \"../definitions/common/form-view.common.enum.definitions\";\r\nimport { TField } from \"../definitions/fields/form-view.fields.type.definitions\";\r\nimport { ERuleKey } from \"../definitions/rules/form-view.rules.enum.definitions\";\r\nimport {\r\n  TRule,\r\n  TRuleObjectPathExists,\r\n  TRuleType,\r\n  TRuleValueChange,\r\n  TRuleValueCheck\r\n} from \"../definitions/rules/form-view.rules.type.definitions\";\r\nimport { ESourceKey } from \"../definitions/sources/form-view.sources.enum.definitions\";\r\nimport { TSource } from \"../definitions/sources/form-view.sources.type.definitions\";\r\nimport { log } from \"../form-view.decorators\";\r\nimport { hasPath } from \"./form-view.common.helper\";\r\nimport { Sources } from \"./form-view.sources.helper\";\r\n\r\nexport class Rules {\r\n  private _formData: any;\r\n  private _previousFormData: any;\r\n  private _allFormsData: any;\r\n  private _field: TField;\r\n  private _rules: Array<TRule>;\r\n\r\n  constructor(\r\n    rules: Array<TRule>,\r\n    field: TField,\r\n    formData: any,\r\n    previousFormData: any,\r\n    allFormsData: any\r\n  ) {\r\n    this._field = field;\r\n    this._formData = formData;\r\n    this._previousFormData = previousFormData;\r\n    this._allFormsData = allFormsData;\r\n    this._rules = rules;\r\n  }\r\n\r\n  @log\r\n  private evaluate(rule: TRule): boolean {\r\n    let ruleType: TRuleType = rule.key;\r\n    let ruleEvaluationStatus: boolean = false;\r\n\r\n    if (this._field.type === \"radio\") {\r\n      this._formData[this._field.key] = this._formData[this._field.key].label;\r\n    }\r\n\r\n    const source = new Sources(\r\n      this._field,\r\n      this._formData,\r\n      this._previousFormData,\r\n      this._allFormsData\r\n    );\r\n\r\n    switch (ruleType) {\r\n      case ERuleKey.OBJECT_PATH_EXISTS:\r\n        const ruleObjectPathExists = rule as TRuleObjectPathExists;\r\n        const ruleObjectPathExistsObject = ruleObjectPathExists.props.object;\r\n        const ruleObjectPathExistsPath = ruleObjectPathExists.props.path;\r\n\r\n        switch (ruleObjectPathExistsObject) {\r\n          case ESourceKey.ALL_FORMS_DATA:\r\n            ruleEvaluationStatus = hasPath(\r\n              this._allFormsData,\r\n              ruleObjectPathExistsPath\r\n            );\r\n            break;\r\n          case ESourceKey.FORM_DATA:\r\n            ruleEvaluationStatus = hasPath(\r\n              this._formData,\r\n              ruleObjectPathExistsPath\r\n            );\r\n            break;\r\n          case ESourceKey.PREVIOUS_FORM_DATA:\r\n            ruleEvaluationStatus = hasPath(\r\n              this._previousFormData,\r\n              ruleObjectPathExistsPath\r\n            );\r\n            break;\r\n          case ESourceKey.FIELD_CONFIG:\r\n            ruleEvaluationStatus = hasPath(\r\n              this._field,\r\n              ruleObjectPathExistsPath\r\n            );\r\n            break;\r\n          default:\r\n            ruleEvaluationStatus = false;\r\n            break;\r\n        }\r\n        break;\r\n      case ERuleKey.VALUE_CHECK:\r\n        const ruleValueCheck = rule as TRuleValueCheck;\r\n        const ruleValueCheckSource: TSource = ruleValueCheck.props.value.source;\r\n        const ruleValueCheckValue =\r\n          source.getValueFromSource(ruleValueCheckSource);\r\n\r\n        if (ruleValueCheck.props.pattern.key === EPatternKey.CUSTOM) {\r\n          var re = new RegExp(ruleValueCheck.props.pattern.pattern);\r\n        } else {\r\n          var re = new RegExp(EPattern[ruleValueCheck.props.pattern.key]);\r\n        }\r\n\r\n        ruleEvaluationStatus = re.test(ruleValueCheckValue);\r\n        break;\r\n      case ERuleKey.VALUE_CHANGE:\r\n        const ruleValueChange = rule as TRuleValueChange;\r\n        const ruleValueChangeCurrentSource: TSource =\r\n          ruleValueChange.props.value.current.source;\r\n        const ruleValueChangePreviousSource: TSource =\r\n          ruleValueChange.props.value.previous.source;\r\n\r\n        const previousValue = source.getValueFromSource(\r\n          ruleValueChangePreviousSource\r\n        );\r\n        const currentValue = source.getValueFromSource(\r\n          ruleValueChangeCurrentSource\r\n        );\r\n\r\n        ruleEvaluationStatus = previousValue === currentValue;\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n\r\n    return ruleEvaluationStatus;\r\n  }\r\n\r\n  @log\r\n  public mapping(): any {\r\n    let rulesEvaluationMapping = {};\r\n\r\n    for (const rule of this._rules) {\r\n      const ruleEvaluationStatus = this.evaluate(rule);\r\n\r\n      rulesEvaluationMapping = {\r\n        ...rulesEvaluationMapping,\r\n        [rule.id]: ruleEvaluationStatus\r\n      };\r\n    }\r\n\r\n    return rulesEvaluationMapping;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/renderer/form-view/helpers/form-view.sources.helper.js

@@ -0,0 +1,161 @@
+import { __awaiter, __decorate } from "tslib";
+import { EBrowserStorageType, ESourceKey } from "../definitions/sources/form-view.sources.enum.definitions";
+import { log } from "../form-view.decorators";
+import { isNotEmpty, isNotEmptyBrowserStorageValue, jpQueryWrapper, setEmptyValue, setValueToObject } from "./form-view.common.helper";
+export class Sources {
+    constructor(field, formData, previousFormData, allFormsData) {
+        this._field = field;
+        this._formData = formData;
+        this._previousFormData = previousFormData;
+        this._allFormsData = allFormsData;
+    }
+    get formData() {
+        return this._formData;
+    }
+    set formData(value) {
+        this._formData = value;
+    }
+    get previousFormData() {
+        return this._previousFormData;
+    }
+    set previousFormData(value) {
+        this._previousFormData = value;
+    }
+    get allFormsData() {
+        return this._allFormsData;
+    }
+    set allFormsData(value) {
+        this._allFormsData = value;
+    }
+    get field() {
+        return this._field;
+    }
+    set field(value) {
+        this._field = value;
+    }
+    getValueFromFieldConfig(path) {
+        let value = "";
+        if (isNotEmpty(path)) {
+            value = jpQueryWrapper(this._field, path);
+        }
+        else {
+            value = setEmptyValue(this._field);
+        }
+        return value;
+    }
+    getValueFromFormData(path) {
+        let value;
+        value = jpQueryWrapper(this._formData, path);
+        return value;
+    }
+    getValueFromPreviousFormData(path) {
+        let value;
+        value = jpQueryWrapper(this._previousFormData, path);
+        return value;
+    }
+    getValueFromAllFormsData(path) {
+        let value;
+        value = jpQueryWrapper(this._allFormsData, path);
+        return value;
+    }
+    getValueFromBrowserStorage(type, key) {
+        let value = "";
+        switch (type) {
+            case EBrowserStorageType.LOCAL_STORAGE:
+                value = isNotEmptyBrowserStorageValue(localStorage.getItem(key))
+                    ? localStorage.getItem(key)
+                    : "";
+                break;
+            case EBrowserStorageType.SESSION_STORAGE:
+                value = isNotEmptyBrowserStorageValue(sessionStorage.getItem(key))
+                    ? sessionStorage.getItem(key)
+                    : "";
+                break;
+            default:
+                value = "";
+                break;
+        }
+        return value;
+    }
+    getValueFromSource(source) {
+        let value = "";
+        switch (source.key) {
+            case ESourceKey.FIELD_CONFIG:
+                value = this.getValueFromFieldConfig(source.props.path);
+                break;
+            case ESourceKey.FORM_DATA:
+                value = this.getValueFromFormData(source.props.path);
+                break;
+            case ESourceKey.ALL_FORMS_DATA:
+                value = this.getValueFromAllFormsData(source.props.path);
+                break;
+            case ESourceKey.PREVIOUS_FORM_DATA:
+                value = this.getValueFromPreviousFormData(source.props.path);
+                break;
+            case ESourceKey.BROWSER_STORAGE:
+                value = this.getValueFromBrowserStorage(source.props.browserStorage.type, source.props.browserStorage.key);
+                break;
+            case ESourceKey.PREDEFINED:
+                value = source.value;
+                break;
+            default:
+                value = "";
+                break;
+        }
+        return value;
+    }
+    setValueToFieldConfig(path, value) {
+        this._field = setValueToObject(this._field, path, value);
+    }
+    setValueToFormData(path, value) {
+        this._formData = setValueToObject(this._formData, path, value);
+    }
+    setValueToAllFormsData(path, value) {
+        this._allFormsData = setValueToObject(this._allFormsData, path, value);
+    }
+    setValueToPreviousFromData(path, value) {
+        this._previousFormData = setValueToObject(this._previousFormData, path, value);
+    }
+    setValueToBrowserStorage(type, key, value) {
+        switch (type) {
+            case EBrowserStorageType.LOCAL_STORAGE:
+                localStorage.setItem(key, value);
+                break;
+            case EBrowserStorageType.SESSION_STORAGE:
+                sessionStorage.setItem(key, value);
+                break;
+            default:
+                break;
+        }
+    }
+    setValueToSource(source, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (source.key) {
+                case ESourceKey.FIELD_CONFIG:
+                    this._field = this.setValueToFieldConfig(source.props.path, value);
+                    break;
+                case ESourceKey.FORM_DATA:
+                    this._formData = this.setValueToFormData(source.props.path, value);
+                    break;
+                case ESourceKey.ALL_FORMS_DATA:
+                    this._allFormsData = this.setValueToAllFormsData(source.props.path, value);
+                    break;
+                case ESourceKey.PREVIOUS_FORM_DATA:
+                    this._previousFormData = this.setValueToPreviousFromData(source.props.path, value);
+                    break;
+                case ESourceKey.BROWSER_STORAGE:
+                    yield this.setValueToBrowserStorage(source.props.browserStorage.type, source.props.browserStorage.key, value);
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+}
+__decorate([
+    log
+], Sources.prototype, "getValueFromSource", null);
+__decorate([
+    log
+], Sources.prototype, "setValueToSource", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view.sources.helper.js","sourceRoot":"","sources":["../../../../../../../projects/kwikid-forms/src/lib/renderer/form-view/helpers/form-view.sources.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { TField } from \"../definitions/fields/form-view.fields.type.definitions\";\r\nimport {\r\n  EBrowserStorageType,\r\n  ESourceKey\r\n} from \"../definitions/sources/form-view.sources.enum.definitions\";\r\nimport {\r\n  TBrowserStorageType,\r\n  TSource\r\n} from \"../definitions/sources/form-view.sources.type.definitions\";\r\nimport { log } from \"../form-view.decorators\";\r\nimport {\r\n  isNotEmpty,\r\n  isNotEmptyBrowserStorageValue,\r\n  jpQueryWrapper,\r\n  setEmptyValue,\r\n  setValueToObject\r\n} from \"./form-view.common.helper\";\r\n\r\nexport class Sources {\r\n  private _formData: any;\r\n  get formData(): any {\r\n    return this._formData;\r\n  }\r\n  set formData(value: any) {\r\n    this._formData = value;\r\n  }\r\n\r\n  private _previousFormData: any;\r\n  get previousFormData(): any {\r\n    return this._previousFormData;\r\n  }\r\n  set previousFormData(value: any) {\r\n    this._previousFormData = value;\r\n  }\r\n\r\n  private _allFormsData: any;\r\n  get allFormsData(): any {\r\n    return this._allFormsData;\r\n  }\r\n  set allFormsData(value: any) {\r\n    this._allFormsData = value;\r\n  }\r\n\r\n  private _field: TField;\r\n  get field(): TField {\r\n    return this._field;\r\n  }\r\n  set field(value: TField) {\r\n    this._field = value;\r\n  }\r\n\r\n  constructor(\r\n    field: TField,\r\n    formData: any,\r\n    previousFormData: any,\r\n    allFormsData: any\r\n  ) {\r\n    this._field = field;\r\n    this._formData = formData;\r\n    this._previousFormData = previousFormData;\r\n    this._allFormsData = allFormsData;\r\n  }\r\n\r\n  private getValueFromFieldConfig(path: string): any {\r\n    let value: any = \"\";\r\n    if (isNotEmpty(path)) {\r\n      value = jpQueryWrapper(this._field, path);\r\n    } else {\r\n      value = setEmptyValue(this._field);\r\n    }\r\n    return value;\r\n  }\r\n\r\n  private getValueFromFormData(path: string): any {\r\n    let value: any;\r\n    value = jpQueryWrapper(this._formData, path);\r\n    return value;\r\n  }\r\n  private getValueFromPreviousFormData(path: string): any {\r\n    let value: any;\r\n    value = jpQueryWrapper(this._previousFormData, path);\r\n    return value;\r\n  }\r\n  private getValueFromAllFormsData(path: string): any {\r\n    let value: any;\r\n    value = jpQueryWrapper(this._allFormsData, path);\r\n    return value;\r\n  }\r\n  private getValueFromBrowserStorage(\r\n    type: TBrowserStorageType,\r\n    key: string\r\n  ): any {\r\n    let value: any = \"\";\r\n    switch (type) {\r\n      case EBrowserStorageType.LOCAL_STORAGE:\r\n        value = isNotEmptyBrowserStorageValue(localStorage.getItem(key))\r\n          ? localStorage.getItem(key)\r\n          : \"\";\r\n        break;\r\n      case EBrowserStorageType.SESSION_STORAGE:\r\n        value = isNotEmptyBrowserStorageValue(sessionStorage.getItem(key))\r\n          ? sessionStorage.getItem(key)\r\n          : \"\";\r\n        break;\r\n      default:\r\n        value = \"\";\r\n        break;\r\n    }\r\n    return value;\r\n  }\r\n\r\n  @log\r\n  getValueFromSource(source: TSource): any {\r\n    let value: any = \"\";\r\n\r\n    switch (source.key) {\r\n      case ESourceKey.FIELD_CONFIG:\r\n        value = this.getValueFromFieldConfig(source.props.path);\r\n        break;\r\n      case ESourceKey.FORM_DATA:\r\n        value = this.getValueFromFormData(source.props.path);\r\n        break;\r\n      case ESourceKey.ALL_FORMS_DATA:\r\n        value = this.getValueFromAllFormsData(source.props.path);\r\n        break;\r\n      case ESourceKey.PREVIOUS_FORM_DATA:\r\n        value = this.getValueFromPreviousFormData(source.props.path);\r\n        break;\r\n      case ESourceKey.BROWSER_STORAGE:\r\n        value = this.getValueFromBrowserStorage(\r\n          source.props.browserStorage.type,\r\n          source.props.browserStorage.key\r\n        );\r\n        break;\r\n      case ESourceKey.PREDEFINED:\r\n        value = source.value;\r\n        break;\r\n      default:\r\n        value = \"\";\r\n        break;\r\n    }\r\n\r\n    return value;\r\n  }\r\n\r\n  private setValueToFieldConfig(path: string, value: any): any {\r\n    this._field = setValueToObject(this._field, path, value);\r\n  }\r\n  private setValueToFormData(path: string, value: any): any {\r\n    this._formData = setValueToObject(this._formData, path, value);\r\n  }\r\n  private setValueToAllFormsData(path: string, value: any): any {\r\n    this._allFormsData = setValueToObject(this._allFormsData, path, value);\r\n  }\r\n  private setValueToPreviousFromData(path: string, value: any): any {\r\n    this._previousFormData = setValueToObject(\r\n      this._previousFormData,\r\n      path,\r\n      value\r\n    );\r\n  }\r\n  private setValueToBrowserStorage(type: string, key: string, value: any): any {\r\n    switch (type) {\r\n      case EBrowserStorageType.LOCAL_STORAGE:\r\n        localStorage.setItem(key, value);\r\n        break;\r\n      case EBrowserStorageType.SESSION_STORAGE:\r\n        sessionStorage.setItem(key, value);\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n  }\r\n\r\n  @log\r\n  async setValueToSource(source: TSource, value: any) {\r\n    switch (source.key) {\r\n      case ESourceKey.FIELD_CONFIG:\r\n        this._field = this.setValueToFieldConfig(source.props.path, value);\r\n        break;\r\n      case ESourceKey.FORM_DATA:\r\n        this._formData = this.setValueToFormData(source.props.path, value);\r\n        break;\r\n      case ESourceKey.ALL_FORMS_DATA:\r\n        this._allFormsData = this.setValueToAllFormsData(\r\n          source.props.path,\r\n          value\r\n        );\r\n        break;\r\n      case ESourceKey.PREVIOUS_FORM_DATA:\r\n        this._previousFormData = this.setValueToPreviousFromData(\r\n          source.props.path,\r\n          value\r\n        );\r\n        break;\r\n      case ESourceKey.BROWSER_STORAGE:\r\n        await this.setValueToBrowserStorage(\r\n          source.props.browserStorage.type,\r\n          source.props.browserStorage.key,\r\n          value\r\n        );\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/renderer/form-view/helpers/form-view.validations.helper.js

@@ -0,0 +1,156 @@
+import { __awaiter, __decorate } from "tslib";
+import { FormArray, FormGroup, Validators } from "@angular/forms";
+import { EPattern, EPatternKey } from "../definitions/common/form-view.common.enum.definitions";
+import { log } from "../form-view.decorators";
+import { Actions } from "./form-view.actions.helper";
+import { hasKey, isNotEmpty } from "./form-view.common.helper";
+import { Condition } from "./form-view.condition.helper";
+import { Rules } from "./form-view.rules.helper";
+export class Validations {
+    constructor(field, formData, previousFormData, allFormsData, takeAction) {
+        this._field = field;
+        this._formData = formData;
+        this._previousFormData = previousFormData;
+        this._allFormsData = allFormsData;
+        this._takeAction = takeAction;
+    }
+    get formData() {
+        return this._formData;
+    }
+    set formData(value) {
+        this._formData = value;
+    }
+    get previousFormData() {
+        return this._previousFormData;
+    }
+    set previousFormData(value) {
+        this._previousFormData = value;
+    }
+    get allFormsData() {
+        return this._allFormsData;
+    }
+    set allFormsData(value) {
+        this._allFormsData = value;
+    }
+    get field() {
+        return this._field;
+    }
+    set field(value) {
+        this._field = value;
+    }
+    getFieldValidators(field) {
+        let validators = [];
+        if (hasKey(field, "validators") &&
+            hasKey(field.validators, "min") &&
+            isNotEmpty(field.validators.min)) {
+            validators.push(Validators.min(field.validators.min));
+        }
+        if (hasKey(field, "validators") &&
+            hasKey(field.validators, "max") &&
+            isNotEmpty(field.validators.max)) {
+            validators.push(Validators.max(field.validators.max));
+        }
+        if (hasKey(field, "required") ||
+            (hasKey(field, "validators") && hasKey(field.validators, "required"))) {
+            validators.push(Validators.required);
+        }
+        if (hasKey(field, "validators") &&
+            hasKey(field.validators, "minLength") &&
+            isNotEmpty(field.validators.minLength)) {
+            validators.push(Validators.minLength(field.validators.minLength));
+        }
+        if (hasKey(field, "validators") &&
+            hasKey(field.validators, "maxLength") &&
+            isNotEmpty(field.validators.maxLength)) {
+            validators.push(Validators.maxLength(field.validators.maxLength));
+        }
+        if (hasKey(field, "validators") &&
+            hasKey(field.validators, "pattern") &&
+            isNotEmpty(field.validators.pattern)) {
+            if (field.validators.pattern.key === EPatternKey.CUSTOM) {
+                validators.push(Validators.pattern(field.validators.pattern.pattern));
+            }
+            else {
+                validators.push(Validators.pattern(EPattern[field.validators.pattern.key]));
+            }
+        }
+        if (hasKey(field, "validators") &&
+            hasKey(field.validators, "nullValidator") &&
+            isNotEmpty(field.validators.nullValidator)) {
+            validators.push(Validators.nullValidator(field.validators.nullValidator));
+        }
+        return validators;
+    }
+    getFormValidationErrors(control) {
+        let errors = [];
+        for (const key in control.controls) {
+            const controlErrors = control.controls[key].errors;
+            if (controlErrors !== null && controlErrors !== undefined) {
+                Object.keys(controlErrors).forEach((keyError) => {
+                    errors.push({
+                        name: keyError,
+                        value: controlErrors[keyError]
+                    });
+                });
+            }
+        }
+        return errors;
+    }
+    findInvalidControlsRecursive(formToInvestigate) {
+        var controls = [];
+        let recursiveFunc = (form) => {
+            Object.keys(form.controls).forEach((field) => {
+                const control = form.get(field);
+                if (control.invalid) {
+                    controls.push({
+                        key: field,
+                        invalid: true
+                    });
+                }
+                else {
+                    controls.push({
+                        key: field,
+                        invalid: false
+                    });
+                }
+                if (control instanceof FormGroup) {
+                    recursiveFunc(control);
+                }
+                else if (control instanceof FormArray) {
+                    recursiveFunc(control);
+                }
+            });
+        };
+        recursiveFunc(formToInvestigate);
+        return controls;
+    }
+    validateField() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validations = this._field.validation;
+            const triggers = validations.triggers;
+            const rules = validations.rules;
+            const actions = validations.actions;
+            const rulesMapping = new Rules(rules, this._field, this._formData, this._previousFormData, this._allFormsData).mapping();
+            for (let action of actions) {
+                const conditionEvaluation = new Condition(action.condition, rulesMapping).evaluate();
+                if (conditionEvaluation) {
+                    const actions = new Actions(action, this._field, rulesMapping, this._allFormsData, this._formData, this._previousFormData, this._takeAction);
+                    yield actions.execute();
+                }
+            }
+        });
+    }
+}
+__decorate([
+    log
+], Validations.prototype, "getFieldValidators", null);
+__decorate([
+    log
+], Validations.prototype, "getFormValidationErrors", null);
+__decorate([
+    log
+], Validations.prototype, "findInvalidControlsRecursive", null);
+__decorate([
+    log
+], Validations.prototype, "validateField", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-view.validations.helper.js","sourceRoot":"","sources":["../../../../../../../projects/kwikid-forms/src/lib/renderer/form-view/helpers/form-view.validations.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  FormArray,\r\n  FormGroup,\r\n  ValidationErrors,\r\n  Validators\r\n} from \"@angular/forms\";\r\nimport {\r\n  EPattern,\r\n  EPatternKey\r\n} from \"../definitions/common/form-view.common.enum.definitions\";\r\nimport { TField } from \"../definitions/fields/form-view.fields.type.definitions\";\r\nimport { log } from \"../form-view.decorators\";\r\nimport { Actions } from \"./form-view.actions.helper\";\r\nimport { hasKey, isNotEmpty } from \"./form-view.common.helper\";\r\nimport { Condition } from \"./form-view.condition.helper\";\r\nimport { Rules } from \"./form-view.rules.helper\";\r\n\r\nexport class Validations {\r\n  private _formData: any;\r\n  get formData(): any {\r\n    return this._formData;\r\n  }\r\n  set formData(value: any) {\r\n    this._formData = value;\r\n  }\r\n\r\n  private _previousFormData: any;\r\n  get previousFormData(): any {\r\n    return this._previousFormData;\r\n  }\r\n  set previousFormData(value: any) {\r\n    this._previousFormData = value;\r\n  }\r\n\r\n  private _allFormsData: any;\r\n  get allFormsData(): any {\r\n    return this._allFormsData;\r\n  }\r\n  set allFormsData(value: any) {\r\n    this._allFormsData = value;\r\n  }\r\n\r\n  private _field: TField;\r\n  get field(): TField {\r\n    return this._field;\r\n  }\r\n  set field(value: TField) {\r\n    this._field = value;\r\n  }\r\n\r\n  private _takeAction: Function;\r\n\r\n  constructor(\r\n    field: TField,\r\n    formData: any,\r\n    previousFormData: any,\r\n    allFormsData: any,\r\n    takeAction: any\r\n  ) {\r\n    this._field = field;\r\n    this._formData = formData;\r\n    this._previousFormData = previousFormData;\r\n    this._allFormsData = allFormsData;\r\n    this._takeAction = takeAction;\r\n  }\r\n\r\n  @log\r\n  getFieldValidators(field: any) {\r\n    let validators = [];\r\n\r\n    if (\r\n      hasKey(field, \"validators\") &&\r\n      hasKey(field.validators, \"min\") &&\r\n      isNotEmpty(field.validators.min)\r\n    ) {\r\n      validators.push(Validators.min(field.validators.min));\r\n    }\r\n    if (\r\n      hasKey(field, \"validators\") &&\r\n      hasKey(field.validators, \"max\") &&\r\n      isNotEmpty(field.validators.max)\r\n    ) {\r\n      validators.push(Validators.max(field.validators.max));\r\n    }\r\n    if (\r\n      hasKey(field, \"required\") ||\r\n      (hasKey(field, \"validators\") && hasKey(field.validators, \"required\"))\r\n    ) {\r\n      validators.push(Validators.required);\r\n    }\r\n    if (\r\n      hasKey(field, \"validators\") &&\r\n      hasKey(field.validators, \"minLength\") &&\r\n      isNotEmpty(field.validators.minLength)\r\n    ) {\r\n      validators.push(Validators.minLength(field.validators.minLength));\r\n    }\r\n    if (\r\n      hasKey(field, \"validators\") &&\r\n      hasKey(field.validators, \"maxLength\") &&\r\n      isNotEmpty(field.validators.maxLength)\r\n    ) {\r\n      validators.push(Validators.maxLength(field.validators.maxLength));\r\n    }\r\n    if (\r\n      hasKey(field, \"validators\") &&\r\n      hasKey(field.validators, \"pattern\") &&\r\n      isNotEmpty(field.validators.pattern)\r\n    ) {\r\n      if (field.validators.pattern.key === EPatternKey.CUSTOM) {\r\n        validators.push(Validators.pattern(field.validators.pattern.pattern));\r\n      } else {\r\n        validators.push(\r\n          Validators.pattern(EPattern[field.validators.pattern.key])\r\n        );\r\n      }\r\n    }\r\n    if (\r\n      hasKey(field, \"validators\") &&\r\n      hasKey(field.validators, \"nullValidator\") &&\r\n      isNotEmpty(field.validators.nullValidator)\r\n    ) {\r\n      validators.push(Validators.nullValidator(field.validators.nullValidator));\r\n    }\r\n\r\n    return validators;\r\n  }\r\n\r\n  @log\r\n  getFormValidationErrors(\r\n    control: FormGroup\r\n  ): { name: string; value: string }[] {\r\n    let errors: { name: string; value: string }[] = [];\r\n\r\n    for (const key in control.controls) {\r\n      const controlErrors: ValidationErrors = control.controls[key].errors;\r\n      if (controlErrors !== null && controlErrors !== undefined) {\r\n        Object.keys(controlErrors).forEach((keyError) => {\r\n          errors.push({\r\n            name: keyError,\r\n            value: controlErrors[keyError]\r\n          });\r\n        });\r\n      }\r\n    }\r\n\r\n    return errors;\r\n  }\r\n\r\n  @log\r\n  findInvalidControlsRecursive(formToInvestigate: FormGroup | FormArray) {\r\n    var controls: any[] = [];\r\n\r\n    let recursiveFunc = (form: FormGroup | FormArray) => {\r\n      Object.keys(form.controls).forEach((field: any) => {\r\n        const control = form.get(field);\r\n        if (control.invalid) {\r\n          controls.push({\r\n            key: field,\r\n            invalid: true\r\n          });\r\n        } else {\r\n          controls.push({\r\n            key: field,\r\n            invalid: false\r\n          });\r\n        }\r\n        if (control instanceof FormGroup) {\r\n          recursiveFunc(control);\r\n        } else if (control instanceof FormArray) {\r\n          recursiveFunc(control);\r\n        }\r\n      });\r\n    };\r\n\r\n    recursiveFunc(formToInvestigate);\r\n\r\n    return controls;\r\n  }\r\n\r\n  @log\r\n  async validateField(): Promise<any> {\r\n    const validations = this._field.validation;\r\n\r\n    const triggers = validations.triggers;\r\n    const rules = validations.rules;\r\n    const actions = validations.actions;\r\n\r\n    const rulesMapping = new Rules(\r\n      rules,\r\n      this._field,\r\n      this._formData,\r\n      this._previousFormData,\r\n      this._allFormsData\r\n    ).mapping();\r\n\r\n    for (let action of actions) {\r\n      const conditionEvaluation = new Condition(\r\n        action.condition,\r\n        rulesMapping\r\n      ).evaluate();\r\n\r\n      if (conditionEvaluation) {\r\n        const actions = new Actions(\r\n          action,\r\n          this._field,\r\n          rulesMapping,\r\n          this._allFormsData,\r\n          this._formData,\r\n          this._previousFormData,\r\n          this._takeAction\r\n        );\r\n\r\n        await actions.execute();\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}