forstok-ui-lib 8.4.1 → 8.5.0

package/src/assets/javascripts/function.ts

@@ -1,60 +1,91 @@
-import approve from 'approvejs'
-import { ReactNode } from 'react';
-import { TMessage, TMessageFunction, TMessageQuestion } from '../../components/message/typed';
-import { TObject } from '../../typeds/base.typed';
-import { errorTitle } from './helper';
-import { THeadProps } from '../../typeds';
-
-export const getStorage = (name: string, type: string = 'string', defaultVal?: any, loadName: string = 'load') => {
-  let result: any
+import approve from "approvejs";
+import { ReactNode } from "react";
+import {
+  TMessage,
+  TMessageFunction,
+  TMessageQuestion,
+} from "../../components/message/typed";
+import { TObject } from "../../typeds/base.typed";
+import { errorTitle } from "./helper";
+import { THeadProps } from "../../typeds";
+
+export const getStorage = (
+  name: string,
+  type: string = "string",
+  defaultVal?: any,
+  loadName: string = "load",
+) => {
+  let result: any;
   if (sessionStorage.getItem(loadName) !== null) {
-    result = sessionStorage.getItem(name) !== null ? sessionStorage.getItem(name) : defaultVal
+    result =
+      sessionStorage.getItem(name) !== null
+        ? sessionStorage.getItem(name)
+        : defaultVal;
   } else {
-    result = localStorage.getItem(name) !== null ? localStorage.getItem(name) : defaultVal
-    localStorage.getItem(name) !== null && sessionStorage.setItem(name, result)
+    result =
+      localStorage.getItem(name) !== null
+        ? localStorage.getItem(name)
+        : defaultVal;
+    localStorage.getItem(name) !== null && sessionStorage.setItem(name, result);
   }
   switch (type) {
-    case 'boolean':
-      result = (result !== undefined && result !== 'undefined') ? (result === 'true') : false
-      break
-    case 'number': 
-    case 'integer':
-      result = (result !== undefined && result !== 'undefined') ? parseInt(result) : 0
-      break
-    case 'object':
-    case 'array':
-      result = (result !== undefined && result !== 'undefined') ? (typeof result === 'string' ? (result !== '' ? JSON.parse(result) : undefined) : result) : undefined
-      break  
+    case "boolean":
+      result =
+        result !== undefined && result !== "undefined"
+          ? result === "true"
+          : false;
+      break;
+    case "number":
+    case "integer":
+      result =
+        result !== undefined && result !== "undefined" ? parseInt(result) : 0;
+      break;
+    case "object":
+    case "array":
+      result =
+        result !== undefined && result !== "undefined"
+          ? typeof result === "string"
+            ? result !== ""
+              ? JSON.parse(result)
+              : undefined
+            : result
+          : undefined;
+      break;
     default:
-      result = (result === undefined || result === 'undefined') ? '' : result
-      break
+      result = result === undefined || result === "undefined" ? "" : result;
+      break;
   }
-  return result
-}
+  return result;
+};
 
 export const setStorage = (name: string, value?: any, only?: string) => {
   if (value === undefined || value === null) {
     return false;
   }
-  const _value: string = (typeof value !== 'string') ? ((typeof value === 'object') ? JSON.stringify(value) : value.toString()) : value;
+  const _value: string =
+    typeof value !== "string"
+      ? typeof value === "object"
+        ? JSON.stringify(value)
+        : value.toString()
+      : value;
   switch (only) {
-    case 'session':
+    case "session":
       sessionStorage.setItem(name, _value);
-      break
-    case 'local':
+      break;
+    case "local":
       localStorage.setItem(name, _value);
-      break
+      break;
     default:
       sessionStorage.setItem(name, _value);
       localStorage.setItem(name, _value);
   }
-}
+};
 
 export const removeStorage = (name: string) => {
   localStorage.removeItem(name);
   sessionStorage.removeItem(name);
   return true;
-}
+};
 
 export const debounce = (fn: Function, ms = 300) => {
   let timeoutId: ReturnType<typeof setTimeout>;
@@ -62,16 +93,16 @@ export const debounce = (fn: Function, ms = 300) => {
     clearTimeout(timeoutId);
     timeoutId = setTimeout(() => fn.apply(this, args), ms);
   };
-}
+};
 
 export const capitalize = (value?: string) => {
-  return value ? (value[0].toUpperCase() + value.substring(1)) : '';
-}
+  return value ? value[0].toUpperCase() + value.substring(1) : "";
+};
 
 export const formatNumber = (n?: string | number, flag?: boolean) => {
   const _flag = flag === undefined ? true : flag;
-  let result:string = '';
-  if (n !== '' && n !== null && n !== undefined) {
+  let result: string = "";
+  if (n !== "" && n !== null && n !== undefined) {
     result = n?.toString().replaceAll(".", "");
     if (result.length === 2 && result.substring(0, 1) === "0") {
       result = parseInt(result).toString();
@@ -81,71 +112,105 @@ export const formatNumber = (n?: string | number, flag?: boolean) => {
     }
   }
   return result;
-}
+};
 
 export const IsNumeric = (val?: any) => {
   return Number(parseFloat(val)) === val;
-}
+};
 
-export const generateMessage = (type: string, value: string | ReactNode, callback?: () => void, timer?: number) => {
+export const generateMessage = (
+  type: string,
+  value: string | ReactNode,
+  callback?: () => void,
+  timer?: number,
+) => {
   let result: TMessage = {
     $type: type,
     message: value,
-    timer: timer || (type === 'warning' ? 3000 : 2000)
+    timer: timer || (type === "warning" ? 3000 : 2000),
   };
-  callback && (result.callback = () => { callback() });
+  callback &&
+    (result.callback = () => {
+      callback();
+    });
   return result;
-}
+};
 
-export const generateMessageQuestion = (type: string, title: string, subtitle: string, callback?: () => void, buttonSubmit?: string, cancelCallback?: () => void) => {
+export const generateMessageQuestion = (
+  type: string,
+  title: string,
+  subtitle: string,
+  callback?: () => void,
+  buttonSubmit?: string,
+  cancelCallback?: () => void,
+) => {
   let result: TMessageQuestion = {
     $type: type,
     title: title,
     subtitle: subtitle,
     callback: callback,
     buttonSubmit: buttonSubmit,
-    cancelCallback: cancelCallback
+    cancelCallback: cancelCallback,
   };
   return result;
-}
+};
 
 export const currencyNumber = (value?: number | null) => {
-  return (value !== undefined  && value !== null) ? value.toLocaleString('id-ID', { style: 'currency', currency: 'IDR', minimumFractionDigits: 0 }) : '-'
-}
+  return value !== undefined && value !== null
+    ? value.toLocaleString("id-ID", {
+        style: "currency",
+        currency: "IDR",
+        minimumFractionDigits: 0,
+      })
+    : "-";
+};
 
