@bolttech/form-engine-core 0.0.1-beta.1

package/index.esm.js

@@ -0,0 +1,3518 @@
+import { Subscription, Subject, combineLatest, startWith, groupBy, mergeMap, debounceTime, map } from 'rxjs';
+import creditCardType from 'credit-card-type';
+import { isNumber as isNumber$1, isNil, isEqual, get, set } from 'lodash';
+import { getCurrencySymbol } from '@gaignoux/currency';
+
+var TMutationEnum;
+(function (TMutationEnum) {
+  TMutationEnum["ON_VALUE"] = "value";
+  TMutationEnum["ON_PROPS"] = "props";
+  // ON_VALIDATION = 'valid',
+  TMutationEnum["ON_VISIBILITY"] = "visibility";
+  TMutationEnum["ON_API"] = "api";
+  TMutationEnum["ON_IVARS"] = "iVars";
+  TMutationEnum["ON_FIELDS"] = "fields";
+})(TMutationEnum || (TMutationEnum = {}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Makes an HTTP request using XMLHttpRequest.
+ *
+ * @param {string} method - The HTTP method (GET, POST, PUT, DELETE, etc.).
+ * @param {string} url - The URL to which the request is sent.
+ * @param {OutgoingHttpHeaders} [headers] - Optional request headers.
+ * @param {Record<string,unknown>} [body] - Optional object body.
+ * @returns {Promise<string>} A promise that resolves with the response text if the request is successful, otherwise rejects with an error message.
+ *
+ * @example
+ * ```typescript
+ * const response = await makeRequest('GET', 'https://api.example.com/data');
+ * ```
+ */
+function makeRequest(method, url, headers, body) {
+  return new Promise(function (resolve, reject) {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, true);
+    if (headers) {
+      Object.keys(headers).forEach(header => {
+        xhr.setRequestHeader(header, headers[header]);
+      });
+    }
+    xhr.onload = function () {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve(xhr.responseText);
+      } else {
+        reject(xhr.statusText);
+      }
+    };
+    xhr.onerror = function () {
+      reject(xhr.statusText);
+    };
+    xhr.send(JSON.stringify(body) || null);
+  });
+}
+/**
+ * Extracts keys enclosed in `${}` from a given expression.
+ *
+ * @param {string} expression - The expression to extract keys from.
+ * @returns {
+ * originFieldKeys: string[];
+ * originPropertyKeys: string[];
+ * } An object containing the field names and properties from the template expression.
+ *
+ * @example
+ * ```typescript
+ * const keys = extractFieldKeys('Hello ${name.value}, your age is ${age.props.label}.');
+ * // keys will be {originFieldKeys:['name', 'age'],originPropertyKeys:[value,props]}
+ * ```
+ */
+function extractFieldKeys(expression) {
+  const regex = /\${(.*?)}/g;
+  const extractedValues = [];
+  let match;
+  while ((match = regex.exec(expression)) !== null) {
+    extractedValues.push(match[1]);
+  }
+  return {
+    originFieldKeys: Array.from(new Set(extractedValues.map(el => el.split('.')[0]))),
+    originPropertyKeys: Array.from(new Set(extractedValues.map(el => el.split('.')[1])))
+  };
+}
+/**
+ * Traverses an object and extracts expressions containing keys.
+ *
+ * @param {any} obj - The object to traverse.
+ * @param {string} [path] - Optional path within the object (used internally during recursion).
+ * @returns {TSubscribedTemplates[]} An array of extracted expressions along with their keys and paths.
+ *
+ * @example
+ * ```typescript
+ * const data = {
+ *   user: {
+ *     name: 'John',
+ *     age: 30,
+ *     address: {
+ *       street: '123 Main St',
+ *       city: 'Example City'
+ *     }
+ *   },
+ *   message: 'Hello ${user.name}, your age is ${user.age}.'
+ * };
+ *
+ * const expressions = traverseObject(data);
+ * // expressions will contain an array of objects with origin expressions, field keys, and destination paths.
+ * ```
+ */
+function traverseObject(obj, path) {
+  const result = [];
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        value.forEach((item, index) => {
+          if (typeof item === 'object') {
+            result.push(...traverseObject(item, `${path ? `${path}.` : ``}${key}.${index}`));
+          } else if (typeof item === 'string') {
+            if (String(item).includes('$')) {
+              // const extractedPath = item.replace(/\$|{|}/g, '').split('.');
+              const extractedOriginPath = `${path ? `${path}.` : ``}${key}`.split('.');
+              result.push(Object.assign(Object.assign({
+                originExpression: item
+              }, extractFieldKeys(item)), {
+                destinationKey: extractedOriginPath[0],
+                destinationProperty: extractedOriginPath[1],
+                destinationPath: extractedOriginPath.slice(2)
+              }));
+            }
+          }
+        });
+      } else if (typeof value === 'object') {
+        result.push(...traverseObject(value, `${path ? `${path}.` : ``}${key}`));
+      } else if (typeof value === 'string') {
+        if (value.includes('$')) {
+          // const extractedPath = value.replace(/\$|{|}/g, '').split('.');
+          const destinationPath = `${path ? `${path}.` : ``}${key}`.split('.');
+          result.push(Object.assign(Object.assign({
+            originExpression: value
+          }, extractFieldKeys(value)), {
+            destinationKey: destinationPath[0],
+            destinationProperty: destinationPath[1],
+            destinationPath: destinationPath.slice(2)
+          }));
+        }
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Splits a string by inserting specified values at given positions.
+ *
+ * @param value - The value to be processed.
+ * @param formatters - An object containing formatting options.
+ * @returns The processed value with splitters applied.
+ *
+ * @example
+ * ```typescript
+ * import { splitter } from './path/to/formatterFunctions';
+ *
+ * const processedValue = splitter('HelloWorld', { splitter: [{ position: 5, value: '_' }] });
+ * console.log(processedValue); // Output: 'Hello_World'
+ * ```
+ */
+const splitter = (value, formatters) => {
+  if (!value || !formatters.splitter || typeof value !== 'string') return value;
+  formatters.splitter.sort((a, b) => a.position - b.position);
+  let result = value;
+  let offset = 0;
+  for (const splitter of formatters.splitter) {
+    const {
+      position,
+      value
+    } = splitter;
+    const adjustedPosition = position + offset;
+    if (adjustedPosition >= 0 && adjustedPosition <= result.length) {
+      result = result.slice(0, adjustedPosition) + value + result.slice(adjustedPosition);
+      offset += value.length;
+    }
+  }
+  return result;
+};
+
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @param value - The value to be capitalized.
+ * @returns The value with the first letter capitalized.
+ *
+ * @example
+ * ```typescript
+ * import { capitalize } from './path/to/formatterFunctions';
+ *
+ * const capitalizedValue = capitalize('hello world');
+ * console.log(capitalizedValue); // Output: 'Hello world'
+ * ```
+ */
+const capitalize = value => String(value).charAt(0).toUpperCase() + String(value).slice(1);
+/**
+ * Converts a string to uppercase.
+ *
+ * @param value - The value to be converted.
+ * @returns The value in uppercase.
+ *
+ * @example
+ * ```typescript
+ * import { uppercase } from './path/to/formatterFunctions';
+ *
+ * const uppercasedValue = uppercase('hello world');
+ * console.log(uppercasedValue); // Output: 'HELLO WORLD'
+ * ```
+ */
+const uppercase = value => String(value).toUpperCase();
+/**
+ * Formats a string as a float number with a specific precision and decimal separator.
+ *
+ * @param value - The value to be formatted.
+ * @param formatters - An object containing formatting options.
+ * @returns The formatted float number.
+ *
+ * @example
+ * ```typescript
+ * import { onlyFloatNumber } from './path/to/formatterFunctions';
+ *
+ * const formattedNumber = onlyFloatNumber('1234567.89', { onlyFloatNumber: { precision: 2, decimal: '.' } });
+ * console.log(formattedNumber); // Output: '1234567.89'
+ * ```
+ */
+const onlyFloatNumber = (value, formatters) => {
+  const {
+    onlyFloatNumber
+  } = formatters;
+  if (!onlyFloatNumber || typeof value !== 'string' || !value) return value;
+  const {
+    precision = 2,
+    decimal = '.'
+  } = onlyFloatNumber;
+  if (!value.includes(decimal)) {
+    return value;
+  }
+  const replacedValue = value.replace(/[^0-9]/g, '');
+  const partOf = replacedValue.slice(0, replacedValue.length - precision);
+  const sliceOf = replacedValue.slice(replacedValue.length - precision);
+  return parseFloat(`${partOf}.${sliceOf}`).toFixed(precision);
+};
+/**
+ * Trims whitespace from the beginning and end of a string.
+ *
+ * @param value - The value to be trimmed.
+ * @param formatters - An object containing formatting options.
+ * @returns The trimmed value.
+ *
+ * @example
+ * ```typescript
+ * import { trim } from './path/to/formatterFunctions';
+ *
+ * const trimmedValue = trim('   hello world   ');
+ * console.log(trimmedValue); // Output: 'hello world'
+ * ```
+ */
+const trim = (value, formatters) => {
+  if (!value || (formatters === null || formatters === void 0 ? void 0 : formatters.trim)) return value;
+  return String(value).trim();
+};
+/**
+ * Truncates the input value to a specified maximum length if necessary.
+ *
+ * @param {string | number} value - The input value to be formatted.
+ * @param {TFormatters} formatters - An object containing formatting options.
+ * @param {number} formatters.maxLength - The maximum allowed length for the input value.
+ * @returns {string | number} - The formatted value truncated to the maximum length, if applicable.
+ *
+ * @example
+ * ```typescript
+ * const result = maxLength('Hello, World!', { maxLength: 5 });
+ * console.log(result); // "Hello"
+ * ```
+ * @example
+ * ```typescript
+ * const result = maxLength(123456789, { maxLength: 4 });
+ * console.log(result); // "1234"
+ * ```
+ * @example
+ * ```typescript
+ * const result = maxLength('Short', { maxLength: 10 });
+ * console.log(result); // "Short" (no truncation since input is shorter than maxLength)
+ * ```
+ */
+const maxLength = (value, formatters) => {
+  if (!value || !formatters.maxLength) return value;
+  const input = String(value);
+  if (input.length > formatters.maxLength) {
+    return input.substring(0, formatters.maxLength);
+  }
+  return value;
+};
+
+/**
+ * Removes all non-numeric characters from a string.
+ *
+ * @param value - The value to be processed.
+ * @returns The processed value with only numbers.
+ *
+ * @example
+ * ```typescript
+ * import { onlyNumbers } from './path/to/formatterFunctions';
+ *
+ * const processedValue = onlyNumbers('abc123def456');
+ * console.log(processedValue); // Output: '123456'
+ * ```
+ */
+const onlyNumbers = value => String(value).replace(/(\D)+/gim, '');
+/**
+ * Removes all non-letter characters from a string.
+ *
+ * @param value - The value to be processed.
+ * @returns The processed value with only letters.
+ *
+ * @example
+ * ```typescript
+ * import { onlyLetters } from './path/to/formatterFunctions';
+ *
+ * const processedValue = onlyLetters('abc123def456');
+ * console.log(processedValue); // Output: 'abcdef'
+ * ```
+ */
+const onlyLetters$1 = value => String(value).replace(/[^\p{L}\s]/gu, '');
+/**
+ * Applies a regular expression pattern to remove matching substrings from a string.
+ *
+ * @param value - The value to be processed.
+ * @param formatters - An object containing formatting options.
+ * @returns The processed value with matched substrings removed.
+ *
+ * @example
+ * ```typescript
+ * import { regex } from './path/to/formatterFunctions';
+ *
+ * const processedValue = regex('abc123def456', { regex: '\\d+' });
+ * console.log(processedValue); // Output: 'abcdef'
+ * ```
+ */
+const regex$1 = (value, formatters) => {
+  if (!formatters.regex) return value;
+  return String(value).replace(new RegExp(formatters.regex, 'g'), '');
+};
+
+/**
+ * Retrieves the type of the credit card and the raw value without spaces.
+ *
+ * @param value - The credit card number as a string.
+ * @param availableOptions - An optional array of credit card types to consider.
+ * @returns An array containing the detected credit card type and the raw value without spaces.
+ *
+ * @example
+ * ```typescript
+ * import { getTypeCard } from './path/to/helperFunctions';
+ *
+ * const [creditCardType, rawValue] = getTypeCard('4111 1111 1111 1111');
+ * console.log(creditCardType); // Output: { niceType: 'Visa', type: 'visa', ... }
+ * console.log(rawValue); // Output: '4111111111111111'
+ * ```
+ */
+const getTypeCard = (value, availableOptions) => {
+  const rawValue = removeGaps(value === null || value === void 0 ? void 0 : value.toString());
+  const types = creditCardType(rawValue);
+  const selected = (availableOptions === null || availableOptions === void 0 ? void 0 : availableOptions.length) ? types === null || types === void 0 ? void 0 : types.filter(({
+    type: id1
+  }) => availableOptions.some(id2 => id2 === id1))[0] : types[0];
+  return [selected, rawValue];
+};
+/**
+ * Removes all spaces from a string.
+ *
+ * @param value - The string to remove spaces from.
+ * @returns The string without spaces.
+ */
+const removeGaps = value => value === null || value === void 0 ? void 0 : value.replace(/ /g, '');
+/**
+ * Adds specified gaps to a string based on given offsets.
+ *
+ * @param value - The string to add gaps to.
+ * @param gaps - An array containing gap positions.
+ * @returns The string with added gaps.
+ */
+const addGaps = (value, gaps = []) => {
+  const [regexString, replaceString] = gaps.reduce(([regexString, replaceString], offset, i) => {
+    const lastOffset = gaps[i - 1] || 0;
+    const digitNumber = offset - lastOffset;
+    return [`${regexString}([0-9]{0,${digitNumber}})`, `${replaceString}$${i + 1} `];
+  }, ['', '']);
+  return value.replace(new RegExp(regexString), replaceString).trim();
+};
+/**
+ * Formats a credit card number according to its type's gaps and lengths.
+ *
+ * @param value - The credit card number as a string.
+ * @param type - The type of the credit card.
+ * @returns The formatted credit card number.
+ */
+const formatValue = (value, type) => {
+  const DEFAULT_LENGTH = 19;
+  return type ? addGaps(value.slice(0, type === null || type === void 0 ? void 0 : type.lengths[0]), type.gaps) : value === null || value === void 0 ? void 0 : value.slice(0, DEFAULT_LENGTH);
+};
+/**
+ * Formats a date string by adding a prefix and/or trimming the string based on its length.
+ *
+ * @param value - The date string to be formatted.
+ * @param end - The ending index to slice the string to.
+ * @param prefix - The prefix to add between date components.
+ * @returns The formatted date string.
+ *
+ * @example
+ * ```typescript
+ * import { formatDateCard } from './path/to/helperFunctions';
+ *
+ * const formattedDate = formatDateCard('1223', 4, '/');
+ * console.log(formattedDate); // Output: '12/23'
+ * ```
+ */
+const formatDateCard = (value, end = 4, prefix = '/') => {
+  const fixedValue = value.replace(/\D/g, '');
+  const valZeroTwo = fixedValue.slice(0, 2);
+  return fixedValue.length >= 5 ? `${valZeroTwo}${prefix}${fixedValue.slice(2, end)}` : fixedValue.length >= 3 ? `${valZeroTwo}${prefix}${fixedValue.slice(2)}` : fixedValue;
+};
+
+/**
+ * Formats a credit card number by adding gaps based on the card type.
+ *
+ * @param {unknown} value - The input value to be formatted, expected to be a string representing a credit card number.
+ * @param {TFormatters} formatters - An object containing formatting options.
+ * @param {boolean} formatters.gapsCreditCard - A flag indicating whether to apply credit card gap formatting.
+ * @returns {unknown} - The formatted credit card number with appropriate gaps, or the original value if formatting is not applied.
+ *
+ * @example
+ * ```typescript
+ * const formatters = { gapsCreditCard: true };
+ * const result = gapsCreditCard('4111111111111111', formatters);
+ * console.log(result); // "4111 1111 1111 1111" (formatted based on card type, e.g., Visa)
+ * ```
+ * @example
+ * ```typescript
+ * const formatters = { gapsCreditCard: false };
+ * const result = gapsCreditCard('4111111111111111', formatters);
+ * console.log(result); // "4111111111111111" (no formatting applied)
+ * ```
+ */
+const gapsCreditCard = (value, formatters) => {
+  if (!formatters.gapsCreditCard) return value;
+  const [type, rawValue] = getTypeCard(value, formatters === null || formatters === void 0 ? void 0 : formatters.gapsCreditCard);
+  return formatValue(rawValue, type);
+};
+
+/**
+ * Applies a custom callback function to format a value.
+ *
+ * @param {unknown} value - The input value to be formatted.
+ * @param {TFormatters} formatters - An object containing formatting options.
+ * @param {(value: unknown) => unknown} formatters.callback - A custom callback function to apply to the value.
+ * @returns {unknown} - The value after applying the custom callback function, or the original value if no callback is provided.
+ *
+ * @example
+ * ```typescript
+ * const formatters = { callback: (val) => `Formatted: ${val}` };
+ * const result = callback('example', formatters);
+ * console.log(result); // "Formatted: example"
+ * ```
+ * @example
+ * ```typescript
+ * const formatters = { callback: (val) => val.toString().toUpperCase() };
+ * const result = callback('example', formatters);
+ * console.log(result); // "EXAMPLE"
+ * ```
+ * @example
+ * ```typescript
+ * const formatters = { callback: null };
+ * const result = callback('example', formatters);
+ * console.log(result); // "example" (no formatting applied)
+ * ```
+ */
+const callback$1 = (value, formatters) => {
+  if (!(formatters === null || formatters === void 0 ? void 0 : formatters.callback)) return value;
+  return formatters.callback(value);
+};
+
+const formatters = {
+  capitalize,
+  uppercase,
+  onlyNumbers,
+  onlyLetters: onlyLetters$1,
+  regex: regex$1,
+  splitter,
+  maxLength,
+  onlyFloatNumber,
+  trim,
+  gapsCreditCard,
+  callback: callback$1,
+  // todo: to be removed
+  dotEvery3chars: value => {
+    const result = String(value).replace(/\./g, '').replace(/(.{3})/g, '$1.');
+    return result.endsWith('.') ? result.slice(0, -1) : result;
+  }
+};
+
+/**
+ * Applies multiple generic masks to a string based on the provided mask configuration.
+ *
+ * @param value - The value to be masked.
+ * @param masks - An object containing the mask configuration.
+ * @returns The masked value.
+ *
+ * @example
+ * ```typescript
+ * import maskValue from './path/to/maskFunctions';
+ *
+ * const masks = {
+ *   generic: [
+ *     { from: 2, to: 4, mask: '*' },
+ *     { from: 7, to: 9, mask: '#' }
+ *   ]
+ * };
+ *
+ * const maskedValue = maskValue('123456789', masks);
+ * console.log(maskedValue); // Output: '1**45###9'
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   value: 'abcdefghij',
+ *   masks: {
+ *     generic: [
+ *       { from: 3, to: 6, mask: '*' },
+ *       { from: 8, to: 10, mask: '#' }
+ *     ]
+ *   }
+ * };
+ *
+ * const maskedValue = maskValue(config.value, config.masks);
+ * console.log(maskedValue); // Output: 'ab***gh###'
+ * ```
+ */
+var generic = ((value, masks) => {
+  if (!(masks === null || masks === void 0 ? void 0 : masks.generic)) return value;
+  let masked = value;
+  masks.generic.forEach(item => {
+    const {
+      to = masked.length,
+      mask
+    } = item;
+    let {
+      from
+    } = item;
+    if (to > value.length - 1) return;
+    if (from === 0) {
+      from = 1;
+    }
+    const maskedPortion = new Array(to - from + 2).join(mask);
+    masked = masked.slice(0, from - 1) + maskedPortion + masked.slice(to);
+  });
+  return masked;
+});
+
+/**
+ * Replaces all characters in a string with a specified replacement string or character.
+ *
+ * @param value - The value to be masked.
+ * @param masks - An object containing the mask configuration.
+ * @returns The masked value.
+ *
+ * @example
+ * ```typescript
+ * import { replaceAll } from './path/to/maskFunctions';
+ *
+ * const masks = { replaceAll: '*' };
+ *
+ * const maskedValue = replaceAll('12345', masks);
+ * console.log(maskedValue); // Output: '*****'
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   value: 'hello',
+ *   masks: { replaceAll: '*' }
+ * };
+ *
+ * const maskedValue = replaceAll(config.value, config.masks);
+ * console.log(maskedValue); // Output: '*****'
+ * ```
+ */
+const replaceAll = (value, masks) => {
+  let targetReplaceMask = masks.replaceAll;
+  if (!targetReplaceMask) return value;
+  if (typeof targetReplaceMask === 'number') {
+    targetReplaceMask = targetReplaceMask === null || targetReplaceMask === void 0 ? void 0 : targetReplaceMask.toString();
+  }
+  return new Array(String(value).length + 1).join(targetReplaceMask);
+};
+/**
+ * Formats a numeric value as a currency string based on the provided mask configuration.
+ *
+ * @param value - The numeric value to be formatted.
+ * @param masks - An object containing the mask configuration.
+ * @returns The formatted currency string.
+ *
+ * @example
+ * ```typescript
+ * import { currency } from './path/to/maskFunctions';
+ *
+ * const masks = {
+ *   currency: {
+ *     align: 'right',
+ *     decimal: ',',
+ *     precision: 2,
+ *     prefix: 'USD',
+ *     thousands: '.'
+ *   }
+ * };
+ *
+ * const formattedValue = currency(12345.67, masks);
+ * console.log(formattedValue); // Output: '12.345,67 $'
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   value: 9876.54,
+ *   masks: {
+ *     currency: {
+ *       align: 'right',
+ *       decimal: ',',
+ *       precision: 2,
+ *       prefix: 'EUR',
+ *       thousands: '.'
+ *     }
+ *   }
+ * };
+ *
+ * const formattedValue = currency(config.value, config.masks);
+ * console.log(formattedValue); // Output: '9.876,54 €'
+ * ```
+ */
+const currency = (value, masks) => {
+  if (!(masks === null || masks === void 0 ? void 0 : masks.currency)) return value;
+  const {
+    align = 'right',
+    decimal = '.',
+    precision = 2,
+    prefix = 'BBD',
+    thousands = ','
+  } = masks.currency;
+  const rawValue = isNumber$1(value) ? Number(value).toFixed(precision) : value;
+  let convertedValue = rawValue.replace(/[^0-9]/g, '');
+  if (!convertedValue) {
+    return '';
+  }
+  let integerPart = convertedValue.slice(0, convertedValue.length - precision).replace(/^0*/g, '').replace(/\B(?=(\d{3})+(?!\d))/g, thousands);
+  if (integerPart === '') {
+    integerPart = '0';
+  }
+  console.log('Before', {
+    convertedValue
+  });
+  if (align === 'right' && String(value).endsWith(' ')) {
+    convertedValue = convertedValue.slice(0, -1);
+  }
+  console.log('After', {
+    value,
+    convertedValue
+  });
+  let newRawValue = integerPart;
+  let decimalPart = convertedValue.slice(convertedValue.length - precision);
+  if (precision > 0) {
+    decimalPart = '0'.repeat(precision - decimalPart.length) + decimalPart;
+    newRawValue += decimal + decimalPart;
+  }
+  const symbol = getCurrencySymbol(prefix);
+  return align === 'left' ? `${symbol} ${newRawValue}` : `${newRawValue} ${symbol}`;
+};
+/**
+ * Applies a custom mask to a string based on the provided mask configuration.
+ *
+ * @param value - The value to be masked.
+ * @param masks - An object containing the mask configuration.
+ * @returns The masked value.
+ *
+ * @example
+ * ```typescript
+ * import { custom } from './path/to/maskFunctions';
+ *
+ * const masks = { custom: '##-##' };
+ *
+ * const maskedValue = custom('123456', masks);
+ * console.log(maskedValue); // Output: '12-34'
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   masks: { custom: '###-###' }
+ * };
+ *
+ * const maskedValue = custom(config.value, config.masks);
+ * console.log(maskedValue); // Output: '987-654'
+ * ```
+ */
+const custom = (value, masks) => {
+  if (!masks.custom || !value) return value;
+  let mask = '';
+  let index = 0;
+  for (let i = 0; i < masks.custom.length; i++) {
+    if (masks.custom[i] === '#') {
+      if (index < value.length) {
+        mask += value[index];
+        index++;
+      } else {
+        break;
+      }
+    } else {
+      mask += masks.custom[i];
+    }
+  }
+  return mask;
+};
+
+/**
+ * Applies a secure mask to a credit card number, hiding most of its digits.
+ *
+ * @param value - The credit card number to be masked.
+ * @returns The masked credit card number.
+ *
+ * @example
+ * ```typescript
+ * import { secureCreditCard } from './path/to/creditCardFunctions';
+ *
+ * const maskedCardNumber = secureCreditCard('1234567890123456');
+ * console.log(maskedCardNumber); // Output: '1xxxxxxxxxxxx456'
+ * ```
+ */
+const secureCreditCard = value => {
+  const maskValue = [{
+    from: 1,
+    to: 4,
+    mask: 'x'
+  }, {
+    from: 6,
+    to: 9,
+    mask: 'x'
+  }, {
+    from: 11,
+    to: 14,
+    mask: 'x'
+  }, {
+    from: 16,
+    to: 19,
+    mask: 'x'
+  }];
+  return generic(value, {
+    generic: maskValue
+  });
+};
+/**
+ * Formats a credit card number by inserting spaces every four characters.
+ *
+ * @param value - The credit card number to be formatted.
+ * @returns The formatted credit card number.
+ *
+ * @example
+ * ```typescript
+ * import { card } from './path/to/creditCardFunctions';
+ *
+ * const formattedCardNumber = card('1234567890123456');
+ * console.log(formattedCardNumber); // Output: '1234 5678 9012 3456'
+ * ```
+ */
+const card = value => {
+  return value.replace(/[^\dA-Z]/g, '').replace(/(.{4})/g, '$1 ').trim();
+};
+/**
+ * Formats a credit card expiration date (MM/YY).
+ *
+ * @param value - The expiration date to be formatted (in MMYY or MM/YY format).
+ * @returns The formatted expiration date.
+ *
+ * @example
+ * ```typescript
+ * import { cardDate } from './path/to/creditCardFunctions';
+ *
+ * const formattedCardDate = cardDate('1223');
+ * console.log(formattedCardDate); // Output: '12/23'
+ * ```
+ */
+const cardDate = value => formatDateCard(value);
+/**
+ * Formats a credit card FEIN (Federal Employer Identification Number) in a specific format.
+ *
+ * @param value - The FEIN to be formatted.
+ * @returns The formatted FEIN.
+ *
+ * @example
+ * ```typescript
+ * import { fein } from './path/to/creditCardFunctions';
+ *
+ * const formattedFEIN = fein('123456789');
+ * console.log(formattedFEIN); // Output: '12-3456789'
+ * ```
+ */
+const fein = value => formatDateCard(value, 9, '-');
+
+const masks = {
+  currency,
+  custom,
+  callback: (value, masks) => (masks === null || masks === void 0 ? void 0 : masks.callback) && masks.callback(value),
+  generic,
+  secureCreditCard,
+  card,
+  cardDate,
+  fein,
+  replaceAll
+};
+
+/**
+ * Validates the length of a value based on the provided validation rules.
+ *
+ * @param value - The value to be validated. Can be of any type but will be converted to a string for length validation.
+ * @param validations - An object containing the length validation rules.
+ * @returns `true` if the value meets the length validation rule, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import validateLength from './path/to/validationFunctions';
+ *
+ * const validations = {
+ *   length: {
+ *     target: 5,
+ *     rule: 'equal'
+ *   }
+ * };
+ *
+ * const isValid = validateLength('hello', validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: 'test',
+ *   validations: {
+ *     length: {
+ *       target: 4,
+ *       rule: 'equal'
+ *     }
+ *   }
+ * };
+ *
+ * const isValid = validateLength(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+var length = ((value, validations) => {
+  if (!validations.length || !value) return false;
+  let targetValue = value;
+  // We want length even if it is a numeric
+  if (typeof targetValue !== 'string') {
+    targetValue = (value === null || value === void 0 ? void 0 : value.toString()) || targetValue;
+  }
+  const condition = {
+    equal: targetValue.length !== validations.length.target,
+    notEqual: targetValue.length === validations.length.target,
+    less: targetValue.length >= validations.length.target,
+    lessOrEqual: targetValue.length > validations.length.target,
+    greater: targetValue.length <= validations.length.target,
+    greaterOrEqual: targetValue.length < validations.length.target
+  };
+  return condition[validations.length.rule];
+});
+
+/**
+ * Validates a Spanish NIF (Número de Identificación Fiscal).
+ *
+ * @param value - The NIF value to validate.
+ * @returns `true` if the NIF is invalid, otherwise `false`.
+ */
+const NIF_ES = value => {
+  if (value.length !== 9) return true;
+  if (!/^\d{8}$/.test(value.slice(0, 8))) {
+    return true;
+  }
+  const validLetters = 'TRWAGMYFPDXBNJZSQVHLCKE';
+  const numberPart = parseInt(value.slice(0, 8), 10);
+  const expectedLetter = validLetters[numberPart % 23];
+  return !(value[8].toUpperCase() === expectedLetter);
+};
+/**
+ * Validates a Portuguese NIF (Número de Identificação Fiscal).
+ *
+ * @param value - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_PT = value => {
+  const regex = /^\d{9}$/;
+  if (!regex.test(value)) return false;
+  const checkDigit = parseInt(value[8], 10);
+  const sum = Array.from(value.substring(0, 8)).reduce((acc, digit, index) => acc + parseInt(digit, 10) * (9 - index), 0);
+  const calculatedCheckDigit = 11 - sum % 11;
+  return calculatedCheckDigit === 10 || calculatedCheckDigit === 11 ? 0 === checkDigit : calculatedCheckDigit === checkDigit;
+};
+/**
+ * Validates an Italian NIF (Codice Fiscale).
+ *
+ * @param value - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_IT = value => {
+  const regex = /^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$/;
+  return regex.test(value);
+};
+/**
+ * Validates a German NIF (Steuerliche Identifikationsnummer).
+ *
+ * @param nif - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_DE = nif => {
+  const regex = /^\d{11}$/;
+  return regex.test(nif);
+};
+/**
+ * Validates a French NIF (Numéro d'Immatriculation Fiscale).
+ *
+ * @param nif - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_FR = nif => {
+  const regex = /^\d{2} \d{3} \d{3} \d{3} \d{3}$/;
+  return regex.test(nif);
+};
+/**
+ * Validates a UK NIF (National Insurance Number).
+ *
+ * @param value - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_UK = value => {
+  const regex = /^GB\d{9}|\d{12}|\d{3}[A-Z]{5}$/;
+  return regex.test(value);
+};
+/**
+ * Validates a Belgian NIF (Numéro d'Identification Fiscale).
+ *
+ * @param value - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_BE = value => {
+  const regex = /^\d{11}$/;
+  if (!regex.test(value)) return false;
+  const number = parseInt(value.substring(0, 9), 10);
+  const checkDigits = parseInt(value.substring(9), 10);
+  const mod = 97 - number % 97;
+  return mod === checkDigits;
+};
+/**
+ * Validates a Dutch NIF (Burgerservicenummer).
+ *
+ * @param value - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_NL = value => {
+  const regex = /^\d{9}$/;
+  if (!regex.test(value)) return false;
+  const total = value.split('').map((digit, index) => parseInt(digit, 10) * (9 - index)).reduce((sum, val) => sum + val, 0);
+  return total % 11 === 0;
+};
+/**
+ * Validates a Swedish NIF (Personnummer).
+ *
+ * @param value - The NIF value to validate.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ */
+const NIF_SE = value => {
+  const regex = /^\d{10,12}$/;
+  if (!regex.test(value)) return false;
+  const normalizedNIF = value.length === 12 ? value.substring(2) : value;
+  const total = normalizedNIF.split('').map((digit, index) => {
+    let num = parseInt(digit, 10) * (index % 2 === 0 ? 2 : 1);
+    if (num > 9) num -= 9;
+    return num;
+  }).reduce((sum, val) => sum + val, 0);
+  return total % 10 === 0;
+};
+/**
+ * Validates a NIF based on the locale.
+ *
+ * @param nif - The NIF value to validate.
+ * @param locale - The locale code to determine the type of NIF.
+ * @returns `true` if the NIF is valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { NIF } from './path/to/validationFunctions';
+ *
+ * const isValid = NIF('123456789', 'pt-PT');
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+const NIF = (nif, locale) => {
+  switch (locale) {
+    case 'pt-PT':
+      return NIF_PT(nif);
+    case 'es-ES':
+      return NIF_ES(nif);
+    case 'it-IT':
+      return NIF_IT(nif);
+    case 'de-DE':
+      return NIF_DE(nif);
+    case 'fr-FR':
+      return NIF_FR(nif);
+    case 'en-GB':
+      return NIF_UK(nif);
+    case 'nl-BE':
+    case 'fr-BE':
+      return NIF_BE(nif);
+    case 'nl-NL':
+      return NIF_NL(nif);
+    case 'sv-SE':
+      // Suécia
+      return NIF_SE(nif);
+    default:
+      throw new Error(`NIF validation not supported for locale: ${locale}`);
+  }
+};
+/**
+ * Validates a Spanish NIE (Número de Identificación de Extranjeros).
+ *
+ * @param value - The NIE value to validate.
+ * @returns `true` if the NIE is invalid, otherwise `false`.
+ */
+const NIE = value => {
+  if (value.length !== 9) return true;
+  const nieRegex = /^[XYZ]\d{7}[TRWAGMYFPDXBNJZSQVHLCKE]$/;
+  if (!nieRegex.test(value)) {
+    return true;
+  }
+  let fixedDocNumber = value.toUpperCase().padStart(9, '0');
+  fixedDocNumber = fixedDocNumber[0].replace(/[XYZ]/g, char => {
+    return {
+      X: '0',
+      Y: '1',
+      Z: '2'
+    }[char] || char;
+  }) + fixedDocNumber.slice(1);
+  return NIF_ES(fixedDocNumber);
+};
+const mod9710 = validationString => {
+  while (validationString.length > 2) {
+    const part = validationString.slice(0, 6);
+    const partInt = parseInt(part, 10);
+    if (isNaN(partInt)) {
+      return NaN;
+    }
+    validationString = partInt % 97 + validationString.slice(part.length);
+  }
+  return parseInt(validationString, 10) % 97;
+};
+/**
+ * Validates an IBAN (International Bank Account Number).
+ *
+ * @param value - The IBAN value to validate.
+ * @returns `true` if the IBAN is invalid, otherwise `false`.
+ */
+const IBAN = value => {
+  const iban = value.replace(/\s/g, '');
+  if (iban.length !== 24) return true;
+  const ibanRegex = /^(ES)[0-9]{22}$/;
+  if (!ibanRegex.test(iban)) {
+    return true;
+  }
+  const ES_ALPHABET_NUMBER = 1428;
+  const transformedIban = iban.substring(4) + ES_ALPHABET_NUMBER + iban.substring(2, 4);
+  return mod9710(transformedIban) !== 1;
+};
+/**
+ * Validates a Spanish CIF (Código de Identificación Fiscal).
+ *
+ * @param value - The CIF value to validate.
+ * @returns `true` if the CIF is invalid, otherwise `false`.
+ */
+const CIF = value => {
+  const cifRegex = /^[A-Z][0-9]{7}[A-J0-9]$/;
+  return !cifRegex.test(value);
+};
+/**
+ * General validation function for various document types based on the provided validation methods.
+ *
+ * @param value - The document value to validate.
+ * @param validations - An object containing validation methods.
+ * @returns `true` if the document is valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import validateDocument from './path/to/validationFunctions';
+ *
+ * const validations = {
+ *   document: {
+ *     type: 'NIF',
+ *     locale: 'pt-PT'
+ *   }
+ * };
+ *
+ * const isValid = validateDocument('123456789', validations);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+var document = ((value, validations) => {
+  if (!value || !validations.document) return true;
+  const validation = {
+    NIF: (value, locale) => NIF(value, locale),
+    NIE: value => NIE(value),
+    CIF: value => CIF(value),
+    IBAN: value => IBAN(value)
+  };
+  return validation[validations.document.type](value, validations.document.locale);
+});
+
+/**
+ * Validates if a value exceeds the maximum allowed value.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the maximum value for validation.
+ * @returns `true` if the value exceeds the maximum, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { max } from './path/to/validationFunctions';
+ *
+ * const validations = { max: 10 };
+ *
+ * const isValid = max(15, validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: '8',
+ *   validations: { max: 10 }
+ * };
+ *
+ * const isValid = max(config.inputValue, config.validations);
+ * console.log(isValid); // Output: false
+ * ```
+ */
+const max = (value, validations) => {
+  const number = Number(value);
+  if (!validations.max || Number.isNaN(number)) return false;
+  return number > Number(validations.max);
+};
+/**
+ * Validates if a value is less than the minimum allowed value.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the minimum value for validation.
+ * @returns `true` if the value is less than the minimum, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { min } from './path/to/validationFunctions';
+ *
+ * const validations = { min: 5 };
+ *
+ * const isValid = min(3, validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: '8',
+ *   validations: { min: 10 }
+ * };
+ *
+ * const isValid = min(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true
+ * ```
+ */
+const min = (value, validations) => {
+  const number = Number(value);
+  if (!validations.min || Number.isNaN(number)) return false;
+  return number < Number(validations.min);
+};
+/**
+ * Validates if a value falls within a specified range.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the range (start and end) for validation.
+ * @returns `true` if the value falls within the range, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { between } from './path/to/validationFunctions';
+ *
+ * const validations = { between: { start: 5, end: 10 } };
+ *
+ * const isValid = between(7, validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: '4',
+ *   validations: { between: { start: 5, end: 10 } }
+ * };
+ *
+ * const isValid = between(config.inputValue, config.validations);
+ * console.log(isValid); // Output: false
+ * ```
+ */
+const between = (value, validations) => {
+  if (!validations.between || !value) return false;
+  const num = Number(value);
+  return !Number.isNaN(num) && !(+num >= validations.between.start && +num <= validations.between.end);
+};
+/**
+ * Validates if a value contains sequential numbers.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the validation methods.
+ * @returns `true` if the value contains sequential numbers, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { sequential } from './path/to/validationFunctions';
+ *
+ * const validations = { sequential: true };
+ *
+ * const isValid = sequential('12345', validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using in a React component
+ * const MyComponent = ({ inputValue }) => {
+ *   const isValid = sequential(inputValue, validations);
+ *   return <div>{isValid ? 'Valid' : 'Invalid'}</div>;
+ * };
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: '98765',
+ *   validations: { sequential: true }
+ * };
+ *
+ * const isValid = sequential(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true
+ * ```
+ */
+const sequential = (value, validations) => {
+  if (!validations.sequential) return false;
+  const numbers = '0123456789';
+  const numbersRev = '9876543210';
+  const replacedValue = String(value).replace(/[^0-9]/g, '');
+  return !(numbers.indexOf(replacedValue) === -1 && numbersRev.indexOf(replacedValue) === -1);
+};
+
+/**
+ * Validates if a value matches a given regular expression.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the regex pattern for validation.
+ * @returns `true` if the value does not match the regex, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { regex } from './path/to/validationFunctions';
+ *
+ * const validations = { regex: '^[a-zA-Z0-9]*$' };
+ *
+ * const isValid = regex('abc123', validations);
+ * console.log(isValid); // Output: false
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: 'abc123',
+ *   validations: { regex: '^[a-zA-Z0-9]*$' }
+ * };
+ *
+ * const isValid = regex(config.inputValue, config.validations);
+ * console.log(isValid); // Output: false
+ * ```
+ */
+const regex = (value, validations) => {
+  if (!validations.regex || !value) return false;
+  const regex = new RegExp(validations.regex);
+  return !regex.test(value);
+};
+/**
+ * Validates if a value is a valid email address.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the email validation flag.
+ * @returns `true` if the value is not a valid email, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { email } from './path/to/validationFunctions';
+ *
+ * const validations = { email: true };
+ *
+ * const isValid = email('test@example.com', validations);
+ * console.log(isValid); // Output: false
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: 'invalid-email',
+ *   validations: { email: true }
+ * };
+ *
+ * const isValid = email(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true
+ * ```
+ */
+const email = (value, validations) => {
+  if (!validations.email || !value) return false;
+  const regex = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  return !regex.test(value);
+};
+/**
+ * Validates if a value is a valid URL.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the URL validation flag.
+ * @returns `true` if the value is not a valid URL, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { url } from './path/to/validationFunctions';
+ *
+ * const validations = { url: true };
+ *
+ * const isValid = url('https://example.com', validations);
+ * console.log(isValid); // Output: false
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: 'invalid-url',
+ *   validations: { url: true }
+ * };
+ *
+ * const isValid = url(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true
+ * ```
+ */
+const url = (value, validations) => {
+  if (!validations.url || !value) return false;
+  const regex = /[(http(s)?)://(www.)?a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&//=]*)/gi;
+  return !regex.test(value);
+};
+/**
+ * Validates if a value contains only letters.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the onlyLetters validation flag.
+ * @returns `true` if the value contains non-letter characters, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { onlyLetters } from './path/to/validationFunctions';
+ *
+ * const validations = { onlyLetters: true };
+ *
+ * const isValid = onlyLetters('abc', validations);
+ * console.log(isValid); // Output: false
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: '123',
+ *   validations: { onlyLetters: true }
+ * };
+ *
+ * const isValid = onlyLetters(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true
+ * ```
+ */
+const onlyLetters = (value, validations) => {
+  if (!validations.onlyLetters) return false;
+  return !/^[\p{L}\s]*$/u.test(value);
+};
+/**
+ * Validates if a value does not contain spaces.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the notAllowSpaces validation flag.
+ * @returns `true` if the value contains spaces, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { notAllowSpaces } from './path/to/validationFunctions';
+ *
+ * const validations = { notAllowSpaces: true };
+ *
+ * const isValid = notAllowSpaces('no spaces', validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: 'nospaces',
+ *   validations: { notAllowSpaces: true }
+ * };
+ *
+ * const isValid = notAllowSpaces(config.inputValue, config.validations);
+ * console.log(isValid); // Output: false
+ * ```
+ */
+const notAllowSpaces = (value, validations) => {
+  if (!validations.notAllowSpaces) return false;
+  return /\s/.test(value);
+};
+/**
+ * Validates if a value is a number.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the isNumber validation flag.
+ * @returns `true` if the value is not a number, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { isNumber } from './path/to/validationFunctions';
+ *
+ * const validations = { isNumber: true };
+ *
+ * const isValid = isNumber('123', validations);
+ * console.log(isValid); // Output: false
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: 'abc',
+ *   validations: { isNumber: true }
+ * };
+ *
+ * const isValid = isNumber(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true
+ * ```
+ */
+const isNumber = (value, validations) => {
+  if (!validations.isNumber) return false;
+  return !!value && !/^[0-9\s]*$/.test(value);
+};
+/**
+ * Validates if a value has no trailing or leading spaces.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the hasNoExtraSpaces validation flag.
+ * @returns `true` if the value has trailing or leading spaces, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { hasNoExtraSpaces } from './path/to/validationFunctions';
+ *
+ * const validations = { hasNoExtraSpaces: true };
+ *
+ * const isValid = hasNoExtraSpaces('Hello', validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: ' Hello ',
+ *   validations: { hasNoExtraSpaces: true }
+ * };
+ *
+ * const isValid = hasNoExtraSpaces(config.inputValue, config.validations);
+ * console.log(isValid); // Output: false
+ * ```
+ */
+const hasNoExtraSpaces = (value, validations) => {
+  if (!validations.hasNoExtraSpaces || !value) return false;
+  return regex(value, {
+    regex: '^[A-Za-zÀ-ÖØ-öø-ÿäöüÄÖÜß0-9]+$'
+  });
+};
+/**
+ * Validates if a value contains repeated digits.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing the repeated validation flag.
+ * @returns `true` if the value contains repeated digits, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { repeated } from './path/to/validationFunctions';
+ *
+ * const validations = { repeated: true };
+ *
+ * const isValid = repeated('1231', validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: '1234',
+ *   validations: { repeated: true }
+ * };
+ *
+ * const isValid = repeated(config.inputValue, config.validations);
+ * console.log(isValid); // Output: false
+ * ```
+ */
+const repeated = (value, validations) => {
+  if (!validations.repeated) return false;
+  const numCount = {};
+  for (const char of String(value)) {
+    if (/\d/.test(char)) {
+      if (numCount[char]) {
+        return true;
+      }
+      numCount[char] = 1;
+    }
+  }
+  return false;
+};
+
+/**
+ * Executes a custom callback validation function if provided.
+ *
+ * @param value - The value to be validated.
+ * @param validations - An object containing validation methods, including a custom callback function.
+ * @returns `true` if the custom callback validation function returns `true`, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { callback } from './path/to/validationFunctions';
+ *
+ * const validations = {
+ *   callback: (value) => typeof value === 'string' && value.length > 5
+ * };
+ *
+ * // Or from a JSON config
+ * const schema = {
+ *   validations: {
+ *     callback: (value) => typeof value === 'string' && value.length > 5
+ *   }
+ * };
+ * ```
+ */
+const callback = (value, validations) => {
+  if (!validations.callback || !((validations === null || validations === void 0 ? void 0 : validations.callback) instanceof Function)) return false;
+  return validations.callback(value);
+};
+
+/**
+ * Checks if a value is included in the specified array within the validation rules.
+ *
+ * @param value - The value to be checked.
+ * @param validations - An object containing validation methods, including an array of allowed values.
+ * @returns `true` if the value is included in the array, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { includes } from './path/to/validationFunctions';
+ *
+ * const validations = {
+ *   includes: ['apple', 'banana', 'cherry']
+ * };
+ *
+ * const isValid = includes('banana', validations);
+ * console.log(isValid); // Output: true
+ *
+ * // Using from a JSON config
+ * const config = {
+ *   inputValue: 'apple',
+ *   validations: {
+ *     includes: ['apple', 'banana', 'cherry']
+ *   }
+ * };
+ *
+ * const isValid = includes(config.inputValue, config.validations);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+const includes = (value, validations) => {
+  if (!value || !Array.isArray(validations === null || validations === void 0 ? void 0 : validations.includes)) return false;
+  return !validations.includes.some(code => code === value || JSON.stringify(code) === value);
+};
+
+/**
+ * Validates if a given value is a valid credit card number based on predefined validation methods.
+ *
+ * @param value - The value to be validated as a credit card number.
+ * @param validations - An object containing validation methods.
+ * @returns `true` if the value is either falsy or does not match a valid credit card type, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { isCreditCard } from './path/to/validationFunctions';
+ * import { validationMethods } from './path/to/validationConfig';
+ *
+ * const isValid = isCreditCard('4111111111111111', validationMethods);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+const isCreditCard = (value, validations) => {
+  if (!value) return true;
+  const [type] = getTypeCard(String(value), validations.isCreditCard);
+  return !type;
+};
+/**
+ * Validates if a given security code matches the expected length for a specified credit card type.
+ *
+ * @param value - The security code to be validated.
+ * @param validations - An object containing validation methods, specifically with `isCreditCodeMatch` details.
+ * @returns `true` if the value is either falsy or if the validation methods are not provided. Otherwise, it checks if the security code length matches the expected length for the card type.
+ *
+ * @example
+ * ```typescript
+ * import { isCreditCodeMatch } from './path/to/validationFunctions';
+ * import { validationMethods } from './path/to/validationConfig';
+ *
+ * const isValid = isCreditCodeMatch('123', validationMethods);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+const isCreditCodeMatch = (value, validations) => {
+  var _a;
+  if (!value || !validations.isCreditCodeMatch) return false;
+  const [type] = getTypeCard(validations.isCreditCodeMatch.numberCard, validations.isCreditCodeMatch.availableOptions);
+  return ((_a = type === null || type === void 0 ? void 0 : type.code) === null || _a === void 0 ? void 0 : _a.size) !== value.length;
+};
+/**
+ * Validates if a given value is a valid credit card number and checks if its length matches the expected lengths for the card type.
+ *
+ * @param value - The credit card number to be validated.
+ * @param validations - An object containing validation methods, specifically with `isCreditCardAndLength` details.
+ * @returns `true` if the value is either falsy or if the card number does not match any valid lengths for the card type, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * import { isCreditCardAndLength } from './path/to/validationFunctions';
+ * import { validationMethods } from './path/to/validationConfig';
+ *
+ * const isValid = isCreditCardAndLength('4111111111111111', validationMethods);
+ * console.log(isValid); // Output: true or false based on validation
+ * ```
+ */
+const isCreditCardAndLength = (value, validations) => {
+  if (!value || !validations.isCreditCardAndLength) return false;
+  const [type, rawValue] = getTypeCard(value, validations.isCreditCardAndLength);
+  return type && !type.lengths.includes(rawValue.length);
+};
+
+/**
+ * Validates that a string value is not empty.
+ *
+ * @param {string} value - The value to be validated.
+ * @param {TValidationMethods} validations - The validation methods object containing the notEmpty validation rule.
+ * @returns {boolean} - Returns `true` if the value is empty and the notEmpty validation rule is set, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * // Assume validations is an object with a notEmpty property
+ * const validations = { notEmpty: true };
+ *
+ * // Returns true because the string is empty
+ * const result1 = notEmpty('', validations);
+ * console.log(result1); // true
+ *
+ * // Returns false because the string is not empty
+ * const result2 = notEmpty('hello', validations);
+ * console.log(result2); // false
+ *
+ * // Returns false because the notEmpty validation rule is not set
+ * const result3 = notEmpty('', { notEmpty: false });
+ * console.log(result3); // false
+ * ```
+ */
+const notEmpty = (value, validations) => {
+  var _a;
+  if (!(validations === null || validations === void 0 ? void 0 : validations.notEmpty) || typeof value === 'undefined') return false;
+  return value === null || value === '' || value === 0 || !((_a = String(value)) === null || _a === void 0 ? void 0 : _a.trim().length);
+};
+/**
+ * Validates that a value matches a specified value.
+ *
+ * @param {unknown} value - The value to be validated.
+ * @param {TValidationMethods} validations - The validation methods object containing the value validation rule.
+ * @returns {boolean} - Returns `true` if the value does not match the specified validation value, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * // Assume validations is an object with a value property
+ * const validations = { value: 42 };
+ *
+ * // Returns true because the value does not match the validation value
+ * const result1 = value(10, validations);
+ * console.log(result1); // true
+ *
+ * // Returns false because the value matches the validation value
+ * const result2 = value(42, validations);
+ * console.log(result2); // false
+ *
+ * // Returns false because the value validation rule is not set
+ * const result3 = value(10, { value: undefined });
+ * console.log(result3); // false
+ * ```
+ */
+const value = (value, validations) => {
+  if (typeof (validations === null || validations === void 0 ? void 0 : validations.value) === 'undefined' || (validations === null || validations === void 0 ? void 0 : validations.value) === null || typeof value === 'undefined' || value === null) return false;
+  return value != validations.value;
+};
+
+/**
+ * Validates that a value is required.
+ *
+ * @param {unknown} value - The value to be validated.
+ * @param {TValidationMethods} validations - The validation methods object containing the required validation rule.
+ * @returns {boolean} - Returns `true` if the value is required and is empty or not provided, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * // Assume validations is an object with a required property
+ * const validations = { required: true };
+ *
+ * // Returns true because the value is required and is empty
+ * const result1 = required('', validations);
+ * console.log(result1); // true
+ *
+ * // Returns false because the value is required and is provided
+ * const result2 = required('text', validations);
+ * console.log(result2); // false
+ *
+ * // Returns false because the required validation rule is not set
+ * const result3 = required('', { required: false });
+ * console.log(result3); // false
+ * ```
+ */
+const required = (value, validations) => !!(validations.required && (!value || typeof value === 'string' && value.trim().length === 0));
+/**
+ * Validates that a value matches a boolean rule. Useful with iVars property.
+ *
+ * @param _
+ * @param {TValidationMethods} validations - The validation methods object containing the boolean validation rule.
+ * @returns {boolean} - Returns `true` if the boolean validation rule is set and fails, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * // Assume validations is an object with a bool property
+ * const validations = { bool: true };
+ *
+ * // Returns true because the boolean validation rule is set to fail
+ * const result1 = bool(null, validations);
+ * console.log(result1); // true
+ *
+ * // Returns false because the boolean validation rule is not set
+ * const result2 = bool(null, { bool: false });
+ * console.log(result2); // false
+ * ```
+ */
+const bool = (_, validations) => {
+  if (!(validations === null || validations === void 0 ? void 0 : validations.bool)) return false;
+  let fail = false;
+  if (typeof validations.bool === 'boolean') {
+    fail = validations.bool;
+  }
+  return fail;
+};
+/**
+ * Validates that a value exists. Useful with iVars property.
+ *
+ * @param {unknown} value - The value to be validated.
+ * @param {TValidationMethods} validations - The validation methods object containing the exists validation rule.
+ * @returns {boolean} - Returns `true` if the value does not exist when the exists rule is set, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * // Assume validations is an object with an exists property
+ * const validations = { exists: true };
+ *
+ * // Returns true because the value does not exist
+ * const result1 = exists(null, validations);
+ * console.log(result1); // true
+ *
+ * // Returns false because the value exists
+ * const result2 = exists('text', validations);
+ * console.log(result2); // false
+ *
+ * // Returns false because the exists validation rule is not set
+ * const result3 = exists(null, { exists: false });
+ * console.log(result3); // false
+ * ```
+ */
+const exists = (value, validations) => {
+  if (!validations.exists) return false;
+  let fail = !validations.exists;
+  if (!fail) {
+    fail = !value;
+  }
+  return fail;
+};
+
+/**
+ * @internal
+ * Evaluates a condition based on the provided rule and value.
+ *
+ * @param {number | string | boolean} value - The value to be used in the condition evaluation.
+ * @param {TConditionsValidationSet} rule - The rule defining the condition to be evaluated.
+ * @returns {boolean} - The result of the condition evaluation.
+ *
+ * @example
+ * const rule = {
+ *   condition: '===',
+ *   origin: 5,
+ *   target: 5,
+ * };
+ * const result = conditionResult(5, rule);
+ * console.log(result); // true (5 === 5)
+ *
+ * @example
+ * const rule = {
+ *   condition: '!==',
+ *   origin: 5,
+ *   target: 10,
+ * };
+ * const result = conditionResult(5, rule);
+ * console.log(result); // true (5 !== 10)
+ *
+ * @example
+ * const rule = {
+ *   condition: '<',
+ *   origin: 5,
+ *   target: 10,
+ * };
+ * const result = conditionResult(5, rule);
+ * console.log(result); // true (5 < 10)
+ */
+const conditionResult = (value, rule) => {
+  if (rule.forceDefinedOrigin && rule.origin === undefined || rule.forceDefinedTarget && rule.target === undefined) {
+    return false;
+  }
+  const origin = rule.origin === undefined ? value : rule.origin;
+  const target = rule.target === undefined ? value : rule.target;
+  const conditionMapper = {
+    '!==': (origin || value) !== (target || value),
+    '===': (origin || value) === (target || value),
+    '<': (origin || value) < (target || value),
+    '>': (origin || value) > (target || value),
+    '<=': (origin || value) <= (target || value),
+    '>=': (origin || value) >= (target || value),
+    '!!origin': !!String(origin || value).trim().length
+  };
+  return conditionMapper[rule.condition];
+};
+/**
+ * Validates that a value meets specified conditions.
+ *
+ * @param {number | string | boolean} value - The value to be validated.
+ * @param {TValidationMethods} validations - The validation methods object containing the conditions validation rule.
+ * @returns {boolean} - Returns `true` if the value meets the specified conditions, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * // Assume validations is an object with a conditions property
+ * const validations = {
+ *   conditions: {
+ *     rule: 'and',
+ *     set: [
+ *       { condition: '===', origin: 10, target: 10 },
+ *       { condition: '!==', origin: 5, target: 3 }
+ *     ]
+ *   }
+ * };
+ *
+ * // Returns true because both conditions are met
+ * const result1 = conditions(10, validations);
+ * console.log(result1); // true
+ *
+ * // Returns false because the second condition is not met
+ * const result2 = conditions(5, validations);
+ * console.log(result2); // false
+ *
+ * // Returns true because at least one condition is met with 'or' rule
+ * const orValidations = {
+ *   conditions: {
+ *     rule: 'or',
+ *     set: [
+ *       { condition: '===', origin: 10, target: 5 },
+ *       { condition: '!==', origin: 5, target: 3 }
+ *     ]
+ *   }
+ * };
+ * const result3 = conditions(10, orValidations);
+ * console.log(result3); // true
+ * ```
+ */
+const conditions = (value, validations) => {
+  if (!validations.conditions) return false;
+  const rulesMapper = {
+    and: () => {
+      var _a;
+      return !!((_a = validations.conditions) === null || _a === void 0 ? void 0 : _a.set.every(validate => conditionResult(value, validate)));
+    },
+    or: () => {
+      var _a;
+      return !!((_a = validations.conditions) === null || _a === void 0 ? void 0 : _a.set.some(validate => conditionResult(value, validate)));
+    }
+  };
+  let result = rulesMapper[validations.conditions.rule]();
+  if (validations.conditions.conditions) {
+    if (validations.conditions.rule === 'and') {
+      result = result && conditions(value, {
+        conditions: validations.conditions.conditions
+      });
+    } else {
+      result = result || conditions(value, {
+        conditions: validations.conditions.conditions
+      });
+    }
+  }
+  return !result;
+};
+
+/**
+ * Validates if a date value falls between two specified dates.
+ *
+ * @param {string} value - The date value to be validated in string format.
+ * @param {TValidationMethods} validations - The validation methods object containing the betweenDates validation rules.
+ * @returns {boolean} - Returns `true` if the date value fails the betweenDates validation, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const validations = {
+ *   betweenDates: [
+ *     { origin: { value: '2023-01-01', format: 'yyyy-MM-dd' }, operator: '>=' },
+ *     { origin: { value: '2023-12-31', format: 'yyyy-MM-dd' }, operator: '<=' }
+ *   ]
+ * };
+ *
+ * const result1 = betweenDates('2023-06-01', validations);
+ * console.log(result1); // false (date is within the range)
+ *
+ * const result2 = betweenDates('2024-01-01', validations);
+ * console.log(result2); // true (date is outside the range)
+ * ```
+ */
+const betweenDates = (value, validations) => {
+  var _a;
+  let fail = false;
+  if (((_a = validations.betweenDates) === null || _a === void 0 ? void 0 : _a.length) != 2) return false;
+  for (const validation of validations.betweenDates) {
+    if (date(value, {
+      date: validation
+    })) {
+      fail = true;
+      break;
+    }
+  }
+  return fail;
+};
+/**
+ * @internal
+ * Adjusts a date by adding intervals of years, months, or days.
+ *
+ * @param {Date} date - The initial date.
+ * @param {TDateInterval} intervals - An object specifying the intervals to add.
+ * @returns {Date} - The adjusted date.
+ *
+ * @example
+ * const initialDate = new Date('2023-01-01');
+ * const intervals = { years: 1, months: 6, days: 15 };
+ * const newDate = getIntervalsDate(initialDate, intervals);
+ * console.log(newDate); // Expected date: '2024-07-16'
+ */
+const getIntervalsDate = (date, intervals) => {
+  const intervalsMapper = {
+    years: (date, value) => new Date(date.setUTCFullYear(date.getUTCFullYear() + value)),
+    months: (date, value) => new Date(date.setUTCMonth(date.getUTCMonth() + value)),
+    days: (date, value) => new Date(date.setDate(date.getUTCDate() + value))
+  };
+  return Object.keys(intervals).reduce((acc, interval) => intervalsMapper[interval](acc, intervals[interval]), new Date(date));
+};
+/**
+ * @internal
+ * A mapper object for rearranging date strings into different formats.
+ *
+ * @type {Record<TDateFormatsValidation, (value: string) => string>}
+ *
+ * @example
+ * const formattedDate1 = dateRearrangeMapper['DDMMYYYY']('01-12-2023');
+ * console.log(formattedDate1); // '12/01/2023'
+ *
+ * const formattedDate2 = dateRearrangeMapper['YYYYMMDD']('2023-12-01');
+ * console.log(formattedDate2); // '12/01/2023'
+ */
+const dateRearrangeMapper = {
+  DDMMYYYY: value => {
+    const dateParts = value.split(value.includes('/') ? '/' : '-');
+    return `${dateParts[1]}/${dateParts[0]}/${dateParts[2]}`;
+  },
+  YYYYMMDD: value => {
+    const dateParts = value.split(value.includes('/') ? '/' : '-');
+    return `${dateParts[1]}/${dateParts[2]}/${dateParts[0]}`;
+  },
+  YYYYDDMM: value => {
+    const dateParts = value.split(value.includes('/') ? '/' : '-');
+    return `${dateParts[2]}/${dateParts[1]}/${dateParts[0]}`;
+  },
+  MMDDYYYY: value => value,
+  timestamp: value => new Date(value).toString()
+};
+/**
+ * @function date
+ * Validates a date value based on various date conditions and intervals.
+ *
+ * @param {string} value - The date value to be validated in string format.
+ * @param {TValidationMethods} validations - The validation methods object containing the date validation rules.
+ * @returns {boolean} - Returns `true` if the date validation fails, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const validations = {
+ *   date: {
+ *     origin: {
+ *       value: '2023-01-01',
+ *       format: 'YYYY-MM-DD'
+ *     },
+ *     target: {
+ *       value: '2023-12-31',
+ *       format: 'YYYY-MM-DD'
+ *     },
+ *     operator: '<=',
+ *     onlyValidDate: true
+ *   }
+ * };
+ *
+ * const result1 = date('2023-06-01', validations);
+ * console.log(result1); // false (date is within the range)
+ *
+ * const result2 = date('2024-01-01', validations);
+ * console.log(result2); // true (date is outside the range)
+ * ```
+ */
+const date = (value, validations) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+  if (!((_b = (_a = validations.date) === null || _a === void 0 ? void 0 : _a.target) === null || _b === void 0 ? void 0 : _b.value) && !((_d = (_c = validations.date) === null || _c === void 0 ? void 0 : _c.origin) === null || _d === void 0 ? void 0 : _d.intervals)) {
+    return false;
+  }
+  const originValue = validations.date.origin.value || value;
+  let originDate = new Date(dateRearrangeMapper[(_e = validations.date) === null || _e === void 0 ? void 0 : _e.origin.format](originValue).toString());
+  let targetDate = new Date();
+  let target = new Date();
+  if ((_g = (_f = validations.date) === null || _f === void 0 ? void 0 : _f.target) === null || _g === void 0 ? void 0 : _g.format) {
+    target = new Date(dateRearrangeMapper[(_j = (_h = validations.date) === null || _h === void 0 ? void 0 : _h.target) === null || _j === void 0 ? void 0 : _j.format](validations.date.target.value).toString());
+    targetDate = target;
+  }
+  if (validations.date.origin.intervals) {
+    targetDate = getIntervalsDate(originDate, validations.date.origin.intervals);
+    const date = new Date();
+    if (((_k = validations.date.target) === null || _k === void 0 ? void 0 : _k.value) && target) {
+      date.setDate(target.getDate());
+      date.setMonth(target.getMonth());
+    }
+    originDate = new Date(`${date.getUTCMonth() + 1}/${date.getUTCDate()}/${date.getUTCFullYear()}`);
+  }
+  if (validations.date.onlyValidDate && (!(targetDate instanceof Date && isFinite(targetDate)) || !(targetDate instanceof Date && isFinite(originDate)) || originValue.length < 8)) {
+    return true;
+  }
+  const originTimestamp = originDate.getTime();
+  const targetTimestamp = targetDate.getTime();
+  const operationsMapper = {
+    '>': originTimestamp > targetTimestamp,
+    '>=': originTimestamp >= targetTimestamp,
+    '<': originTimestamp < targetTimestamp,
+    '<=': originTimestamp <= targetTimestamp,
+    '===': originTimestamp === targetTimestamp,
+    '!==': originTimestamp !== targetTimestamp
+  };
+  return operationsMapper[(_l = validations.date) === null || _l === void 0 ? void 0 : _l.operator];
+};
+/**
+ * @function validDate
+ * Validates that a date string is a valid date according to the given format.
+ *
+ * @param {string} value - The date value to be validated in string format.
+ * @param {TValidationMethods} validations - The validation methods object containing the validDate rule.
+ * @returns {boolean} - Returns `true` if the date is not valid, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const validations = { validDate: 'MM-dd-yyyy' };
+ *
+ * const result1 = validDate('12-31-2023', validations);
+ * console.log(result1); // false (date is valid)
+ *
+ * const result2 = validDate('02-30-2023', validations);
+ * console.log(result2); // true (date is invalid)
+ * ```
+ */
+const validDate = (value, validations) => {
+  if (!validations.validDate || !value) return false;
+  if (/[^a-zA-Z0-9\s-]/.test(value)) return true;
+  const dateParts = dateRearrangeMapper[validations.validDate](value).toString().split(/[/-]/);
+  const year = parseInt(dateParts[2], 10);
+  const month = parseInt(dateParts[0], 10) - 1; // Month is zero-based
+  const day = parseInt(dateParts[1], 10);
+  const date = new Date(year, month, day);
+  // Check if the date is valid
+  const isValidDate = date.getFullYear() === year && date.getMonth() === month && date.getDate() === day;
+  return !isValidDate;
+};
+
+/**
+ * @internal
+ * An object mapping validation keys to their respective validation functions.
+ *
+ * @type {Record<keyof TAvailableValidations, (value: unknown, validations: TAvailableValidations) => boolean>}
+ *
+ * @example
+ * const isValid = validations.max(5, { max: 10 });
+ * console.log(isValid); // false (5 is not greater than 10)
+ */
+const validations$1 = {
+  max,
+  min,
+  length,
+  regex,
+  url,
+  email,
+  onlyLetters,
+  notAllowSpaces,
+  callback,
+  hasNoExtraSpaces,
+  between,
+  sequential,
+  includes,
+  repeated,
+  document,
+  isCreditCard,
+  isCreditCodeMatch,
+  isCreditCardAndLength,
+  required,
+  value,
+  notEmpty,
+  bool,
+  exists,
+  greaterThan: () => true,
+  isNumber,
+  conditions,
+  validDate,
+  date,
+  betweenDates
+};
+/**
+ * @internal
+ * Runs a set of validation handlers against a given value.
+ *
+ * @param {unknown} value - The value to be validated.
+ * @param {TValidationMethods} handlers - An object containing validation methods to be applied.
+ * @returns {boolean[]} - An array of boolean results for each validation method.
+ *
+ * @example
+ * const handlers = {
+ *   max: { max: 10 },
+ *   required: true,
+ *   email: true
+ * };
+ * const results = run('test@example.com', handlers);
+ * console.log(results); // [false, false, true] (value fails 'max', passes 'required', passes 'email')
+ */
+const run = (value, handlers) => {
+  const runner = [];
+  Object.keys(handlers).forEach(rule => {
+    runner.push(validations$1[rule](value, {
+      [rule]: handlers[rule]
+    }));
+  });
+  return runner;
+};
+/**
+ * Validates that a value meets multiple validation rules.
+ *
+ * @param {number | string | boolean} value - The value to be validated.
+ * @param {TValidationMethods} validations - The validation methods object containing the multipleValidations rule set.
+ * @returns {boolean} - Returns `true` if the value meets the specified multiple validation rules, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * // Assume validations is an object with a multipleValidations property
+ * const validations = {
+ *   multipleValidations: {
+ *     rule: 'AND',
+ *     validations: {
+ *       required: true,
+ *       isNumber: true
+ *     }
+ *   }
+ * };
+ *
+ * // Returns true because both required and isNumber validations pass
+ * const result1 = multipleValidations(123, validations);
+ * console.log(result1); // true
+ *
+ * // Returns false because the value is not a number
+ * const result2 = multipleValidations('abc', validations);
+ * console.log(result2); // false
+ * ```
+ */
+const multipleValidations = (value, validations) => {
+  if (!validations.multipleValidations) return false;
+  const runner = run(value, validations.multipleValidations.validations);
+  const rulesMapper = {
+    AND: () => runner.every(validation => validation),
+    OR: () => runner.some(validation => validation),
+    NOT: () => !runner.every(validation => validation)
+  };
+  return rulesMapper[validations.multipleValidations.rule]();
+};
+
+const validations = {
+  max,
+  min,
+  length,
+  regex,
+  url,
+  email,
+  onlyLetters,
+  notAllowSpaces,
+  callback,
+  hasNoExtraSpaces,
+  between,
+  sequential,
+  includes,
+  repeated,
+  document,
+  isCreditCard,
+  isCreditCodeMatch,
+  isCreditCardAndLength,
+  required,
+  value,
+  notEmpty,
+  bool,
+  exists,
+  greaterThan: () => true,
+  isNumber,
+  conditions,
+  multipleValidations,
+  date,
+  betweenDates,
+  validDate
+};
+
+/**
+ * Represents a form field with observables for managing form state, validations, and API requests.
+ */
+class FormField {
+  /**
+   * Creates an instance of FormField.
+   *
+   * @param {object} options - Configuration options for the form field.
+   * @param {IComponentSchema} options.schemaComponent - The schema definition for the form field.
+   * @param {string} [options.path] - The path within the form field (used internally during recursion).
+   * @param {string[]} options.children - An array of children fields names.
+   * @param {Function} options.validateVisibility - A function to validate the visibility of the field.
+   * @param {Function} options.resetValue - A function to reset the field value.
+   * @param {unknown} [options.initialValue] - The initial value of the form field.
+   * @param {Subject<{ key: string }>} options.templateSubject$ - A subject for template updates.
+   */
+  constructor({
+    schemaComponent,
+    path,
+    children,
+    validateVisibility,
+    resetValue,
+    initialValue,
+    templateSubject$,
+    apiResponseSubject$,
+    dataSubject$,
+    mapper
+  }) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.fieldStateSubscription$ = new Subscription();
+    this.name = schemaComponent.name;
+    this.component = schemaComponent.component;
+    this.path = path;
+    this.children = children;
+    this.validations = schemaComponent.validations;
+    this.errorMessages = schemaComponent.errorMessages;
+    this.visibilityConditions = schemaComponent.visibilityConditions;
+    this.resetValues = schemaComponent.resetValues;
+    this.apiSchema = schemaComponent.api;
+    this.formatters = schemaComponent.formatters;
+    this.masks = schemaComponent.masks;
+    if (mapper.valueChangeEvent) this.valueChangeEvent = mapper.valueChangeEvent;
+    if ((_a = mapper.events) === null || _a === void 0 ? void 0 : _a.setValue) this.valuePropName = mapper.events.setValue;
+    if ((_b = mapper.events) === null || _b === void 0 ? void 0 : _b.setErrorMessage) this.errorMessagePropName = mapper.events.setErrorMessage;
+    this.mapper = mapper;
+    this.validateVisibility = validateVisibility;
+    this.resetValue = resetValue;
+    this.templateSubject$ = templateSubject$;
+    this.apiResponseSubject$ = apiResponseSubject$;
+    this.dataSubject$ = dataSubject$;
+    this._props = schemaComponent.props || {};
+    this._value = '';
+    this._stateValue = '';
+    this._metadata = '';
+    this.initialValue = initialValue;
+    this._visibility = true;
+    this._api = {
+      default: {
+        response: ((_e = (_d = (_c = this.apiSchema) === null || _c === void 0 ? void 0 : _c.defaultConfig) === null || _d === void 0 ? void 0 : _d.config) === null || _e === void 0 ? void 0 : _e.fallbackValue) || ''
+      },
+      named: ((_f = this.apiSchema) === null || _f === void 0 ? void 0 : _f.configs) && Object.keys((_g = this.apiSchema) === null || _g === void 0 ? void 0 : _g.configs).reduce((acc, curr) => {
+        var _a, _b;
+        acc[curr] = {
+          response: ((_b = (_a = this.apiSchema) === null || _a === void 0 ? void 0 : _a.configs) === null || _b === void 0 ? void 0 : _b[curr].config.fallbackValue) || ''
+        };
+        return acc;
+      }, {})
+    };
+    this._errorsString = '';
+    this._valid = false;
+    this.initializeObservers();
+  }
+  /**
+   * method to initialize all recycled Subjects and initialize Observers on field instance creation or rerender
+   */
+  initializeObservers() {
+    if (!this.valueSubject$ || this.valueSubject$.closed) {
+      this.valueSubject$ = new Subject();
+    }
+    if (!this.errorSubject$ || this.errorSubject$.closed) {
+      this.errorSubject$ = new Subject();
+    }
+    if (!this.visibilitySubject$ || this.visibilitySubject$.closed) {
+      this.visibilitySubject$ = new Subject();
+    }
+    if (!this.apiSubject$ || this.apiSubject$.closed) {
+      this.apiSubject$ = new Subject();
+    }
+    if (!this.propsSubject$ || this.propsSubject$.closed) {
+      this.propsSubject$ = new Subject();
+    }
+    if (!this.fieldStateSubscription$ || this.fieldStateSubscription$.closed) {
+      this.fieldStateSubscription$ = new Subscription();
+    }
+    if (!this.apiEventQueueSubject$ || this.apiEventQueueSubject$.closed) {
+      this.apiEventQueueSubject$ = new Subject();
+    }
+    this.fieldState$ = combineLatest({
+      errors: this.errorSubject$.pipe(startWith([])),
+      visibility: this.visibilitySubject$.pipe(startWith(this._visibility)),
+      apiResponse: this.apiSubject$.pipe(startWith(this._api)),
+      props: this.propsSubject$.pipe(startWith(this._props))
+    });
+    !this.apiEventQueueSubject$.observed && this.apiEventQueueSubject$.pipe(this.debounceDistinct(({
+      event
+    }) => event, 1000)).subscribe(payload => {
+      this.apiRequest(payload);
+    });
+    if (!isNil(this.initialValue)) {
+      this.value = this.initialValue;
+    }
+  }
+  /**
+   * Observable function to emit api events debounced and distinct for each event type,
+   * avoiding previous events being cancelled by new events if they occur inside the debounce time interval
+   *
+   * @param {(event: { event: TEvents }) => TEvents} keyExtractor function that will pass the event key to the groupBy operator
+   * @param {number} debounceTimeMs time to wait for each individual event emmited
+   * @returns
+   */
+  debounceDistinct(keyExtractor, debounceTimeMs) {
+    return source$ => source$.pipe(groupBy(keyExtractor), mergeMap(group$ => group$.pipe(debounceTime(debounceTimeMs), map(() => ({
+      event: group$.key
+    })))));
+  }
+  /**
+   * Retrieves the properties associated with the form field.
+   *
+   * @returns {Record<string, unknown>} - The properties of the form field.
+   */
+  get props() {
+    return this._props;
+  }
+  /**
+   * Sets the properties of the form field and notifies subscribers about the change.
+   *
+   * @param {Record<string, unknown>} props - The new properties to be set.
+   */
+  set props(props) {
+    if (typeof props === 'undefined' || isEqual(props, this.props)) return;
+    this._props = props;
+    this.propsSubject$.next(this.props);
+    this.templateSubject$.next({
+      key: this.name,
+      event: 'ON_PROPS'
+    });
+  }
+  /**
+   * Retrieves the current state value of the form field.
+   *
+   * @returns {unknown} - The current state value of the form field.
+   */
+  get stateValue() {
+    return this._stateValue;
+  }
+  get metadata() {
+    return this._metadata;
+  }
+  /**
+   * Retrieves the concatenated string of errors associated with the form field.
+   *
+   * @returns {string} - The concatenated string of errors.
+   */
+  get errorsString() {
+    return this._errorsString;
+  }
+  /**
+   * Retrieves the current value of the form field.
+   *
+   * @returns {unknown} - The current value of the form field.
+   */
+  get value() {
+    return this._value;
+  }
+  /**
+   * Sets the value of the form field and notifies subscribers about the change.
+   *
+   * @param {unknown} value - The new value to be set.
+   */
+  set value(value) {
+    /*
+      too much unstable, if the valueChangeEvent parses the template event
+      value, might occur unexpected results
+    */
+    let val;
+    if (this.valueChangeEvent) {
+      try {
+        val = this.valueChangeEvent(value, {
+          props: this.props
+        });
+      } catch (e) {
+        val = value;
+      }
+    } else {
+      val = value;
+    }
+    if (typeof val === 'undefined' || val === null) return;
+    if (typeof val === 'object' && '_value' in val && '_metadata' in val) {
+      this._value = this.formatValue(val['_value']);
+      this._stateValue = this.maskValue(this.formatValue(val['_value']));
+      this._metadata = val._metadata;
+    } else {
+      this._value = this.formatValue(val);
+      this._stateValue = this.maskValue(this.formatValue(val));
+      this._metadata = val;
+    }
+    /*
+      update prop value attribute to sync with templating
+      currently doesn't need prop Subject emission since it's synced with value
+      to avoid excessive prop subject emissions on each keystroke
+    */
+    if (this.valuePropName) this._props = Object.assign(Object.assign({}, this.props), {
+      [this.valuePropName]: this.value
+    });
+    this.valueSubject$.next(this._stateValue);
+    this.templateSubject$.next({
+      key: this.name,
+      event: 'ON_VALUE'
+    });
+  }
+  /**
+   * Retrieves the visibility status of the form field.
+   *
+   * @returns {boolean} - The visibility status of the form field.
+   */
+  get visibility() {
+    return this._visibility;
+  }
+  /**
+   * Sets the visibility status of the form field and notifies subscribers about the change.
+   *
+   * @param {boolean} visible - The new visibility status to be set.
+   */
+  set visibility(visible) {
+    if (typeof visible === 'undefined' || visible === this.visibility) return;
+    this._visibility = visible;
+    this.visibilitySubject$.next(this.visibility);
+    this.templateSubject$.next({
+      key: this.name,
+      event: 'ON_VISIBILITY'
+    });
+  }
+  /**
+   * Retrieves the validity status of the form field.
+   *
+   * @returns {boolean} - The validity status of the form field.
+   */
+  get valid() {
+    return this._valid;
+  }
+  /**
+   * Retrieves the error messages associated with the form field.
+   *
+   * @returns {TErrorMessages} - The error messages associated with the form field.
+   */
+  get errors() {
+    return this._errors;
+  }
+  /**
+   * Sets the error messages associated with the form field and notifies subscribers about the change.
+   *
+   * @param {TErrorMessages} errors - The new error messages to be set.
+   */
+  set errors(errors) {
+    if (typeof errors === 'undefined' || isEqual(errors, this.errors)) return;
+    this._errors = errors;
+    this._errorsString = Object.values(this.errors).join(', ');
+    this.errorSubject$.next(Object.values(this.errors));
+    this.templateSubject$.next({
+      key: this.name,
+      event: 'ON_PROPS'
+    });
+  }
+  /**
+   * Retrieves the API response data associated with the form field.
+   *
+   * @returns {TApiResponse} - The API response data associated with the form field.
+   */
+  get api() {
+    return this._api;
+  }
+  /**
+   * Sets the API response data associated with the form field and notifies subscribers about the change.
+   *
+   * @param {TApiResponse} response - The new API response data to be set.
+   */
+  set api(response) {
+    if (typeof response === 'undefined' || isEqual(response, this.api)) return;
+    this._api = response;
+    this.apiSubject$.next(this.api);
+    this.templateSubject$.next({
+      key: this.name,
+      event: 'ON_API'
+    });
+    // this.apiResponseSubject$.next({ key: this.name });
+    this.emitEvents({
+      event: 'ON_API_FIELD_RESPONSE'
+    });
+  }
+  /**
+   * Mounts the form field by initializing necessary subjects and combining their streams.
+   *
+   * @param {object} mountOpts - Adapter mount options.
+   * @param {string} prop.valuePropName - Adapter value property name.
+   * @param {(event: unknown) => unknown} prop.valueChangeEvent - Adapter change event handler function
+   * @param {(value: unknown) => unknown} prop.valueSubscription - Adapter value change function
+   * @param {(payload: Partial<IState>) => unknown} prop.propsSubscription - Adapter prop change function
+   * @param {string} prop.errorMessagePropName - error message property name to set errors onto component
+   * @returns {void}
+   */
+  mountField({
+    valueSubscription,
+    propsSubscription
+  }) {
+    this.initializeObservers();
+    this.subscribeValue(valueSubscription);
+    this.subscribeState(propsSubscription);
+  }
+  /**
+   * Sets the value of the form field and emits associated events.
+   *
+   * @param {unknown} prop.value - The new value to be set.
+   * @param {TEvents} prop.event - The event associated with setting the value.
+   * @returns {void}
+   */
+  emitValue(prop) {
+    this.value = prop.value;
+    this.emitEvents({
+      event: prop.event
+    });
+    this.dataSubject$.next({
+      key: this.name,
+      event: prop.event
+    });
+  }
+  /**
+   * Emits events to trigger field-related actions such as validation, visibility checks, value resets, and API requests.
+   *
+   * @param {TEvents} event - The event type that triggers the field actions.
+   * @returns {void}
+   */
+  emitEvents({
+    event
+  }) {
+    this.setFieldValidity({
+      event
+    });
+    this.validateVisibility({
+      event,
+      key: this.name
+    });
+    this.resetValue({
+      event,
+      key: this.name
+    });
+    this.apiEventQueueSubject$.next({
+      event
+    });
+  }
+  /**
+   * Sets the validity state of the field based on the provided validation rules and triggers error message updates.
+   *
+   * @param {TEvents} event - The event type associated with the field action.
+   * @returns {void}
+   */
+  setFieldValidity({
+    event
+  }) {
+    var _a;
+    if (!this.validations) {
+      this._valid = true;
+      return;
+    }
+    /*
+      @TODO evaluate if _valid flag needs to be updated on all events, this condition saves resources,
+      currently form submition needs to be controlled with form instance submit property function that
+      will evaluate if all fields are valid regardless the events that triggers error messages
+    */
+    if (!this.validations.events.includes(event) && event !== 'ON_FORM_SUBMIT') return;
+    let valid = true;
+    const errors = Object.assign({}, this.errors);
+    const schemaValidations = (_a = this.validations) === null || _a === void 0 ? void 0 : _a.config;
+    schemaValidations && Object.keys(schemaValidations).forEach(validationKey => {
+      var _a, _b;
+      const error = validations[validationKey](this.value, schemaValidations);
+      // setting valid flag
+      valid = !error && valid;
+      // setting error messages
+      if (((_a = this.validations) === null || _a === void 0 ? void 0 : _a.events.includes(event)) || event === 'ON_FORM_SUBMIT') {
+        if (error && ((_b = this.errorMessages) === null || _b === void 0 ? void 0 : _b[validationKey])) {
+          errors[validationKey] = this.errorMessages[validationKey];
+        } else {
+          delete errors[validationKey];
+        }
+      }
+    });
+    this._valid = valid;
+    this.errors = errors;
+    // remove later
+    if (this.errorMessagePropName) this.props = Object.assign(Object.assign({}, this.props), {
+      [this.errorMessagePropName]: this.errorsString
+    });
+  }
+  /**
+   * Formats the field value using the specified formatters, if available.
+   *
+   * @param {unknown} value - The value to be formatted.
+   * @returns {unknown} - The formatted value.
+   */
+  formatValue(value) {
+    if (this.formatters) {
+      return Object.keys(this.formatters).reduce((acc, curr) => {
+        return formatters[curr](acc, this.formatters);
+      }, value);
+    }
+    return value;
+  }
+  /**
+   * Masks the field value using the specified masks, if available.
+   *
+   * @param {unknown} value - The value to be masked.
+   * @returns {unknown} - The masked value.
+   */
+  maskValue(value) {
+    if (this.masks) {
+      return Object.keys(this.masks).reduce((acc, curr) => {
+        return masks[curr](acc, this.masks);
+      }, value);
+    }
+    return value;
+  }
+  checkApiRequestValidations(config) {
+    let valid = true;
+    const preConditions = config.preConditions;
+    preConditions && Object.keys(preConditions).forEach(validationKey => {
+      const error = validations[validationKey](this.value, preConditions);
+      valid = valid && !error;
+    });
+    if (config.blockRequestWhenInvalid) {
+      valid = valid && this.valid;
+    }
+    return valid;
+  }
+  /**
+   * Makes an API request based on the field's API configuration and event type, updating the field's API response data.
+   *
+   * @param {TEvents} event - The event type associated with the API request.
+   * @returns {Promise<void>}
+   */
+  apiRequest({
+    event
+  }) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!((_b = (_a = this.apiSchema) === null || _a === void 0 ? void 0 : _a.defaultConfig) === null || _b === void 0 ? void 0 : _b.events.includes(event)) && !(((_c = this.apiSchema) === null || _c === void 0 ? void 0 : _c.configs) && Object.keys((_d = this.apiSchema) === null || _d === void 0 ? void 0 : _d.configs).some(key => {
+        var _a, _b;
+        return (_b = (_a = this.apiSchema) === null || _a === void 0 ? void 0 : _a.configs) === null || _b === void 0 ? void 0 : _b[key].events.includes(event);
+      }))) return;
+      const responses = {
+        default: Object.assign({}, this.api.default),
+        named: Object.assign({}, this.api.named)
+      };
+      const config = (_e = this.apiSchema.defaultConfig) === null || _e === void 0 ? void 0 : _e.config;
+      if (config && ((_g = (_f = this.apiSchema) === null || _f === void 0 ? void 0 : _f.defaultConfig) === null || _g === void 0 ? void 0 : _g.events.includes(event)) && this.checkApiRequestValidations(config)) {
+        try {
+          const responseData = yield makeRequest(config.method, config.url, config.headers, config.body);
+          const apiResponseData = JSON.parse(String(responseData));
+          const response = config.resultPath ? get(apiResponseData, config.resultPath) : apiResponseData;
+          // this.apiResponseData = { response };
+          responses.default = {
+            response
+          };
+        } catch (e) {
+          responses.default = {
+            response: !isNil(config === null || config === void 0 ? void 0 : config.fallbackValue) ? config.fallbackValue : 'error'
+          };
+        }
+      }
+      if (((_h = this.apiSchema) === null || _h === void 0 ? void 0 : _h.configs) && Object.keys((_j = this.apiSchema) === null || _j === void 0 ? void 0 : _j.configs).some(key => {
+        var _a, _b;
+        return (_b = (_a = this.apiSchema) === null || _a === void 0 ? void 0 : _a.configs) === null || _b === void 0 ? void 0 : _b[key].events.includes(event);
+      })) {
+        if (this.apiSchema.configs) {
+          /*
+            @TODO handle promises with error
+          */
+          const result = yield Promise.all(Object.keys(this.apiSchema.configs).map(configKey => __awaiter(this, void 0, void 0, function* () {
+            return new Promise(res => {
+              var _a, _b, _c, _d;
+              const config = (_b = (_a = this.apiSchema) === null || _a === void 0 ? void 0 : _a.configs) === null || _b === void 0 ? void 0 : _b[configKey].config;
+              if (config && ((_d = (_c = this.apiSchema) === null || _c === void 0 ? void 0 : _c.configs) === null || _d === void 0 ? void 0 : _d[configKey].events.includes(event)) && this.checkApiRequestValidations(config)) {
+                try {
+                  makeRequest(config.method, config.url, config.headers, config.body).then(responseData => {
+                    const apiResponseData = JSON.parse(String(responseData));
+                    const response = get(apiResponseData, config.resultPath || '');
+                    res({
+                      name: configKey,
+                      result: {
+                        response
+                      }
+                    });
+                    // responses.named![configKey] = { response };
+                  });
+                } catch (e) {
+                  res({
+                    name: configKey,
+                    result: {
+                      response: !isNil(config.fallbackValue) ? config.fallbackValue : 'error'
+                    }
+                  });
+                }
+              }
+            });
+          })));
+          result.forEach(({
+            name,
+            result
+          }) => {
+            if (responses.named) responses.named[name] = result;
+          });
+        }
+      }
+      this.api = responses;
+    });
+  }
+  /**
+   * Unsubscribes from all subject subscriptions associated with the field, cleaning up resources.
+   *
+   * @returns {void}
+   */
+  destroyField() {
+    this.valueSubject$.unsubscribe();
+    this.visibilitySubject$.unsubscribe();
+    this.fieldStateSubscription$.unsubscribe();
+    this.propsSubject$.unsubscribe();
+    this.errorSubject$.unsubscribe();
+    this.apiSubject$.unsubscribe();
+    this.apiEventQueueSubject$.unsubscribe();
+  }
+  /**
+   * Subscribes to changes in the field state and executes the provided callback function.
+   *
+   * @param {Function} callback - The callback function to be executed when the field state changes.
+   * @returns {void}
+   */
+  subscribeState(callback) {
+    this.fieldStateSubscription$ = this.fieldState$.pipe(debounceTime(100)).subscribe({
+      next: callback
+    });
+  }
+  /**
+   * Subscribes to changes in the field value and executes the provided callback function.
+   *
+   * @param {Function} callback - The callback function to be executed when the field value changes.
+   * @returns {void}
+   */
+  subscribeValue(callback) {
+    this.valueSubject$.subscribe({
+      next: callback
+    });
+  }
+}
+
+const IVARPROPNAME = 'iVars';
+/**
+ * Represents the core logic for managing a form, including field management, validation, and submission.
+ */
+class FormCore {
+  /**
+   * Creates an instance of FormCore.
+   *
+   * @param {TFormEntry & Omit<IFormSchema, 'components'>} entry - Configuration options for the form.
+   * @param {IFormSchema} entry.schema - The schema definition for the form.
+   * @param {Record<string, unknown> | IFormSchema.initialValues} [entry.initialValues] - Initial values for the form fields.
+   * @param {string} [entry.action] - The action attribute of the form.
+   * @param {string} [entry.method] - The method attribute of the form.
+   * @param {IFormSchema.iVars} [entry.iVars] - The internal variables of the form.
+   * @param {(data: TFormValues) => void} [entry.onSubmit] - A callback function to handle form submission.
+   * @param {((payload: {field: string;data: TFormValues;}) => void) | undefined} [entry.onData] - A callback function to handle data emission.
+   */
+  constructor(entry) {
+    var _a, _b, _c, _d;
+    this.schema = entry.schema;
+    this.fields = new Map();
+    this.initialValues = entry.initialValues || ((_a = entry.schema) === null || _a === void 0 ? void 0 : _a.initialValues);
+    this.action = entry.action || ((_b = entry.schema) === null || _b === void 0 ? void 0 : _b.action);
+    this.method = entry.method || ((_c = entry.schema) === null || _c === void 0 ? void 0 : _c.method);
+    this._iVars = entry.iVars || ((_d = entry.schema) === null || _d === void 0 ? void 0 : _d.iVars) || {};
+    this.onSubmit = entry.onSubmit;
+    this.mappers = entry.mappers;
+    this.schema && FormCore.checkIndexes(this.schema.components);
+    this.templateSubject$ = new Subject();
+    this.submitSubject$ = new Subject();
+    this.apiResponseSubject$ = new Subject();
+    this.dataSubject$ = new Subject();
+    this.dataCallbackSubscription$ = new Subscription();
+    this.subscribedTemplates = [];
+    this.schema && this.serializeStructure(this.schema.components);
+    this.schema && this.subscribeTemplates();
+    this.templateSubject$.subscribe(this.refreshTemplates.bind(this));
+    this.templateSubject$.next({
+      key: IVARPROPNAME,
+      event: 'ON_IVARS'
+    });
+    this.apiResponseSubject$.subscribe(this.refreshApi.bind(this));
+    entry.onData && this.subscribeData(entry.onData);
+    /*
+      mount events needs to occur on form level, only when all the fields are instantiated
+      is it possible to apply all the side effects that occur globally, same effect occur
+      onto refreshFields
+    */
+    this.fields.forEach((field, key) => {
+      field.emitEvents({
+        event: 'ON_FIELD_MOUNT'
+      });
+      this.refreshTemplates({
+        key,
+        event: 'ON_FIELDS'
+      });
+    });
+  }
+  /**
+   * Retrieves the internal variables (iVars) of the form.
+   *
+   * @returns {Record<string, unknown>} - The internal variables of the form.
+   */
+  get iVars() {
+    return this._iVars;
+  }
+  /**
+   * Sets the internal variables (iVars) of the form and notifies subscribers about the change.
+   *
+   * @param {Record<string, unknown>} payload - The new internal variables to be set.
+   */
+  set iVars(payload) {
+    this._iVars = payload;
+    this.templateSubject$.next({
+      key: IVARPROPNAME,
+      event: 'ON_IVARS'
+    });
+  }
+  /**
+   * Checks if the form is valid by validating all form fields.
+   *
+   * @returns {boolean} True if the form is valid; otherwise, false.
+   */
+  get isValid() {
+    for (const [, field] of this.fields) {
+      if (!field.valid) return false;
+    }
+    return true;
+  }
+  /**
+   * Subscribes to templates for dynamic updates.
+   */
+  subscribeTemplates() {
+    /*
+      @TODO fix removal of templates of removed fields, they are kept
+      tried: this.subscribedTemplates = [] and only stores the last one..
+    */
+    this.fields.forEach(({
+      component,
+      props,
+      name,
+      validations,
+      visibilityConditions,
+      resetValues,
+      errorMessages,
+      apiSchema,
+      metadata
+    }, key) => {
+      const template = {
+        component,
+        props,
+        name,
+        validations,
+        visibilityConditions,
+        resetValues,
+        errorMessages,
+        apiSchema,
+        metadata
+      };
+      traverseObject(template, key).forEach(element => this.subscribedTemplates.push(element));
+    });
+    // console.log(subscribedProps);
+  }
+  /**
+   *
+   * @param {(payload: { field: string; data: TFormValues }) => void} callback callback function to call on data
+   */
+  subscribeData(callback) {
+    this.dataCallbackSubscription$ = this.dataSubject$.pipe(debounceTime(100), map(({
+      key
+    }) => ({
+      field: key,
+      data: this.getFormValues()
+    }))).subscribe({
+      next: callback
+    });
+  }
+  /**
+   * Gets the value of a property from a field.
+   *
+   * @param {object} options - Options for getting the value.
+   * @param {string} options.key - The key of the field.
+   * @param {string} options.property - The property to retrieve.
+   * @param {string[]} options.path - The path to the property if it's nested.
+   * @returns {unknown | undefined} The value of the property, or undefined if the field doesn't exist.
+   */
+  getValue({
+    key,
+    property,
+    path
+  }) {
+    if (key === IVARPROPNAME) {
+      const value = get(this.iVars, [property, ...path]);
+      return value;
+    }
+    if (!this.fields.has(key)) return console.warn(`failed to get value from ${key}`);
+    return path.length > 0 ? get(this.fields.get(key)[property], path) : this.fields.get(key)[property];
+  }
+  /**
+   * Sets the value of a property in a field.
+   *
+   * @param {object} options - Options for setting the value.
+   * @param {string} options.key - The key of the field.
+   * @param {string} options.property - The property to set.
+   * @param {string[]} options.path - The path to the property if it's nested.
+   * @param {unknown} options.originKey - field that called templating
+   * @param {unknown} options.value - The value to set.
+   * @param {TMutationEvents} options.event - Internal Event for template Handling.
+   */
+  setValue({
+    key,
+    property,
+    path,
+    originKey,
+    value
+  }) {
+    const field = this.fields.get(key);
+    if (!field) {
+      console.warn(`failed to update field ${key}`);
+      return;
+    }
+    if (path.length > 0) {
+      /*
+        property value is only allowed to be templated if the value isn't
+        changed by itself, else a black hole opens
+        previously using event !== 'ON_VALUE' on the condition
+        now using key !== originKey, check if any recursion error occurs
+      **/
+      if (property === 'props' && path[0] === field.valuePropName && key !== originKey) {
+        // field.value = value;
+        field.emitValue({
+          event: 'ON_FIELD_CHANGE',
+          value
+        });
+        return;
+      }
+      const fieldProp = field[property];
+      let propState;
+      if (Array.isArray(fieldProp)) {
+        propState = [...fieldProp];
+      } else if (typeof fieldProp === 'object' && !isNil(fieldProp)) {
+        propState = Object.assign({}, fieldProp);
+      } else {
+        console.warn(`invalid template property, skipping evaluation of ${field.name} with ${fieldProp}`);
+        return;
+      }
+      set(propState, path, value);
+      field[property] = propState;
+      return;
+    }
+    field[property] = value;
+    return;
+  }
+  /**
+   * Extracts parameters from an expression.
+   *
+   * @param {string} expression - The expression containing parameters.
+   * @returns {string[]} An array of extracted parameters.
+   */
+  extractParams(expression) {
+    const regex = /\${(.*?)}/g;
+    const extractedValues = [];
+    let match;
+    while (!isNil(match = regex.exec(expression))) {
+      extractedValues.push(match[1]);
+    }
+    const operatorRegex = /\s*(\|\||&&|!)\s*/g;
+    const splittedString = extractedValues.map(el => el.split(operatorRegex));
+    const result = splittedString.map(splittedStringVal => {
+      // console.log(splittedStringVal)
+      return splittedStringVal.filter(Boolean).reduce((acc, curr) => {
+        if (curr.match(/^\|\||&&|!$/)) {
+          return `${acc}${curr}`;
+        }
+        let value;
+        // check if element is in dot notation to get from field instances
+        const element = curr.split('.');
+        const currElementContent = element.length > 1 ? this.getValue({
+          key: element[0],
+          property: element[1],
+          path: element.slice(2)
+        }) : element;
+        let currValue;
+        // if any parsable content was passed to the conditions, parse them
+        // required to be able to apply conditions
+        try {
+          currValue = JSON.parse(currElementContent);
+        } catch (e) {
+          currValue = currElementContent;
+        }
+        switch (typeof currValue) {
+          case 'string':
+            value = `\`${currValue}\``;
+            break;
+          case 'boolean':
+          case 'undefined':
+          case 'number':
+            value = currValue;
+            break;
+          case 'object':
+            if (currValue === null) {
+              value = null;
+            }
+            value = JSON.stringify(currValue);
+            break;
+          default:
+            value = currValue;
+        }
+        return `${acc}${value}`;
+      }, '');
+    });
+    return result.map(el => {
+      try {
+        // console.log(el);
+        return new Function(`return ${el}`)();
+      } catch (e) {
+        console.log(e);
+        return 'lil error here.. :(';
+      }
+    });
+  }
+  /**
+   * Replaces expressions marked by ${...} in the expression string with the provided values.
+   *
+   * @param {string} expression - The expression string containing the marked expressions.
+   * @param {string[]} values - The values to be inserted into the marked expressions.
+   * @returns {string} The expression string with the replacements made.
+   */
+  replaceExpression(expression, values) {
+    const regex = /\${(.*?)}/g;
+    return expression.replace(regex, () => values.shift() || '');
+  }
+  /**
+   * Checks if an expression string contains string concatenation within a marked expression.
+   *
+   * @param {string} expression - The expression string to be checked.
+   * @returns {boolean} True if the expression contains string concatenation, otherwise false.
+   */
+  hasStringConcatenation(expression) {
+    const regex = /^\${[^${}]*}$/;
+    return !regex.test(expression);
+  }
+  /**
+   * Refreshes templates with updated values.
+   *
+   * @param {object} options - Options for refreshing templates.
+   * @param {string} options.key - The key of the field triggering the update.
+   * @param {TMutationEvents} options.event - Internal event descriptor to handle templating.
+   */
+  refreshTemplates({
+    key,
+    event
+  }) {
+    this.subscribedTemplates.forEach(({
+      destinationKey,
+      destinationPath,
+      destinationProperty,
+      originExpression,
+      originFieldKeys
+    }) => {
+      if (originFieldKeys.includes(key)) {
+        const originExpressions = this.extractParams(originExpression);
+        let originValue;
+        if (this.hasStringConcatenation(originExpression)) {
+          originValue = this.replaceExpression(originExpression, [...originExpressions]);
+        } else {
+          originValue = originExpressions === null || originExpressions === void 0 ? void 0 : originExpressions[0];
+        }
+        const destinationValue = this.getValue({
+          key: destinationKey,
+          property: destinationProperty,
+          path: destinationPath
+        });
+        if (!isEqual(destinationValue, originValue)) {
+          this.setValue({
+            key: destinationKey,
+            property: destinationProperty,
+            path: destinationPath,
+            originKey: key,
+            value: originValue,
+            event
+          });
+        }
+      }
+    });
+  }
+  /**
+   * Refreshes api observed fields.
+   *
+   * @param {object} options - Options for refreshing api.
+   * @param {string} options.key - The key of the field triggering the update.
+   */
+  refreshApi({
+    key
+  }) {
+    /*
+      global api notifications needs to have field dependency array
+      in order to be reliable, disabled for now
+    */
+    return key;
+    // const emmittedFields: string[] = [];
+    // this.subscribedTemplates.forEach((template) => {
+    //   if (
+    //     template.originFieldKeys.includes(key) &&
+    //     template.originPropertyKeys.includes('api') &&
+    //     !emmittedFields.includes(template.destinationKey)
+    //   ) {
+    //     emmittedFields.push(template.destinationKey);
+    //     this.fields
+    //       .get(template.destinationKey)
+    //       ?.emitEvents({ event: 'ON_API_RESPONSE' });
+    //   }
+    // });
+  }
+  /**
+   * Validates visibility conditions for a given event and updates field visibility accordingly.
+   *
+   * @param {object} options - Options for validating visibility.
+   * @param {TEvents} options.event - The event triggering visibility validation.
+   * @param {string} options.key - The key of the field.
+   */
+  validateVisibility({
+    event,
+    key
+  }) {
+    const field = this.fields.get(key);
+    const structVisibility = field === null || field === void 0 ? void 0 : field.visibilityConditions;
+    if (!structVisibility || !(structVisibility === null || structVisibility === void 0 ? void 0 : structVisibility.some(config => config.events.includes(event)))) return;
+    structVisibility.forEach(structElement => {
+      if (!structElement.events.includes(event)) return;
+      Object.keys(structElement.validations).forEach(validationKey => {
+        const error = validations[validationKey](field.value, structElement.validations);
+        if (Array.isArray(structElement.fields)) {
+          structElement.fields.forEach(fieldKey => {
+            if (!this.fields.has(fieldKey)) console.warn(`failed to update visibility onto field ${fieldKey}`);else this.fields.get(fieldKey).visibility = error;
+          });
+        } else if (structElement.fields) {
+          if (!this.fields.has(structElement.fields)) console.warn(`failed to update visibility onto field ${structElement.fields}`);else this.fields.get(structElement.fields).visibility = error;
+        }
+      });
+    });
+  }
+  /**
+   * Resets field values based on reset conditions defined in the schema.
+   *
+   * @param {object} options - Options for resetting field values.
+   * @param {TEvents} options.event - The event triggering the reset.
+   * @param {string} options.key - The key of the field.
+   */
+  resetValue({
+    event,
+    key
+  }) {
+    const field = this.fields.get(key);
+    const structResetValue = field === null || field === void 0 ? void 0 : field.resetValues;
+    if (!structResetValue || !(structResetValue === null || structResetValue === void 0 ? void 0 : structResetValue.some(config => config.events.includes(event)))) return;
+    structResetValue.forEach(structElement => {
+      if (!structElement.events.includes(event)) return;
+      Object.keys(structElement.validations).forEach(validationKey => {
+        const error = validations[validationKey](field.value, structElement.validations);
+        if (!error) {
+          if (Array.isArray(structElement.fields)) {
+            structElement.fields.forEach((fieldKey, index) => {
+              const resettledValue = Array.isArray(structElement.resettledValue) ? structElement.resettledValue[index] : structElement.resettledValue;
+              if (!this.fields.has(fieldKey)) console.warn(`failed to reset value onto field ${fieldKey}`);else this.fields.get(fieldKey).emitValue({
+                value: resettledValue,
+                event: 'ON_FIELD_CHANGE'
+              });
+            });
+          } else if (structElement.fields) {
+            if (!this.fields.has(structElement.fields)) console.warn(`failed to reset value onto field ${structElement.fields}`);else this.fields.get(structElement.fields).emitValue({
+              value: structElement.resettledValue,
+              event: 'ON_FIELD_CHANGE'
+            });
+          }
+        }
+      });
+    });
+  }
+  /**
+   * Serializes the schema structure to create form fields.
+   *
+   * @param {IComponentSchema[]} [struct] - The schema structure to serialize.
+   * @param {string} [path] - The path of the parent component.
+   */
+  serializeStructure(struct, path) {
+    if (!struct) return;
+    struct.forEach(structElement => {
+      var _a, _b;
+      const currField = this.fields.get(structElement.name);
+      if (!currField) {
+        const mapper = this.mappers.find(mapEl => mapEl.componentName === structElement.component);
+        if (!mapper) throw new Error(`mapper not found for ${structElement.component}, add it to the mappers configuration`);
+        this.fields.set(structElement.name, new FormField({
+          schemaComponent: structElement,
+          mapper,
+          path,
+          children: structElement.children ? structElement.children.map(el => el.name) : [],
+          validateVisibility: this.validateVisibility.bind(this),
+          resetValue: this.resetValue.bind(this),
+          initialValue: (_a = this.initialValues) === null || _a === void 0 ? void 0 : _a[structElement.name],
+          templateSubject$: this.templateSubject$,
+          apiResponseSubject$: this.apiResponseSubject$,
+          dataSubject$: this.dataSubject$
+        }));
+      } else {
+        currField.children = ((_b = structElement === null || structElement === void 0 ? void 0 : structElement.children) === null || _b === void 0 ? void 0 : _b.map(el => el.name)) || (currField === null || currField === void 0 ? void 0 : currField.children) || [];
+        currField.path = path;
+        currField.templateSubject$ = this.templateSubject$;
+      }
+      if (structElement.children) {
+        return this.serializeStructure(structElement.children, `${path ? `${path}.` : ``}${structElement.name}`);
+      }
+    });
+  }
+  /**
+   * Refreshes form fields based on changes in the schema structure.
+   *
+   * @param {IComponentSchema[]} struct - The updated schema structure.
+   */
+  refreshFields(struct) {
+    const prevKeys = Array.from(this.fields.keys());
+    this.serializeStructure(struct);
+    const keys = FormCore.checkIndexes(struct);
+    this.fields.forEach((_, key) => {
+      var _a;
+      if (!keys.includes(key)) {
+        (_a = this.fields.get(key)) === null || _a === void 0 ? void 0 : _a.destroyField();
+        this.fields.delete(key);
+      }
+    });
+    this.subscribeTemplates();
+    this.fields.forEach((_, key) => {
+      var _a;
+      if (!prevKeys.includes(key)) {
+        (_a = this.fields.get(key)) === null || _a === void 0 ? void 0 : _a.emitEvents({
+          event: 'ON_FIELD_MOUNT'
+        });
+      }
+    });
+    this.subscribedTemplates.forEach(el => {
+      el.originFieldKeys.forEach(field => {
+        this.templateSubject$.next({
+          key: field,
+          event: 'ON_FIELDS'
+        });
+      });
+    });
+  }
+  /**
+   * Gets a form field by its key.
+   *
+   * @param {object} options - Options for getting the form field.
+   * @param {string} options.key - The key of the form field.
+   * @returns {IFormField | undefined} The form field, or undefined if not found.
+   */
+  getField({
+    key
+  }) {
+    return this.fields.get(key);
+  }
+  /**
+   * Prints the current values of all form fields.
+   */
+  printValues() {
+    const values = {};
+    this.fields.forEach((val, key) => {
+      if (val.value) {
+        values[key] = val.value;
+      }
+    });
+    console.log(values);
+  }
+  /**
+   * Gets the current values of all form fields.
+   *
+   * @returns {TFormValues} The current form values.
+   */
+  getFormValues() {
+    const values = {};
+    const erroredFields = [];
+    this.fields.forEach((val, key) => {
+      if (val.value) {
+        values[key] = val.value;
+      }
+      if (!val.valid) {
+        erroredFields.push(key);
+      }
+    });
+    return {
+      values,
+      erroredFields,
+      isValid: this.isValid
+    };
+  }
+  /**
+   * Submits the form by triggering form field events and invoking the onSubmit callback.
+   */
+  submit() {
+    this.fields.forEach(field => {
+      field.emitEvents({
+        event: 'ON_FORM_SUBMIT'
+      });
+    });
+    if (!this.isValid) return;
+    const values = this.getFormValues();
+    this.submitSubject$.next(values);
+    this.onSubmit && this.onSubmit(values);
+  }
+  destroy() {
+    this.submitSubject$.unsubscribe();
+    this.templateSubject$.unsubscribe();
+    this.apiResponseSubject$.unsubscribe();
+    this.dataSubject$.unsubscribe();
+  }
+}
+/**
+ * Validates and collects the names of form fields in the provided schema structure.
+ *
+ * @param {IComponentSchema[]} [struct] - The schema structure of the form components.
+ * @param {string[]} [indexes=[]] - An array to collect the names of the form fields.
+ * @returns {string[]} - An array of form field names.
+ * @throws {Error} - Throws an error if a field name matches the reserved name defined by `IVARPROPNAME`.
+ * @private
+ */
+FormCore.checkIndexes = (struct, indexes = []) => {
+  if (!struct) return indexes;
+  for (let i = 0; i < struct.length; i++) {
+    const structElement = struct[i];
+    if (structElement.name === IVARPROPNAME) {
+      throw new Error(`reserved ${IVARPROPNAME} name for field names`);
+    }
+    indexes.push(structElement.name);
+    if (structElement.children) {
+      return FormCore.checkIndexes(structElement.children, indexes);
+    }
+  }
+  return indexes;
+};
+
+/**
+ * Represents a group that manages multiple forms.
+ */
+class FormGroup {
+  /**
+   * Creates an instance of FormGroup.
+   */
+  constructor() {
+    this.forms = new Map();
+  }
+  /**
+   * Adds a form instance to the form group.
+   *
+   * @param {object} options - Options for adding a form.
+   * @param {string} options.key - The key associated with the form instance.
+   * @param {TFormCore} options.formInstance - The instance of the form to add.
+   */
+  addForm({
+    key,
+    formInstance
+  }) {
+    this.checkIndexes({
+      key
+    });
+    this.forms.set(key, formInstance);
+  }
+  /**
+   * Retrieves a form instance from the form group.
+   *
+   * @param {object} options - Options for retrieving a form.
+   * @param {string} options.key - The key associated with the form instance.
+   * @returns {TFormCore | undefined} The instance of the form, if found; otherwise, undefined.
+   */
+  getForm({
+    key
+  }) {
+    return this.forms.get(key);
+  }
+  /**
+   * Removes a form instance from the form group.
+   *
+   * @param {object} options - Options for removing a form.
+   * @param {string} options.key - The key associated with the form instance to remove.
+   */
+  removeForm({
+    key
+  }) {
+    var _a;
+    //@TODO logic to unsubscribe all form related
+    (_a = this.forms.get(key)) === null || _a === void 0 ? void 0 : _a.destroy();
+    this.forms.delete(key);
+  }
+  /**
+   * Checks if the specified key already exists in the form group.
+   *
+   * @param {object} options - Options for checking the key.
+   * @param {string} options.key - The key to check.
+   * @throws {Error} Throws an error if the key already exists in the form group.
+   */
+  checkIndexes({
+    key
+  }) {
+    if (this.forms.has(key)) {
+      throw new Error(`duplicate index ${key} on form group`);
+    }
+  }
+  /**
+   * Prints the form group instance to the console.
+   */
+  printFormGroupInstance() {
+    console.log(this.forms);
+  }
+  /**
+   * Prototype submit function to multiple forms
+   * @param {string[]} indexes form indexes to be submitted
+   * @returns
+   */
+  submitMultipleFormsByIndex(indexes) {
+    let isValid = true;
+    let values = {};
+    let erroredFields = [];
+    indexes.forEach(index => {
+      var _a;
+      const res = (_a = this.forms.get(index)) === null || _a === void 0 ? void 0 : _a.getFormValues();
+      isValid = isValid && ((res === null || res === void 0 ? void 0 : res.isValid) || false);
+      values = Object.assign(Object.assign({}, values), (res === null || res === void 0 ? void 0 : res.values) || {});
+      erroredFields = [...erroredFields, ...((res === null || res === void 0 ? void 0 : res.erroredFields) || [])];
+    });
+    return {
+      erroredFields,
+      isValid,
+      values
+    };
+  }
+}
+
+export { FormCore, FormField, FormGroup, TMutationEnum };