-export const generateSUM = (names: string[] | string, data: any, type?: string) => {
-  let result: number = 0
+export const generateSUM = (
+  names: string[] | string,
+  data: any,
+  type?: string,
+) => {
+  let result: number = 0;
   if (data && names) {
     result = data.reduce((_sum: any, cur: any) => {
-      let _name
+      let _name;
       if (Array.isArray(names)) {
-        _name = cur
+        _name = cur;
         for (const name of names) {
           if (name in _name) {
-            _name = _name[name]
+            _name = _name[name];
           }
         }
       } else {
-        _name = cur[names]
+        _name = cur[names];
       }
-      return _sum + (type === 'currency' ? parseInt(_name.replace(/,.*|[^0-9]/g, '')) : _name)
-    }, 0)
+      return (
+        _sum +
+        (type === "currency"
+          ? parseInt(_name.replace(/,.*|[^0-9]/g, ""))
+          : _name)
+      );
+    }, 0);
   }
-  return result
-}
+  return result;
+};
 
-export const evUpdateInputRc = (input?: HTMLInputElement, value?: string | number) => {
+export const evUpdateInputRc = (
+  input?: HTMLInputElement,
+  value?: string | number,
+) => {
   if (!input) {
     return false;
   }
   const nativeInputValueSetter = Object.getOwnPropertyDescriptor(
     window.HTMLInputElement.prototype,
-    "value"
+    "value",
   )?.set;
-  nativeInputValueSetter && nativeInputValueSetter.call(input, (value === undefined ? '' : value));
-  const inputEvent = new Event('input', { bubbles: true});
+  nativeInputValueSetter &&
+    nativeInputValueSetter.call(input, value === undefined ? "" : value);
+  const inputEvent = new Event("input", { bubbles: true });
   input.dispatchEvent(inputEvent);
-}
+};
 
 export const getSizeContainer = (full?: boolean) => {
   const height = window.innerHeight;
@@ -157,370 +222,463 @@ export const getSizeContainer = (full?: boolean) => {
     result.width = width - 187 - 32;
   }
   return result;
-}
+};
 
-export const generateValueTable = (input: string|number, key: string) => {
+export const generateValueTable = (input: string | number, key: string) => {
   let result = input;
-  if (key && input !== '') {
+  if (key && input !== "") {
     const _key = key.toLowerCase();
-    const _input = (typeof input === 'string') ? parseInt(input) : input;
+    const _input = typeof input === "string" ? parseInt(input) : input;
     if (/price/.test(_key)) {
       result = currencyNumber(_input);
-    } else if (/width/.test(_key) || /length/.test(_key) || /height/.test(_key)) {
-      result = input + ' cm';
+    } else if (
+      /width/.test(_key) ||
+      /length/.test(_key) ||
+      /height/.test(_key)
+    ) {
+      result = input + " cm";
     } else if (/weight/.test(_key)) {
-      result = input + ' gr';
-    } else if(/discount/.test(_key)) {
-      result = input + ' %';
+      result = input + " gr";
+    } else if (/discount/.test(_key)) {
+      result = input + " %";
     }
   }
   return result;
-}
+};
 
 export const generateValue = (type: string, value: any) => {
   let result: any;
   switch (type) {
-    case 'String':
-      result = value ? value.toString().trim() : '';
-      break
-    case 'Integer':
-      result = (value !== '' && value !== null) ? parseInt(value) : null;
-      break
-    case 'Currency':
-      result = (value !== '' && value !== null) ? parseInt(formatNumber(value, false)) : null;
-      break 
-    case 'Boolean':
-      case 'Array':
+    case "String":
+      result = value ? value.toString().trim() : "";
+      break;
+    case "Integer":
+      result = value !== "" && value !== null ? parseInt(value) : null;
+      break;
+    case "Currency":
+      result =
+        value !== "" && value !== null
+          ? parseInt(formatNumber(value, false))
+          : null;
+      break;
+    case "Boolean":
+    case "Array":
       result = value;
-      break
+      break;
     default:
       result = value.toString().trim();
   }
   return result;
-}
+};
 
-export const validateByApproveJs = (head: TObject, value: any, title?: string, valueMatch?: any) => {
+export const validateByApproveJs = (
+  head: TObject,
+  value: any,
+  title?: string,
+  valueMatch?: any,
+) => {
   let result: TObject = { approved: true };
   let _title: string = title || errorTitle(head.name);
-  if (head.key.indexOf('options-option') !== -1) {
-    if (value === '') {
-      result = { approved: false, errors: [_title+' is required'] };
+  if (head.key.indexOf("options-option") !== -1) {
+    if (value === "") {
+      result = { approved: false, errors: [_title + " is required"] };
     }
   }
   if (head?.validations) {
-    const typeData: string = head?.typeData || 'String';
+    const typeData: string = head?.typeData || "String";
     let rules: TObject = { title: _title };
     if (head.validations?.required) {
       switch (typeData) {
-        case 'String':
+        case "String":
           rules.required = true;
-        break
-        case 'Integer': 
-        case 'Currency':
-          const _value = (typeof value === 'undefined') ? '' : (isNaN(value) ? '' : value);
+          break;
+        case "Boolean":
+          const requiredBooleanRule = {
+            expects: ["value"],
+            message: "{title} is required",
+            validate: (value: any, pars: TObject) => {
+              return pars.value !== undefined && pars.value !== null;
+            },
+          };
+          approve.addTest(requiredBooleanRule, "requiredBooleanRule");
+          rules.requiredBooleanRule = {
+            value: value,
+          };
+          break;
+        case "Integer":
+        case "Currency":
+          const _value =
+            typeof value === "undefined" ? "" : isNaN(value) ? "" : value;
           const requiredIntegerRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} is required',
+            expects: ["value"],
+            message: "{title} is required",
             validate: (value: any, pars: TObject) => {
-              return pars.value !== '' && pars.value !== null
-            }
+              return pars.value !== "" && pars.value !== null;
+            },
           };
-          approve.addTest(requiredIntegerRule, 'requiredIntegerRule');
+          approve.addTest(requiredIntegerRule, "requiredIntegerRule");
           rules.requiredIntegerRule = {
-            value: _value
+            value: _value,
           };
-        break 
-        case 'Array':
+          break;
+        case "Array":
           const requiredArrayRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} is required',
+            expects: ["value"],
+            message: "{title} is required",
             validate: (value: any, pars: TObject) => {
-              return pars.value?.length || (pars.value && Object.keys(pars.value).length) ? true : false 
-            }
+              return pars.value?.length ||
+                (pars.value && Object.keys(pars.value).length)
+                ? true
+                : false;
+            },
           };
-          approve.addTest(requiredArrayRule, 'requiredArrayRule');
+          approve.addTest(requiredArrayRule, "requiredArrayRule");
           rules.requiredArrayRule = {
-            value: value
+            value: value,
           };
-        break
-        default: 
+          break;
+        default:
           rules.required = true;
       }
     }
 
-    if(('min' in head.validations && head.validations.min !== null) && ('max' in head.validations && head.validations.max !== null)) {
+    if (head.validations?.requiredIf) {
+      const requiredIfRule = {
+        expects: ["value", "valueMatch"],
+        message: "{title} is required",
+        validate: (value: any, pars: TObject) => {
+          if (pars?.valueMatch) {
+            if (IsNumeric(pars?.valueMatch)) {
+              return pars?.valueMatch > 0 && value ? true : false;
+            } else {
+              return pars?.valueMatch && value ? true : false;
+            }
+          } else {
+            return true;
+          }
+        },
+      };
+      approve.addTest(requiredIfRule, "requiredIfRule");
+      rules.requiredIfRule = {
+        value: value,
+        valueMatch: valueMatch,
+      };
+    }
+
+    if (
+      "min" in head.validations &&
+      head.validations.min !== null &&
+      "max" in head.validations &&
+      head.validations.max !== null
+    ) {
       switch (typeData) {
-        case 'Integer':
-        case 'Currency':
+        case "Integer":
+        case "Currency":
+          const minMaxMin = head.validations.min;
+          const minMaxMax = head.validations.max;
           const minMaxIntegerRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} min '+head.validations.min+' and max '+head.validations.max,
+            expects: ["value"],
+            message: "{title} min " + minMaxMin + " and max " + minMaxMax,
             validate: (value: any, pars: TObject) => {
-              return (pars.value >= head.validations.min && pars.value <= head.validations.max) || pars.value === '' || typeof pars.value === 'undefined'
-            }
+              return (
+                (pars.value >= minMaxMin && pars.value <= minMaxMax) ||
+                pars.value === "" ||
+                pars.value === null ||
+                typeof pars.value === "undefined"
+              );
+            },
           };
-          approve.addTest(minMaxIntegerRule, 'minMaxIntegerRule');
-          rules.minMaxIntegerRule = {
-            value: value
+          const minMaxIntegerRuleName = "minMaxIntegerRule_" + head.key;
+          approve.addTest(minMaxIntegerRule, minMaxIntegerRuleName);
+          rules[minMaxIntegerRuleName] = {
+            value: value,
           };
-        break
-        case 'Array':
+          break;
+        case "Array":
+          const minMaxArrayMin = head.validations.min;
+          const minMaxArrayMax = head.validations.max;
           const minMaxArrayRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} must be a minimum of '+head.validations.min+' and a maximum of '+head.validations.max,
+            expects: ["value"],
+            message:
+              "{title} must be a minimum of " +
+              minMaxArrayMin +
+              " and a maximum of " +
+              minMaxArrayMax,
             validate: (value: any, pars: TObject) => {
-              return pars.value ? (pars.value.length >= head.validations.min &&  pars.value.length <= head.validations.max) : (head.validations.min === 0 ? true : false)
-            }
+              return pars.value
+                ? pars.value.length >= minMaxArrayMin &&
+                    pars.value.length <= minMaxArrayMax
+                : minMaxArrayMin === 0
+                  ? true
+                  : false;
+            },
           };
-          approve.addTest(minMaxArrayRule, 'minMaxArrayRule');
-          rules.minMaxArrayRule = {
-            value: value
+          const minMaxArrayRuleName = "minMaxArrayRule_" + head.key;
+          approve.addTest(minMaxArrayRule, minMaxArrayRuleName);
+          rules[minMaxArrayRuleName] = {
+            value: value,
           };
-        break
-        default: 
+          break;
+        default:
           rules.min = head.validations.min;
           rules.max = head.validations.max;
       }
-    }
-    else if('min' in head.validations && head.validations.min !== null) {
+    } else if ("min" in head.validations && head.validations.min !== null) {
       switch (typeData) {
-        case 'Integer':
-        case 'Currency':
+        case "Integer":
+        case "Currency":
+          const minValue = head.validations.min;
           const minIntegerRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} min '+head.validations.min,
+            expects: ["value"],
+            message: "{title} min " + minValue,
             validate: (value: any, pars: TObject) => {
-              return pars.value >= head.validations.min || pars.value === '' || typeof pars.value === 'undefined'
-            }
+              return (
+                pars.value >= minValue ||
+                pars.value === "" ||
+                pars.value === null ||
+                typeof pars.value === "undefined"
+              );
+            },
           };
-          approve.addTest(minIntegerRule, 'minIntegerRule');
-          rules.minIntegerRule = {
-            value: value
+          const minIntegerRuleName = "minIntegerRule_" + head.key;
+          approve.addTest(minIntegerRule, minIntegerRuleName);
+          rules[minIntegerRuleName] = {
+            value: value,
           };
-        break
-        case 'Array':
+          break;
+        case "Array":
+          const minArrayMin = head.validations.min;
           const minArrayRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} must be a minimum of '+head.validations.min,
+            expects: ["value"],
+            message: "{title} must be a minimum of " + minArrayMin,
             validate: (value: any, pars: TObject) => {
-              return pars.value ? (pars.value.length >= head.validations.min) : (head.validations.min === 0 ? true : false)
-            }
+              return pars.value
+                ? pars.value.length >= minArrayMin
+                : minArrayMin === 0
+                  ? true
+                  : false;
+            },
           };
-          approve.addTest(minArrayRule, 'minArrayRule');
-          rules.minArrayRule = {
-            value: value
+          const minArrayRuleName = "minArrayRule_" + head.key;
+          approve.addTest(minArrayRule, minArrayRuleName);
+          rules[minArrayRuleName] = {
+            value: value,
           };
-        break
-        default: 
+          break;
+        default:
           rules.min = head.validations.min;
       }
-    }
-    else if('max' in head.validations && head.validations.max !== null) {
+    } else if ("max" in head.validations && head.validations.max !== null) {
       switch (typeData) {
-        case 'Integer':
-        case 'Currency':
+        case "Integer":
+        case "Currency":
+          const maxValue = head.validations.max;
           const maxIntegerRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} max '+head.validations.max,
+            expects: ["value"],
+            message: "{title} max " + maxValue,
             validate: (value: any, pars: TObject) => {
-              return pars.value <= head.validations.max || pars.value === '' || typeof pars.value === 'undefined'
-            }
+              return (
+                pars.value <= maxValue ||
+                pars.value === "" ||
+                pars.value === null ||
+                typeof pars.value === "undefined"
+              );
+            },
           };
-          approve.addTest(maxIntegerRule, 'maxIntegerRule');
-          rules.maxIntegerRule = {
-            value: value
+          const maxIntegerRuleName = "maxIntegerRule_" + head.key;
+          approve.addTest(maxIntegerRule, maxIntegerRuleName);
+          rules[maxIntegerRuleName] = {
+            value: value,
           };
-        break
-        case 'Array':
+          break;
+        case "Array":
+          const maxArrayMax = head.validations.max;
           const maxArrayRule = {
-            expects: [
-              'value'
-            ],
-            message: '{title} must be a maximum of '+head.validations.max,
+            expects: ["value"],
+            message: "{title} must be a maximum of " + maxArrayMax,
             validate: (value: any, pars: TObject) => {
-              return pars?.value?.length <= head.validations.max
-            }
+              return pars?.value?.length <= maxArrayMax;
+            },
           };
-          approve.addTest(maxArrayRule, 'maxArrayRule');
-          rules.maxArrayRule = {
-            value: value
+          const maxArrayRuleName = "maxArrayRule_" + head.key;
+          approve.addTest(maxArrayRule, maxArrayRuleName);
+          rules[maxArrayRuleName] = {
+            value: value,
           };
-        break
-        default: 
+          break;
+        default:
           rules.max = head.validations.max;
       }
     }
 
-    if('lessEqual' in head.validations) {
+    if ("lessEqual" in head.validations) {
       const lessEqualRule = {
-        expects: [
-          'value',
-          'valueMatch',
-        ],
-        message: '{title} is less than or equal {valueMatch}',
+        expects: ["value", "valueMatch"],
+        message: "{title} is less than or equal {valueMatch}",
         validate: (value: any, pars: TObject) => {
-          return (IsNumeric(value) && IsNumeric(pars?.valueMatch)) ? (value <= pars.valueMatch) : true
-        }
+          return IsNumeric(value) && IsNumeric(pars?.valueMatch)
+            ? value <= pars.valueMatch
+            : true;
+        },
       };
-      approve.addTest(lessEqualRule, 'lessEqualRule');
+      approve.addTest(lessEqualRule, "lessEqualRule");
       rules.lessEqualRule = {
         value: value,
-        valueMatch: valueMatch
+        valueMatch: valueMatch,
       };
     }
 
-    if('less' in head.validations) {
+    if ("less" in head.validations) {
       const lessRule = {
-        expects: [
-          'value',
-          'valueMatch',
-        ],
-        message: '{title} is less than {valueMatch}',
+        expects: ["value", "valueMatch"],
+        message: "{title} is less than {valueMatch}",
         validate: (value: any, pars: TObject) => {
-          return (IsNumeric(value) && IsNumeric(pars?.valueMatch)) ? (value < pars.valueMatch) : true
-        }
+          return IsNumeric(value) && IsNumeric(pars?.valueMatch)
+            ? value < pars.valueMatch
+            : true;
+        },
       };
-      approve.addTest(lessRule, 'lessRule');
+      approve.addTest(lessRule, "lessRule");
       rules.lessRule = {
         value: value,
-        valueMatch: valueMatch 
+        valueMatch: valueMatch,
       };
     }
 
-    if(head.validations?.greaterEqual) {
+    if (head.validations?.greaterEqual) {
       const greaterEqualRule = {
-        expects: [
-          'value',
-          'valueMatch',
-        ],
-        message: '{title} is greater than or equal {valueMatch}',
+        expects: ["value", "valueMatch"],
+        message: "{title} is greater than or equal {valueMatch}",
         validate: (value: any, pars: TObject) => {
-          return (IsNumeric(value) && IsNumeric(pars?.valueMatch)) ? (value >= pars.valueMatch) : true
-        }
+          return IsNumeric(value) && IsNumeric(pars?.valueMatch)
+            ? value >= pars.valueMatch
+            : true;
+        },
       };
-      approve.addTest(greaterEqualRule, 'greaterEqualRule');
+      approve.addTest(greaterEqualRule, "greaterEqualRule");
       rules.greaterEqualRule = {
         value: value,
-        valueMatch: valueMatch
+        valueMatch: valueMatch,
       };
     }
 
-    if(head.validations?.greater) {
+    if (head.validations?.greater) {
       const greaterRule = {
-        expects: [
-          'value',
-          'valueMatch',
-        ],
-        message: '{title} is greater than {valueMatch}',
+        expects: ["value", "valueMatch"],
+        message: "{title} is greater than {valueMatch}",
         validate: (value: any, pars: TObject) => {
-          return (IsNumeric(value) && IsNumeric(pars?.valueMatch)) ? (value > pars.valueMatch) : true
-        }
+          return IsNumeric(value) && IsNumeric(pars?.valueMatch)
+            ? value > pars.valueMatch
+            : true;
+        },
       };
-      approve.addTest(greaterRule, 'greaterRule');
+      approve.addTest(greaterRule, "greaterRule");
       rules.greaterRule = {
         value: value,
-        valueMatch: valueMatch
+        valueMatch: valueMatch,
       };
     }
 
     result = approve.value(value, rules);
   }
-  return result
-} 
+  return result;
+};
 
 export const evGenerateValueMatch = (validation?: TObject, data?: any) => {
   let result = undefined;
   if (validation && Object.keys(validation).length) {
-    const keyArr = ['lessEqual', 'greaterEqual', 'less', 'greater'];
+    const keyArr = ["lessEqual", "greaterEqual", "less", "greater"];
     const key = keyArr.find((_key) => _key in validation);
     if (data && key) {
       const obj = validation[key];
-      if(obj && obj in data) result = data[obj];
+      if (obj && obj in data) result = data[obj];
     }
   }
   return result;
-}
+};
 
 export const unescapeHTML = (value?: string) => {
-  return value ? value.replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&') : value as string
-}
+  return value
+    ? value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&")
+    : (value as string);
+};
 
 export const evScrollTo = (el?: HTMLElement, range?: number) => {
   const _range = range || 140;
   if (el) {
     setTimeout(() => {
-      const viewportEl = document.querySelector('._refMasterTableViewport') as HTMLElement;
+      const viewportEl = document.querySelector(
+        "._refMasterTableViewport",
+      ) as HTMLElement;
       if (!viewportEl) {
         return;
       }
       const bodyRect = viewportEl.getBoundingClientRect();
       const elemRect = el.getBoundingClientRect();
       if (elemRect) {
-        const offsetTop = (elemRect.top - bodyRect.top - _range) + viewportEl.scrollTop;
-        const offsetLeft = (elemRect.left - bodyRect.left) + viewportEl.scrollLeft
-        viewportEl.scrollTo(offsetLeft,offsetTop);
+        const offsetTop =
+          elemRect.top - bodyRect.top - _range + viewportEl.scrollTop;
+        const offsetLeft =
+          elemRect.left - bodyRect.left + viewportEl.scrollLeft;
+        viewportEl.scrollTo(offsetLeft, offsetTop);
       }
     }, 20);
   }
-}
+};
 
-export const evHighlight = (ids?: string[]|number[]) => {
+export const evHighlight = (ids?: string[] | number[]) => {
   if (!ids?.length) {
-    return false
+    return false;
   }
-  const timer: number = Math.ceil(ids.length/10)*10 <= 10 ? 30 : (Math.ceil(ids.length/10)*10 >= 200 ? 200 : Math.ceil(ids.length/10)*10) 
+  const timer: number =
+    Math.ceil(ids.length / 10) * 10 <= 10
+      ? 30
+      : Math.ceil(ids.length / 10) * 10 >= 200
+        ? 200
+        : Math.ceil(ids.length / 10) * 10;
   setTimeout(() => {
-    const contentHightlightedEls = document.querySelectorAll('._refMasterTableBodyContent.is-highlighted') as NodeListOf<HTMLElement>
+    const contentHightlightedEls = document.querySelectorAll(
+      "._refMasterTableBodyContent.is-highlighted",
+    ) as NodeListOf<HTMLElement>;
     if (contentHightlightedEls?.length) {
       for (const contentHightlightedEl of contentHightlightedEls) {
-        contentHightlightedEl.classList.remove('is-highlighted')
+        contentHightlightedEl.classList.remove("is-highlighted");
       }
     }
     for (let i = 0; i < ids.length; i++) {
-      const id = ids[i]
-      const el = document.querySelector(`#row-${id}`) as HTMLElement
+      const id = ids[i];
+      const el = document.querySelector(`#row-${id}`) as HTMLElement;
       if (el) {
-        el.classList.add('is-highlighted')
+        el.classList.add("is-highlighted");
         setTimeout(() => {
-          el.classList.remove('is-highlighted')
-        }, 1888)
+          el.classList.remove("is-highlighted");
+        }, 1888);
       }
-      if (i === (ids.length - 1)) {
-        const firstEl = document.querySelector(`#row-${ids[0]}`) as HTMLElement
-          firstEl && evScrollTo(firstEl, 140)
+      if (i === ids.length - 1) {
+        const firstEl = document.querySelector(`#row-${ids[0]}`) as HTMLElement;
+        firstEl && evScrollTo(firstEl, 140);
       }
     }
-  }, timer)
-}
+  }, timer);
+};
 
 export const evKeyMapperScanner = (oEvent: any) => {
   var iCode = oEvent.which;
   switch (true) {
     case iCode >= 48 && iCode <= 90:
-    case (iCode >= 106 && iCode <= 111) || iCode === 45 || iCode === 173 || iCode === 189:
-      if (oEvent.key !== undefined && oEvent.key !== '') {
+    case (iCode >= 106 && iCode <= 111) ||
+      iCode === 45 ||
+      iCode === 173 ||
+      iCode === 189:
+      if (oEvent.key !== undefined && oEvent.key !== "") {
         return oEvent.key;
       }
       var sDecoded = String.fromCharCode(iCode);
       switch (oEvent.shiftKey) {
-        case false: 
+        case false:
           sDecoded = sDecoded.toLowerCase();
           break;
-        case true: 
+        case true:
           sDecoded = sDecoded.toUpperCase();
           break;
         default:
@@ -528,40 +686,45 @@ export const evKeyMapperScanner = (oEvent: any) => {
       }
       return sDecoded;
     case iCode >= 96 && iCode <= 105:
-      return 0+(iCode-96);
+      return 0 + (iCode - 96);
     default:
       break;
   }
-  return ''
-}
+  return "";
+};
 
 export const evExecuteError = (evCreateMessage?: TMessageFunction) => {
-  const msg: TMessage = generateMessage('failed', 'Validation Errors found, Please fix it!');
+  const msg: TMessage = generateMessage(
+    "failed",
+    "Validation Errors found, Please fix it!",
+  );
   evCreateMessage && evCreateMessage(msg);
-  const errorEl = document.querySelectorAll('.cell-error') as NodeListOf<HTMLDivElement>;
+  const errorEl = document.querySelectorAll(
+    ".cell-error",
+  ) as NodeListOf<HTMLDivElement>;
   if (errorEl.length) {
     evScrollTo(errorEl[0]);
   }
-}
+};
 
 export const evCheckAllValidation = (data: any[]) => {
   let isError = false;
-  for(let x=0; x<data.length; x++) {
+  for (let x = 0; x < data.length; x++) {
     const _data = data[x];
     const keys = Object.keys(_data);
 
-    for(let key of keys) {
+    for (let key of keys) {
       if (Array.isArray(_data[key])) {
-        for(let i = 0; i < _data[key].length; i++){
+        for (let i = 0; i < _data[key].length; i++) {
           const _dataArr = _data[key][i];
           const keysArr = Object.keys(_dataArr);
-          for(let keyArr of keysArr) {
+          for (let keyArr of keysArr) {
             if (Array.isArray(_dataArr[keyArr])) {
-              for(let z = 0; z < _dataArr[keyArr].length; z++){
+              for (let z = 0; z < _dataArr[keyArr].length; z++) {
                 const _dataArrArr = _dataArr[keyArr][z];
                 const keysArrArr = Object.keys(_dataArrArr);
-                for(let keyArrArr of keysArrArr) {
-                  if (keyArrArr.indexOf('_error') !== -1 && !isError) {
+                for (let keyArrArr of keysArrArr) {
+                  if (keyArrArr.indexOf("_error") !== -1 && !isError) {
                     isError = true;
                   }
                   if (isError) {
@@ -573,7 +736,7 @@ export const evCheckAllValidation = (data: any[]) => {
                 }
               }
             } else {
-              if (keyArr.indexOf('_error') !== -1 && !isError) {
+              if (keyArr.indexOf("_error") !== -1 && !isError) {
                 isError = true;
               }
               if (isError) {
@@ -589,8 +752,8 @@ export const evCheckAllValidation = (data: any[]) => {
           }
         }
       } else {
-        if (key.indexOf('_error') !== -1 && !isError) {
-          isError = true
+        if (key.indexOf("_error") !== -1 && !isError) {
+          isError = true;
         }
         if (isError) {
           break;
@@ -602,277 +765,368 @@ export const evCheckAllValidation = (data: any[]) => {
     }
   }
   return isError;
-}
+};
 
-export const unCamelCaseKeys = (object: TObject) => {  
+export const unCamelCaseKeys = (object: TObject) => {
   const unCamelCase = (value: string) => {
-    return value.replace(/([a-z][A-Z])/g, function (g) { return g[0] + '_' + g[1].toLowerCase() });
+    return value.replace(/([a-z][A-Z])/g, function (g) {
+      return g[0] + "_" + g[1].toLowerCase();
+    });
   };
-  return Object
-    .entries(object)
-    .reduce((carry: any, [key, value]) => {
-      carry[unCamelCase(key)] = value
-      return carry
-    }, {});
-}
+  return Object.entries(object).reduce((carry: any, [key, value]) => {
+    carry[unCamelCase(key)] = value;
+    return carry;
+  }, {});
+};
 
 export const abbreviateNumber = (value?: number) => {
-  let result: string = ''
+  let result: string = "";
   if (value !== undefined) {
-    result = value.toString()
+    result = value.toString();
     if (value >= 1000) {
-      const suffixes = ["", "k", "m", "b","t"]
-      const suffixNum = Math.floor((""+value).length/3)
-      let shortValue
+      const suffixes = ["", "k", "m", "b", "t"];
+      const suffixNum = Math.floor(("" + value).length / 3);
+      let shortValue;
       for (let precision = 2; precision >= 1; precision--) {
-        shortValue = parseFloat((suffixNum !== 0 ? (value / Math.pow(1000,suffixNum)) : value).toPrecision(precision))
-        const dotLessShortValue = (shortValue + '').replace(/[^a-zA-Z 0-9]+/g,'')
+        shortValue = parseFloat(
+          (suffixNum !== 0
+            ? value / Math.pow(1000, suffixNum)
+            : value
+          ).toPrecision(precision),
+        );
+        const dotLessShortValue = (shortValue + "").replace(
+          /[^a-zA-Z 0-9]+/g,
+          "",
+        );
         if (dotLessShortValue.length <= 2) {
-          break 
+          break;
         }
       }
-      result = shortValue+suffixes[suffixNum]
+      result = shortValue + suffixes[suffixNum];
     }
   }
-  return result
-}
-
-export const pasteIntoInput = (el:HTMLInputElement| HTMLTextAreaElement, text: string) => {
-  el.focus()
-  if (typeof el.selectionStart == 'number' && typeof el.selectionEnd == 'number') {
-    var val = el.value
-    var selStart = el.selectionStart
-    el.value = val.slice(0, selStart) + text + val.slice(el.selectionEnd)
-    el.selectionEnd = el.selectionStart = selStart + text.length
-  } else if (typeof (document as any).selection != 'undefined') {
-    var textRange = (document as any).selection.createRange()
-    textRange.text = text
-    textRange.collapse(false)
-    textRange.select()
+  return result;
+};
+
+export const pasteIntoInput = (
+  el: HTMLInputElement | HTMLTextAreaElement,
+  text: string,
+) => {
+  el.focus();
+  if (
+    typeof el.selectionStart == "number" &&
+    typeof el.selectionEnd == "number"
+  ) {
+    var val = el.value;
+    var selStart = el.selectionStart;
+    el.value = val.slice(0, selStart) + text + val.slice(el.selectionEnd);
+    el.selectionEnd = el.selectionStart = selStart + text.length;
+  } else if (typeof (document as any).selection != "undefined") {
+    var textRange = (document as any).selection.createRange();
+    textRange.text = text;
+    textRange.collapse(false);
+    textRange.select();
   }
-}
+};
 
 export const isDesktop = () => {
   return document.body.clientWidth >= 1024 ? true : false;
-}
+};
 
 export const isTablet = () => {
-  return (document.body.clientWidth >= 768 && document.body.clientWidth < 1024) ? true : false;
-}
+  return document.body.clientWidth >= 768 && document.body.clientWidth < 1024
+    ? true
+    : false;
+};
 
 export const isMobile = () => {
   return document.body.clientWidth < 768 ? true : false;
-}
+};
 
 export const evCloseDropdown = (currentTarget: EventTarget & HTMLElement) => {
-  const containerEl = currentTarget.closest('._refContainer') as HTMLElement || currentTarget.closest('._refDropdownPortal') as HTMLDivElement;
-  const isOpen = containerEl ? containerEl.classList.contains('is-shown') : false;
+  const containerEl =
+    (currentTarget.closest("._refContainer") as HTMLElement) ||
+    (currentTarget.closest("._refDropdownPortal") as HTMLDivElement);
+  const isOpen = containerEl
+    ? containerEl.classList.contains("is-shown")
+    : false;
   if (isOpen) {
-    const containerRefs = document.getElementsByClassName('_refContainer is-shown') as HTMLCollectionOf<HTMLElement>
-    const dropdownContainerRefs = document.getElementsByClassName('_refDropdownPortal is-shown') as HTMLCollectionOf<HTMLDivElement>
+    const containerRefs = document.getElementsByClassName(
+      "_refContainer is-shown",
+    ) as HTMLCollectionOf<HTMLElement>;
+    const dropdownContainerRefs = document.getElementsByClassName(
+      "_refDropdownPortal is-shown",
+    ) as HTMLCollectionOf<HTMLDivElement>;
     if (containerRefs?.length) {
       for (let i = 0; i < containerRefs.length; i++) {
-        const overlay = containerRefs[i].querySelector(`._refDropdownOverlay`) as HTMLElement
-        overlay && (overlay.style.display = 'none')
-        containerRefs[i].classList.remove('is-shown')
+        const overlay = containerRefs[i].querySelector(
+          `._refDropdownOverlay`,
+        ) as HTMLElement;
+        overlay && (overlay.style.display = "none");
+        containerRefs[i].classList.remove("is-shown");
       }
     }
     if (dropdownContainerRefs?.length) {
       for (let i = 0; i < dropdownContainerRefs.length; i++) {
-        const overlay = dropdownContainerRefs[i].querySelector(`._refDropdownOverlay`) as HTMLElement
-        overlay && (overlay.style.display = 'none')
-        dropdownContainerRefs[i].classList.remove('is-shown')
+        const overlay = dropdownContainerRefs[i].querySelector(
+          `._refDropdownOverlay`,
+        ) as HTMLElement;
+        overlay && (overlay.style.display = "none");
+        dropdownContainerRefs[i].classList.remove("is-shown");
       }
     }
-    const refScrollContainerEl = document.querySelector('._refScrollContainer') as HTMLElement
-    const bodyEl = document.getElementsByTagName('BODY')[0] as HTMLBodyElement
-    bodyEl.classList.remove('is-immuned')
+    const refScrollContainerEl = document.querySelector(
+      "._refScrollContainer",
+    ) as HTMLElement;
+    const bodyEl = document.getElementsByTagName("BODY")[0] as HTMLBodyElement;
+    bodyEl.classList.remove("is-immuned");
     if (refScrollContainerEl) {
-      refScrollContainerEl.style.overflow = 'auto'
-      const child = refScrollContainerEl.firstChild as HTMLElement
-      child.style.overflowY = 'unset'
+      refScrollContainerEl.style.overflow = "auto";
+      const child = refScrollContainerEl.firstChild as HTMLElement;
+      child.style.overflowY = "unset";
     }
   }
-}
+};
 
 export const evForceCloseDropdown = () => {
-  const containerRefs = document.getElementsByClassName('_refContainer is-shown') as HTMLCollectionOf<HTMLElement>;
+  const containerRefs = document.getElementsByClassName(
+    "_refContainer is-shown",
+  ) as HTMLCollectionOf<HTMLElement>;
   if (containerRefs?.length) {
     for (let i = 0; i < containerRefs.length; i++) {
-      containerRefs[i].classList.remove('is-shown');
+      containerRefs[i].classList.remove("is-shown");
     }
-    const refScrollContainerEl = document.querySelector('._refScrollContainer') as HTMLElement;
-    const bodyEl = document.getElementsByTagName('BODY')[0] as HTMLBodyElement
-    bodyEl.classList.remove('is-immuned');
+    const refScrollContainerEl = document.querySelector(
+      "._refScrollContainer",
+    ) as HTMLElement;
+    const bodyEl = document.getElementsByTagName("BODY")[0] as HTMLBodyElement;
+    bodyEl.classList.remove("is-immuned");
     if (refScrollContainerEl) {
-      refScrollContainerEl.style.overflow = 'auto';
-      const child = refScrollContainerEl.firstChild as HTMLElement
-      child.style.overflowY = 'unset';
+      refScrollContainerEl.style.overflow = "auto";
+      const child = refScrollContainerEl.firstChild as HTMLElement;
+      child.style.overflowY = "unset";
     }
-    const overlayEls = document.querySelectorAll(`._refDropdownOverlay`) as NodeListOf<HTMLDivElement>;
-    overlayEls?.length && overlayEls.forEach(overlayEl => overlayEl.style.display = 'none');
+    const overlayEls = document.querySelectorAll(
+      `._refDropdownOverlay`,
+    ) as NodeListOf<HTMLDivElement>;
+    overlayEls?.length &&
+      overlayEls.forEach((overlayEl) => (overlayEl.style.display = "none"));
   }
-  return
-}
+  return;
+};
 
-export const evSetTotal = (totalCount: number, totalEl: HTMLSpanElement, callback?: () => void) => {
+export const evSetTotal = (
+  totalCount: number,
+  totalEl: HTMLSpanElement,
+  callback?: () => void,
+) => {
   if (totalCount && totalEl) {
-    totalEl.innerText =`(${totalCount})`
-    totalEl.removeAttribute('hidden')
+    totalEl.innerText = `(${totalCount})`;
+    totalEl.removeAttribute("hidden");
   }
-  if (callback && typeof(callback) == "function") {
-    callback()
+  if (callback && typeof callback == "function") {
+    callback();
   }
-}
+};
 
 export const humanise = (value?: string) => {
-  const underscoreMatch = /_/g, underscoreMatch2 = /-/g
-  return value ? value.replace(underscoreMatch, " ").replace(underscoreMatch2, " ") : ''
-}
+  const underscoreMatch = /_/g,
+    underscoreMatch2 = /-/g;
+  return value
+    ? value.replace(underscoreMatch, " ").replace(underscoreMatch2, " ")
+    : "";
+};
 
 export const generateAddress = (address?: TObject | null) => {
-  let result: string = '-'
+  let result: string = "-";
   if (address) {
-    const firstLine = ((!address.address1 && !address.address2) ? '' : ((address.address1 ? address.address1 + ', ' : '') + (address.address2 || '') + '<br/>') ),
-          secondLine = ((!address.subDistrict && !address.district && !address.city) ? '' : ((address.subDistrict ? address.subDistrict + ', ' : '') + (address.district ? address.district + ', ' : '') + (address.city || '') + '<br/>') ),
-          thirdLine = ((address.postalCode ? (address.postalCode + '<br/>') : '')),
-          lastLine = address.phone || ''
-    result = firstLine + secondLine + thirdLine + lastLine
+    const firstLine =
+        !address.address1 && !address.address2
+          ? ""
+          : (address.address1 ? address.address1 + ", " : "") +
+            (address.address2 || "") +
+            "<br/>",
+      secondLine =
+        !address.subDistrict && !address.district && !address.city
+          ? ""
+          : (address.subDistrict ? address.subDistrict + ", " : "") +
+            (address.district ? address.district + ", " : "") +
+            (address.city || "") +
+            "<br/>",
+      thirdLine = address.postalCode ? address.postalCode + "<br/>" : "",
+      lastLine = address.phone || "";
+    result = firstLine + secondLine + thirdLine + lastLine;
   }
-  return result
-}
+  return result;
+};
 
 export const evRemoveActiveButton = () => {
-  const nextButtonEl = document.querySelector('#btn-active-red') as HTMLButtonElement
-  nextButtonEl && nextButtonEl.removeAttribute('id')
-}
-
-export const evCheckAllValidationByHeader = (data: any[], headerColumns: THeadProps[]) => {
-  let isError = false 
-  const validByHeader = (key: string, valuex: any, idx?: number, title = null) => {
-    const __idx = idx || 0
-    const validHeaderKeyFilter = headerColumns.filter(header => (header.key === key && header.validations))
+  const nextButtonEl = document.querySelector(
+    "#btn-active-red",
+  ) as HTMLButtonElement;
+  nextButtonEl && nextButtonEl.removeAttribute("id");
+};
+
+export const evCheckAllValidationByHeader = (
+  data: any[],
+  headerColumns: THeadProps[],
+) => {
+  let isError = false;
+  const validByHeader = (
+    key: string,
+    valuex: any,
+    idx?: number,
+    title = null,
+  ) => {
+    const __idx = idx || 0;
+    const validHeaderKeyFilter = headerColumns.filter(
+      (header) => header.key === key && header.validations,
+    );
     if (validHeaderKeyFilter.length) {
-      const head = validHeaderKeyFilter[__idx]
-      const type = head.typeData || 'String'
-      const _value = generateValue(type, valuex)
-      const valid = validateByApproveJs(head, _value, title || '')
-      return valid      
+      const head = validHeaderKeyFilter[__idx];
+      const type = head.typeData || "String";
+      const _value = generateValue(type, valuex);
+      const valid = validateByApproveJs(head, _value, title || "");
+      return valid;
     }
-    return { approved: true } 
-  }
+    return { approved: true };
+  };
 
-  const newData = []
-  for (let x=0; x<data.length; x++) {
-    const _data = data[x]
-    const keys = Object.keys(_data)
+  const newData = [];
+  for (let x = 0; x < data.length; x++) {
+    const _data = data[x];
+    const keys = Object.keys(_data);
 
     for (const key of keys) {
-      let _valid: TObject = { approved: true }
+      let _valid: TObject = { approved: true };
       if (Array.isArray(_data[key])) {
         for (let i = 0; i < _data[key].length; i++) {
-          const _dataArr = _data[key][i]
-          const keysArr = Object.keys(_dataArr)
+          const _dataArr = _data[key][i];
+          const keysArr = Object.keys(_dataArr);
           for (const keyArr of keysArr) {
             if (Array.isArray(_dataArr[keyArr])) {
               for (let z = 0; z < _dataArr[keyArr].length; z++) {
-                const _dataArrArr = _dataArr[keyArr][z]
-                const keysArrArr = Object.keys(_dataArrArr)
+                const _dataArrArr = _dataArr[keyArr][z];
+                const keysArrArr = Object.keys(_dataArrArr);
                 for (const keyArrArr of keysArrArr) {
-                  _valid = validByHeader(keyArrArr, _dataArrArr[keyArrArr])
+                  _valid = validByHeader(keyArrArr, _dataArrArr[keyArrArr]);
                   if (!_valid.approved) {
-                    _dataArrArr[`${keyArr}_error`] = _valid.errors[0]
+                    _dataArrArr[`${keyArr}_error`] = _valid.errors[0];
                     if (!isError) {
-                      isError = true
+                      isError = true;
                     }
                   }
-                  if (keyArrArr.indexOf('_error') !== -1 && !isError) {
-                    isError = true
+                  if (keyArrArr.indexOf("_error") !== -1 && !isError) {
+                    isError = true;
                   }
                 }
               }
             } else {
-              _valid = validByHeader(keyArr, _dataArr[keyArr])
+              _valid = validByHeader(keyArr, _dataArr[keyArr]);
               if (!_valid.approved) {
-                _dataArr[`${keyArr}_error`] = _valid.errors[0]
+                _dataArr[`${keyArr}_error`] = _valid.errors[0];
                 if (!isError) {
-                  isError = true
+                  isError = true;
                 }
               }
-              if (keyArr.indexOf('_error') !== -1 && !isError) {
-                isError = true
+              if (keyArr.indexOf("_error") !== -1 && !isError) {
+                isError = true;
               }
             }
           }
         }
       } else {
-        _valid = validByHeader(key, _data[key])
+        _valid = validByHeader(key, _data[key]);
         if (!_valid.approved) {
-          _data[`${key}_error`] = _valid.errors[0]
+          _data[`${key}_error`] = _valid.errors[0];
           if (!isError) {
-            isError = true
+            isError = true;
           }
         }
-        if (key.indexOf('_error') !== -1 && !isError) {
-          isError = true
+        if (key.indexOf("_error") !== -1 && !isError) {
+          isError = true;
         }
       }
     }
-    newData.push(_data)
+    newData.push(_data);
   }
-  return { error: isError, data: newData }
-}
+  return { error: isError, data: newData };
+};
 
-export const evCheckAllValidationByHeaderWithVariant = (newData: any[], headerColumns: THeadProps[]) => {
-  let isError = false 
+export const evCheckAllValidationByHeaderWithVariant = (
+  newData: any[],
+  headerColumns: THeadProps[],
+) => {
+  let isError = false;
 
-  const validByHeader = (key: string, valuex: any, idx?: number, content?: any) => {
-    const __idx = idx || 0
-    const validHeaderKeyFilter = headerColumns.filter(header => (header.key === key && header.validations))
+  const validByHeader = (
+    key: string,
+    valuex: any,
+    idx?: number,
+    content?: any,
+  ) => {
+    const __idx = idx || 0;
+    const validHeaderKeyFilter = headerColumns.filter(
+      (header) => header.key === key && header.validations,
+    );
     if (validHeaderKeyFilter.length) {
-      const head = validHeaderKeyFilter[__idx]
-      const type = head.typeData || 'String'
-      const _value = generateValue(type, valuex)
-      const valid = validateByApproveJs(head, _value, undefined, evGenerateValueMatch(head.validations, content))
-      return valid      
+      const head = validHeaderKeyFilter[__idx];
+      const type = head.typeData || "String";
+      const _value = generateValue(type, valuex);
+      const valid = validateByApproveJs(
+        head,
+        _value,
+        undefined,
+        evGenerateValueMatch(head.validations, content),
+      );
+      return valid;
     }
-    return { approved: true } 
-  }
+    return { approved: true };
+  };
 
-  let _newData = [...newData]
-  for (let x=0; x<_newData.length; x++) {
-    let _data = _newData[x]
-    let keys = Object.keys(_data)
+  let _newData = [...newData];
+  for (let x = 0; x < _newData.length; x++) {
+    let _data = _newData[x];
+    let keys = Object.keys(_data);
 
     for (const key of keys) {
-      if (Array.isArray(_data[key]) && _data[key].length && typeof _data[key][0] === 'object') {
-        for (let i = 0; i < _data[key].length; i++){
-          const _dataArr = _data[key][i]
-          const keysArr = Object.keys(_dataArr)
+      if (
+        Array.isArray(_data[key]) &&
+        _data[key].length &&
+        typeof _data[key][0] === "object"
+      ) {
+        for (let i = 0; i < _data[key].length; i++) {
+          const _dataArr = _data[key][i];
+          const keysArr = Object.keys(_dataArr);
           for (const keyArr of keysArr) {
             if (!Array.isArray(_dataArr[keyArr])) {
               const _key = `${key}-${keyArr}`,
-              valid = validByHeader(_key, _dataArr[keyArr], undefined, _dataArr)
+                valid = validByHeader(
+                  _key,
+                  _dataArr[keyArr],
+                  undefined,
+                  _dataArr,
+                );
               if (!valid.approved) {
-                _dataArr[`${keyArr}_error`] = valid.errors[0]
+                _dataArr[`${keyArr}_error`] = valid.errors[0];
                 if (!isError) {
-                  isError = true
+                  isError = true;
                 }
               }
             }
           }
         }
       } else {
-        const valid = validByHeader(key, _data[key], undefined, _data)
+        const valid = validByHeader(key, _data[key], undefined, _data);
         if (!valid.approved) {
-          _data[`${key}_error`] = valid.errors[0]
+          _data[`${key}_error`] = valid.errors[0];
           if (!isError) {
-            isError = true
+            isError = true;
           }
         }
       }
-    }      
-    _newData.splice(x, 1, _data)
+    }
+    _newData.splice(x, 1, _data);
   }
-  return { error: isError, data: _newData }
-}
+  return { error: isError, data: _newData };
+};