@bolttech/form-engine 3.0.0-beta.11 → 3.0.0-beta.3

package/src/core/index.d.js

@@ -0,0 +1,2126 @@
+// libs/form-engine-core/src/types/event.ts
+var TMutationEnum = /* @__PURE__ */ ((TMutationEnum2) => {
+  TMutationEnum2["ON_VALUE"] = "value";
+  TMutationEnum2["ON_PROPS"] = "props";
+  TMutationEnum2["ON_VISIBILITY"] = "visibility";
+  TMutationEnum2["ON_API"] = "api";
+  TMutationEnum2["ON_IVARS"] = "iVars";
+  TMutationEnum2["ON_FIELDS"] = "fields";
+  return TMutationEnum2;
+})(TMutationEnum || {});
+
+// libs/form-engine-core/src/managers/field.ts
+import {
+  combineLatest,
+  debounceTime,
+  map,
+  mergeMap,
+  startWith,
+  Subject,
+  Subscription,
+  groupBy
+} from "rxjs";
+
+// libs/form-engine-core/src/helpers/helpers.ts
+function makeRequest(method, url2, headers, body) {
+  return new Promise(function(resolve, reject) {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url2, 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);
+  });
+}
+function extractFieldKeys(expression) {
+  const regex3 = /\${(.*?)}/g;
+  const extractedValues = [];
+  let match;
+  while ((match = regex3.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]))
+    )
+  };
+}
+function traverseObject(obj, path) {
+  const result = [];
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      const value2 = obj[key];
+      if (Array.isArray(value2)) {
+        value2.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 extractedOriginPath = `${path ? `${path}.` : ``}${key}`.split(".");
+              result.push({
+                originExpression: item,
+                // originFieldKeys: extractFieldKeys(item),
+                ...extractFieldKeys(item),
+                destinationKey: extractedOriginPath[0],
+                destinationProperty: extractedOriginPath[1],
+                destinationPath: extractedOriginPath.slice(2)
+              });
+            }
+          }
+        });
+      } else if (typeof value2 === "object") {
+        result.push(
+          ...traverseObject(value2, `${path ? `${path}.` : ``}${key}`)
+        );
+      } else if (typeof value2 === "string") {
+        if (value2.includes("$")) {
+          const destinationPath = `${path ? `${path}.` : ``}${key}`.split(".");
+          result.push({
+            originExpression: value2,
+            ...extractFieldKeys(value2),
+            destinationKey: destinationPath[0],
+            destinationProperty: destinationPath[1],
+            destinationPath: destinationPath.slice(2)
+          });
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// libs/form-engine-core/src/formatters/splitter.ts
+var splitter = (value2, formatters2) => {
+  if (!value2 || !formatters2.splitter || typeof value2 !== "string")
+    return value2;
+  formatters2.splitter.sort((a, b) => a.position - b.position);
+  let result = value2;
+  let offset = 0;
+  for (const splitter2 of formatters2.splitter) {
+    const { position, value: value3 } = splitter2;
+    const adjustedPosition = position + offset;
+    if (adjustedPosition >= 0 && adjustedPosition <= result.length) {
+      result = result.slice(0, adjustedPosition) + value3 + result.slice(adjustedPosition);
+      offset += value3.length;
+    }
+  }
+  return result;
+};
+
+// libs/form-engine-core/src/formatters/string.ts
+var capitalize = (value2) => String(value2).charAt(0).toUpperCase() + String(value2).slice(1);
+var uppercase = (value2) => String(value2).toUpperCase();
+var onlyFloatNumber = (value2, formatters2) => {
+  const { onlyFloatNumber: onlyFloatNumber2 } = formatters2;
+  if (!onlyFloatNumber2 || typeof value2 !== "string" || !value2)
+    return value2;
+  const { precision = 2, decimal = "." } = onlyFloatNumber2;
+  if (!value2.includes(decimal)) {
+    return value2;
+  }
+  const replacedValue = value2.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);
+};
+var trim = (value2, formatters2) => {
+  if (!value2 || formatters2?.trim)
+    return value2;
+  return String(value2).trim();
+};
+var maxLength = (value2, formatters2) => {
+  if (!value2 || !formatters2.maxLength)
+    return value2;
+  const input = String(value2);
+  if (input.length > formatters2.maxLength) {
+    return input.substring(0, formatters2.maxLength);
+  }
+  return value2;
+};
+
+// libs/form-engine-core/src/formatters/regex.ts
+var onlyNumbers = (value2) => String(value2).replace(/(\D)+/gim, "");
+var onlyLetters = (value2) => String(value2).replace(/[^\p{L}\s]/gu, "");
+var regex = (value2, formatters2) => {
+  if (!formatters2.regex)
+    return value2;
+  return String(value2).replace(new RegExp(formatters2.regex, "g"), "");
+};
+
+// libs/form-engine-core/src/helpers/creditCard.ts
+import creditCardType from "credit-card-type";
+var getTypeCard = (value2, availableOptions) => {
+  const rawValue = removeGaps(value2?.toString());
+  const types = creditCardType(rawValue);
+  const selected = availableOptions?.length ? types?.filter(
+    ({ type: id1 }) => availableOptions.some((id2) => id2 === id1)
+  )[0] : types[0];
+  return [selected, rawValue];
+};
+var removeGaps = (value2) => value2?.replace(/ /g, "");
+var addGaps = (value2, gaps = []) => {
+  const [regexString, replaceString] = gaps.reduce(
+    ([regexString2, replaceString2], offset, i) => {
+      const lastOffset = gaps[i - 1] || 0;
+      const digitNumber = offset - lastOffset;
+      return [
+        `${regexString2}([0-9]{0,${digitNumber}})`,
+        `${replaceString2}$${i + 1} `
+      ];
+    },
+    ["", ""]
+  );
+  return value2.replace(new RegExp(regexString), replaceString).trim();
+};
+var formatValue = (value2, type) => {
+  const DEFAULT_LENGTH = 19;
+  return type ? addGaps(value2.slice(0, type?.lengths[0]), type.gaps) : value2?.slice(0, DEFAULT_LENGTH);
+};
+var formatDateCard = (value2, end = 4, prefix = "/") => {
+  const fixedValue = value2.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;
+};
+
+// libs/form-engine-core/src/formatters/creditCard.ts
+var gapsCreditCard = (value2, formatters2) => {
+  if (!formatters2.gapsCreditCard)
+    return value2;
+  const [type, rawValue] = getTypeCard(
+    value2,
+    formatters2?.gapsCreditCard
+  );
+  return formatValue(rawValue, type);
+};
+
+// libs/form-engine-core/src/formatters/custom.ts
+var callback = (value2, formatters2) => {
+  if (!formatters2?.callback)
+    return value2;
+  return formatters2.callback(value2);
+};
+
+// libs/form-engine-core/src/formatters/handler.ts
+var formatters = {
+  capitalize,
+  uppercase,
+  onlyNumbers,
+  onlyLetters,
+  regex,
+  splitter,
+  maxLength,
+  onlyFloatNumber,
+  trim,
+  gapsCreditCard,
+  callback,
+  // todo: to be removed
+  dotEvery3chars: (value2) => {
+    const result = String(value2).replace(/\./g, "").replace(/(.{3})/g, "$1.");
+    return result.endsWith(".") ? result.slice(0, -1) : result;
+  }
+};
+
+// libs/form-engine-core/src/masks/generic.ts
+var generic_default = (value2, masks2) => {
+  if (!masks2?.generic)
+    return value2;
+  let masked = value2;
+  masks2.generic.forEach((item) => {
+    const { to = masked.length, mask } = item;
+    let { from } = item;
+    if (to > value2.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;
+};
+
+// libs/form-engine-core/src/masks/string.ts
+import { isNumber } from "lodash";
+import { getCurrencySymbol } from "@gaignoux/currency";
+var replaceAll = (value2, masks2) => {
+  let targetReplaceMask = masks2.replaceAll;
+  if (!targetReplaceMask)
+    return value2;
+  if (typeof targetReplaceMask === "number") {
+    targetReplaceMask = targetReplaceMask?.toString();
+  }
+  return new Array(String(value2).length + 1).join(targetReplaceMask);
+};
+var currency = (value2, masks2) => {
+  if (!masks2?.currency)
+    return value2;
+  const {
+    align = "right",
+    decimal = ".",
+    precision = 2,
+    prefix = "BBD",
+    thousands = ","
+  } = masks2.currency;
+  const rawValue = isNumber(value2) ? Number(value2).toFixed(precision) : value2;
+  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(value2).endsWith(" ")) {
+    convertedValue = convertedValue.slice(0, -1);
+  }
+  console.log("After", { value: value2, 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}`;
+};
+var custom = (value2, masks2) => {
+  if (!masks2.custom || !value2)
+    return value2;
+  let mask = "";
+  let index = 0;
+  for (let i = 0; i < masks2.custom.length; i++) {
+    if (masks2.custom[i] === "#") {
+      if (index < value2.length) {
+        mask += value2[index];
+        index++;
+      } else {
+        break;
+      }
+    } else {
+      mask += masks2.custom[i];
+    }
+  }
+  return mask;
+};
+
+// libs/form-engine-core/src/masks/creditCard.ts
+var secureCreditCard = (value2) => {
+  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_default(value2, { generic: maskValue });
+};
+var card = (value2) => {
+  return value2.replace(/[^\dA-Z]/g, "").replace(/(.{4})/g, "$1 ").trim();
+};
+var cardDate = (value2) => formatDateCard(value2);
+var fein = (value2) => formatDateCard(value2, 9, "-");
+
+// libs/form-engine-core/src/masks/handler.ts
+var masks = {
+  currency,
+  custom,
+  callback: (value2, masks2) => masks2?.callback && masks2.callback(value2),
+  generic: generic_default,
+  secureCreditCard,
+  card,
+  cardDate,
+  fein,
+  replaceAll
+};
+
+// libs/form-engine-core/src/validations/length.ts
+var length_default = (value2, validations3) => {
+  if (!validations3.length || !value2)
+    return false;
+  let targetValue = value2;
+  if (typeof targetValue !== "string") {
+    targetValue = value2?.toString() || targetValue;
+  }
+  const condition = {
+    equal: targetValue.length !== validations3.length.target,
+    notEqual: targetValue.length === validations3.length.target,
+    less: targetValue.length >= validations3.length.target,
+    lessOrEqual: targetValue.length > validations3.length.target,
+    greater: targetValue.length <= validations3.length.target,
+    greaterOrEqual: targetValue.length < validations3.length.target
+  };
+  return condition[validations3.length.rule];
+};
+
+// libs/form-engine-core/src/validations/document.ts
+var NIF_ES = (value2) => {
+  if (value2.length !== 9)
+    return true;
+  if (!/^\d{8}$/.test(value2.slice(0, 8))) {
+    return true;
+  }
+  const validLetters = "TRWAGMYFPDXBNJZSQVHLCKE";
+  const numberPart = parseInt(value2.slice(0, 8), 10);
+  const expectedLetter = validLetters[numberPart % 23];
+  return !(value2[8].toUpperCase() === expectedLetter);
+};
+var NIF_PT = (value2) => {
+  const regex3 = /^\d{9}$/;
+  if (!regex3.test(value2))
+    return false;
+  const checkDigit = parseInt(value2[8], 10);
+  const sum = Array.from(value2.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;
+};
+var NIF_IT = (value2) => {
+  const regex3 = /^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$/;
+  return regex3.test(value2);
+};
+var NIF_DE = (nif) => {
+  const regex3 = /^\d{11}$/;
+  return regex3.test(nif);
+};
+var NIF_FR = (nif) => {
+  const regex3 = /^\d{2} \d{3} \d{3} \d{3} \d{3}$/;
+  return regex3.test(nif);
+};
+var NIF_UK = (value2) => {
+  const regex3 = /^GB\d{9}|\d{12}|\d{3}[A-Z]{5}$/;
+  return regex3.test(value2);
+};
+var NIF_BE = (value2) => {
+  const regex3 = /^\d{11}$/;
+  if (!regex3.test(value2))
+    return false;
+  const number = parseInt(value2.substring(0, 9), 10);
+  const checkDigits = parseInt(value2.substring(9), 10);
+  const mod = 97 - number % 97;
+  return mod === checkDigits;
+};
+var NIF_NL = (value2) => {
+  const regex3 = /^\d{9}$/;
+  if (!regex3.test(value2))
+    return false;
+  const total = value2.split("").map((digit, index) => parseInt(digit, 10) * (9 - index)).reduce((sum, val) => sum + val, 0);
+  return total % 11 === 0;
+};
+var NIF_SE = (value2) => {
+  const regex3 = /^\d{10,12}$/;
+  if (!regex3.test(value2))
+    return false;
+  const normalizedNIF = value2.length === 12 ? value2.substring(2) : value2;
+  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;
+};
+var 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":
+      return NIF_SE(nif);
+    default:
+      throw new Error(`NIF validation not supported for locale: ${locale}`);
+  }
+};
+var NIE = (value2) => {
+  if (value2.length !== 9)
+    return true;
+  const nieRegex = /^[XYZ]\d{7}[TRWAGMYFPDXBNJZSQVHLCKE]$/;
+  if (!nieRegex.test(value2)) {
+    return true;
+  }
+  let fixedDocNumber = value2.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);
+};
+var 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;
+};
+var IBAN = (value2) => {
+  const iban = value2.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;
+};
+var CIF = (value2) => {
+  const cifRegex = /^[A-Z][0-9]{7}[A-J0-9]$/;
+  return !cifRegex.test(value2);
+};
+var document_default = (value2, validations3) => {
+  if (!value2 || !validations3.document)
+    return true;
+  const validation = {
+    NIF: (value3, locale) => NIF(value3, locale),
+    NIE: (value3) => NIE(value3),
+    CIF: (value3) => CIF(value3),
+    IBAN: (value3) => IBAN(value3)
+  };
+  return validation[validations3.document.type](
+    value2,
+    validations3.document.locale
+  );
+};
+
+// libs/form-engine-core/src/validations/number.ts
+var max = (value2, validations3) => {
+  const number = Number(value2);
+  if (!validations3.max || Number.isNaN(number))
+    return false;
+  return number > Number(validations3.max);
+};
+var min = (value2, validations3) => {
+  const number = Number(value2);
+  if (!validations3.min || Number.isNaN(number))
+    return false;
+  return number < Number(validations3.min);
+};
+var between = (value2, validations3) => {
+  if (!validations3.between || !value2)
+    return false;
+  const num = Number(value2);
+  return !Number.isNaN(num) && !(+num >= validations3.between.start && +num <= validations3.between.end);
+};
+var sequential = (value2, validations3) => {
+  if (!validations3.sequential)
+    return false;
+  const numbers = "0123456789";
+  const numbersRev = "9876543210";
+  const replacedValue = String(value2).replace(/[^0-9]/g, "");
+  return !(numbers.indexOf(replacedValue) === -1 && numbersRev.indexOf(replacedValue) === -1);
+};
+
+// libs/form-engine-core/src/validations/regex.ts
+var regex2 = (value2, validations3) => {
+  if (!validations3.regex || !value2)
+    return false;
+  const regex3 = new RegExp(validations3.regex);
+  return !regex3.test(value2);
+};
+var email = (value2, validations3) => {
+  if (!validations3.email || !value2)
+    return false;
+  const regex3 = /^(([^<>()[\]\\.,;:\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 !regex3.test(value2);
+};
+var url = (value2, validations3) => {
+  if (!validations3.url || !value2)
+    return false;
+  const regex3 = /[(http(s)?)://(www.)?a-zA-Z0-9@:%._+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_+.~#?&//=]*)/gi;
+  return !regex3.test(value2);
+};
+var onlyLetters2 = (value2, validations3) => {
+  if (!validations3.onlyLetters)
+    return false;
+  return !/^[\p{L}\s]*$/u.test(value2);
+};
+var notAllowSpaces = (value2, validations3) => {
+  if (!validations3.notAllowSpaces)
+    return false;
+  return /\s/.test(value2);
+};
+var isNumber2 = (value2, validations3) => {
+  if (!validations3.isNumber)
+    return false;
+  return !!value2 && !/^[0-9\s]*$/.test(value2);
+};
+var hasNoExtraSpaces = (value2, validations3) => {
+  if (!validations3.hasNoExtraSpaces || !value2)
+    return false;
+  return regex2(value2, {
+    regex: "^[A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\xE4\xF6\xFC\xC4\xD6\xDC\xDF0-9]+$"
+  });
+};
+var repeated = (value2, validations3) => {
+  if (!validations3.repeated)
+    return false;
+  const numCount = {};
+  for (const char of String(value2)) {
+    if (/\d/.test(char)) {
+      if (numCount[char]) {
+        return true;
+      }
+      numCount[char] = 1;
+    }
+  }
+  return false;
+};
+
+// libs/form-engine-core/src/validations/custom.ts
+var callback2 = (value2, validations3) => {
+  if (!validations3.callback || !(validations3?.callback instanceof Function))
+    return false;
+  return validations3.callback(value2);
+};
+
+// libs/form-engine-core/src/validations/list.ts
+var includes = (value2, validations3) => {
+  if (!value2 || !Array.isArray(validations3?.includes))
+    return false;
+  return !validations3.includes.some(
+    (code) => code === value2 || JSON.stringify(code) === value2
+  );
+};
+
+// libs/form-engine-core/src/validations/creditCard.ts
+var isCreditCard = (value2, validations3) => {
+  if (!value2)
+    return true;
+  const [type] = getTypeCard(String(value2), validations3.isCreditCard);
+  return !type;
+};
+var isCreditCodeMatch = (value2, validations3) => {
+  if (!value2 || !validations3.isCreditCodeMatch)
+    return false;
+  const [type] = getTypeCard(
+    validations3.isCreditCodeMatch.numberCard,
+    validations3.isCreditCodeMatch.availableOptions
+  );
+  return type?.code?.size !== value2.length;
+};
+var isCreditCardAndLength = (value2, validations3) => {
+  if (!value2 || !validations3.isCreditCardAndLength)
+    return false;
+  const [type, rawValue] = getTypeCard(
+    value2,
+    validations3.isCreditCardAndLength
+  );
+  return type && !type.lengths.includes(rawValue.length);
+};
+
+// libs/form-engine-core/src/validations/string.ts
+var notEmpty = (value2, validations3) => {
+  if (!validations3?.notEmpty || typeof value2 === "undefined")
+    return false;
+  return value2 === null || value2 === "" || value2 === 0 || !String(value2)?.trim().length;
+};
+var value = (value2, validations3) => {
+  if (typeof validations3?.value === "undefined" || validations3?.value === null || typeof value2 === "undefined" || value2 === null)
+    return false;
+  return value2 != validations3.value;
+};
+
+// libs/form-engine-core/src/validations/logical.ts
+var required = (value2, validations3) => !!(validations3.required && (!value2 || typeof value2 === "string" && value2.trim().length === 0));
+var bool = (_, validations3) => {
+  if (!validations3?.bool)
+    return false;
+  let fail = false;
+  if (typeof validations3.bool === "boolean") {
+    fail = validations3.bool;
+  }
+  return fail;
+};
+var exists = (value2, validations3) => {
+  if (!validations3.exists)
+    return false;
+  let fail = !validations3.exists;
+  if (!fail) {
+    fail = !value2;
+  }
+  return fail;
+};
+
+// libs/form-engine-core/src/validations/object.ts
+var conditionResult = (value2, rule) => {
+  if (rule.forceDefinedOrigin && rule.origin === void 0 || rule.forceDefinedTarget && rule.target === void 0) {
+    return false;
+  }
+  const origin = rule.origin === void 0 ? value2 : rule.origin;
+  const target = rule.target === void 0 ? value2 : rule.target;
+  const conditionMapper = {
+    "!==": (origin || value2) !== (target || value2),
+    "===": (origin || value2) === (target || value2),
+    "<": (origin || value2) < (target || value2),
+    ">": (origin || value2) > (target || value2),
+    "<=": (origin || value2) <= (target || value2),
+    ">=": (origin || value2) >= (target || value2),
+    "!!origin": !!String(origin || value2).trim().length
+  };
+  return conditionMapper[rule.condition];
+};
+var conditions = (value2, validations3) => {
+  if (!validations3.conditions)
+    return false;
+  const rulesMapper = {
+    and: () => !!validations3.conditions?.set.every(
+      (validate) => conditionResult(value2, validate)
+    ),
+    or: () => !!validations3.conditions?.set.some(
+      (validate) => conditionResult(value2, validate)
+    )
+  };
+  let result = rulesMapper[validations3.conditions.rule]();
+  if (validations3.conditions.conditions) {
+    if (validations3.conditions.rule === "and") {
+      result = result && conditions(value2, {
+        conditions: validations3.conditions.conditions
+      });
+    } else {
+      result = result || conditions(value2, {
+        conditions: validations3.conditions.conditions
+      });
+    }
+  }
+  return !result;
+};
+
+// libs/form-engine-core/src/validations/date.ts
+var betweenDates = (value2, validations3) => {
+  let fail = false;
+  if (validations3.betweenDates?.length != 2)
+    return false;
+  for (const validation of validations3.betweenDates) {
+    if (date(value2, { date: validation })) {
+      fail = true;
+      break;
+    }
+  }
+  return fail;
+};
+var getIntervalsDate = (date2, intervals) => {
+  const intervalsMapper = {
+    years: (date3, value2) => new Date(date3.setUTCFullYear(date3.getUTCFullYear() + value2)),
+    months: (date3, value2) => new Date(date3.setUTCMonth(date3.getUTCMonth() + value2)),
+    days: (date3, value2) => new Date(date3.setDate(date3.getUTCDate() + value2))
+  };
+  return Object.keys(intervals).reduce(
+    (acc, interval) => intervalsMapper[interval](acc, intervals[interval]),
+    new Date(date2)
+  );
+};
+var dateRearrangeMapper = {
+  DDMMYYYY: (value2) => {
+    const dateParts = value2.split(value2.includes("/") ? "/" : "-");
+    return `${dateParts[1]}/${dateParts[0]}/${dateParts[2]}`;
+  },
+  YYYYMMDD: (value2) => {
+    const dateParts = value2.split(value2.includes("/") ? "/" : "-");
+    return `${dateParts[1]}/${dateParts[2]}/${dateParts[0]}`;
+  },
+  YYYYDDMM: (value2) => {
+    const dateParts = value2.split(value2.includes("/") ? "/" : "-");
+    return `${dateParts[2]}/${dateParts[1]}/${dateParts[0]}`;
+  },
+  MMDDYYYY: (value2) => value2,
+  timestamp: (value2) => new Date(value2).toString()
+};
+var date = (value2, validations3) => {
+  if (!validations3.date?.target?.value && !validations3.date?.origin?.intervals) {
+    return false;
+  }
+  const originValue = validations3.date.origin.value || value2;
+  let originDate = new Date(
+    dateRearrangeMapper[validations3.date?.origin.format](originValue).toString()
+  );
+  let targetDate = /* @__PURE__ */ new Date();
+  let target = /* @__PURE__ */ new Date();
+  if (validations3.date?.target?.format) {
+    target = new Date(
+      dateRearrangeMapper[validations3.date?.target?.format](
+        validations3.date.target.value
+      ).toString()
+    );
+    targetDate = target;
+  }
+  if (validations3.date.origin.intervals) {
+    targetDate = getIntervalsDate(
+      originDate,
+      validations3.date.origin.intervals
+    );
+    const date2 = /* @__PURE__ */ new Date();
+    if (validations3.date.target?.value && target) {
+      date2.setDate(target.getDate());
+      date2.setMonth(target.getMonth());
+    }
+    originDate = /* @__PURE__ */ new Date(
+      `${date2.getUTCMonth() + 1}/${date2.getUTCDate()}/${date2.getUTCFullYear()}`
+    );
+  }
+  if (validations3.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[validations3.date?.operator];
+};
+var validDate = (value2, validations3) => {
+  if (!validations3.validDate || !value2)
+    return false;
+  if (/[^a-zA-Z0-9\s-]/.test(value2))
+    return true;
+  const dateParts = dateRearrangeMapper[validations3.validDate](value2).toString().split(/[/-]/);
+  const year = parseInt(dateParts[2], 10);
+  const month = parseInt(dateParts[0], 10) - 1;
+  const day = parseInt(dateParts[1], 10);
+  const date2 = new Date(year, month, day);
+  const isValidDate = date2.getFullYear() === year && date2.getMonth() === month && date2.getDate() === day;
+  return !isValidDate;
+};
+
+// libs/form-engine-core/src/validations/multiple.ts
+var validations = {
+  max,
+  min,
+  length: length_default,
+  regex: regex2,
+  url,
+  email,
+  onlyLetters: onlyLetters2,
+  notAllowSpaces,
+  callback: callback2,
+  hasNoExtraSpaces,
+  between,
+  sequential,
+  includes,
+  repeated,
+  document: document_default,
+  isCreditCard,
+  isCreditCodeMatch,
+  isCreditCardAndLength,
+  required,
+  value,
+  notEmpty,
+  bool,
+  exists,
+  greaterThan: () => true,
+  isNumber: isNumber2,
+  conditions,
+  validDate,
+  date,
+  betweenDates
+};
+var run = (value2, handlers) => {
+  const runner = [];
+  Object.keys(handlers).forEach((rule) => {
+    runner.push(
+      validations[rule](value2, {
+        [rule]: handlers[rule]
+      })
+    );
+  });
+  return runner;
+};
+var multipleValidations = (value2, validations3) => {
+  if (!validations3.multipleValidations)
+    return false;
+  const runner = run(
+    value2,
+    validations3.multipleValidations.validations
+  );
+  const rulesMapper = {
+    AND: () => runner.every((validation) => validation),
+    OR: () => runner.some((validation) => validation),
+    NOT: () => !runner.every((validation) => validation)
+  };
+  return rulesMapper[validations3.multipleValidations.rule]();
+};
+
+// libs/form-engine-core/src/validations/handler.ts
+var validations2 = {
+  max,
+  min,
+  length: length_default,
+  regex: regex2,
+  url,
+  email,
+  onlyLetters: onlyLetters2,
+  notAllowSpaces,
+  callback: callback2,
+  hasNoExtraSpaces,
+  between,
+  sequential,
+  includes,
+  repeated,
+  document: document_default,
+  isCreditCard,
+  isCreditCodeMatch,
+  isCreditCardAndLength,
+  required,
+  value,
+  notEmpty,
+  bool,
+  exists,
+  greaterThan: () => true,
+  isNumber: isNumber2,
+  conditions,
+  multipleValidations,
+  date,
+  betweenDates,
+  validDate
+};
+
+// libs/form-engine-core/src/managers/field.ts
+import { get, isEqual, isNil } from "lodash";
+var FormField = class {
+  /**
+   * 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
+  }) {
+    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 (mapper.events?.setValue)
+      this.valuePropName = mapper.events.setValue;
+    if (mapper.events?.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: this.apiSchema?.defaultConfig?.config?.fallbackValue || ""
+      },
+      named: this.apiSchema?.configs && Object.keys(this.apiSchema?.configs).reduce(
+        (acc, curr) => {
+          acc[curr] = {
+            response: this.apiSchema?.configs?.[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, 1e3)).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(value2) {
+    let val;
+    if (this.valueChangeEvent) {
+      try {
+        val = this.valueChangeEvent(value2, { props: this.props });
+      } catch (e) {
+        val = value2;
+      }
+    } else {
+      val = value2;
+    }
+    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;
+    }
+    if (this.valuePropName)
+      this._props = {
+        ...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.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 }) {
+    if (!this.validations) {
+      this._valid = true;
+      return;
+    }
+    if (!this.validations.events.includes(event) && event !== "ON_FORM_SUBMIT")
+      return;
+    let valid = true;
+    const errors = { ...this.errors };
+    const schemaValidations = this.validations?.config;
+    schemaValidations && Object.keys(schemaValidations).forEach(
+      (validationKey) => {
+        const error = validations2[validationKey](
+          this.value,
+          schemaValidations
+        );
+        valid = !error && valid;
+        if (this.validations?.events.includes(event) || event === "ON_FORM_SUBMIT") {
+          if (error && this.errorMessages?.[validationKey]) {
+            errors[validationKey] = this.errorMessages[validationKey];
+          } else {
+            delete errors[validationKey];
+          }
+        }
+      }
+    );
+    this._valid = valid;
+    this.errors = errors;
+    if (this.errorMessagePropName)
+      this.props = {
+        ...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(value2) {
+    if (this.formatters) {
+      return Object.keys(this.formatters).reduce(
+        (acc, curr) => {
+          return formatters[curr](acc, this.formatters);
+        },
+        value2
+      );
+    }
+    return value2;
+  }
+  /**
+   * Masks the field value using the specified masks, if available.
+   *
+   * @param {unknown} value - The value to be masked.
+   * @returns {unknown} - The masked value.
+   */
+  maskValue(value2) {
+    if (this.masks) {
+      return Object.keys(this.masks).reduce((acc, curr) => {
+        return masks[curr](acc, this.masks);
+      }, value2);
+    }
+    return value2;
+  }
+  checkApiRequestValidations(config) {
+    let valid = true;
+    const preConditions = config.preConditions;
+    preConditions && Object.keys(preConditions).forEach(
+      (validationKey) => {
+        const error = validations2[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>}
+   */
+  async apiRequest({ event }) {
+    if (!this.apiSchema?.defaultConfig?.events.includes(event) && !(this.apiSchema?.configs && Object.keys(this.apiSchema?.configs).some(
+      (key) => this.apiSchema?.configs?.[key].events.includes(event)
+    )))
+      return;
+    const responses = {
+      default: { ...this.api.default },
+      named: { ...this.api.named }
+    };
+    const config = this.apiSchema.defaultConfig?.config;
+    if (config && this.apiSchema?.defaultConfig?.events.includes(event) && this.checkApiRequestValidations(config)) {
+      try {
+        const responseData = await makeRequest(
+          config.method,
+          config.url,
+          config.headers,
+          config.body
+        );
+        const apiResponseData = JSON.parse(String(responseData));
+        const response = config.resultPath ? get(apiResponseData, config.resultPath) : apiResponseData;
+        responses.default = { response };
+      } catch (e) {
+        responses.default = {
+          response: !isNil(config?.fallbackValue) ? config.fallbackValue : "error"
+        };
+      }
+    }
+    if (this.apiSchema?.configs && Object.keys(this.apiSchema?.configs).some(
+      (key) => this.apiSchema?.configs?.[key].events.includes(event)
+    )) {
+      if (this.apiSchema.configs) {
+        const result = await Promise.all(
+          Object.keys(this.apiSchema.configs).map(async (configKey) => {
+            return new Promise((res) => {
+              const config2 = this.apiSchema?.configs?.[configKey].config;
+              if (config2 && this.apiSchema?.configs?.[configKey].events.includes(event) && this.checkApiRequestValidations(config2)) {
+                try {
+                  makeRequest(
+                    config2.method,
+                    config2.url,
+                    config2.headers,
+                    config2.body
+                  ).then((responseData) => {
+                    const apiResponseData = JSON.parse(String(responseData));
+                    const response = get(
+                      apiResponseData,
+                      config2.resultPath || ""
+                    );
+                    res({ name: configKey, result: { response } });
+                  });
+                } catch (e) {
+                  res({
+                    name: configKey,
+                    result: {
+                      response: !isNil(config2.fallbackValue) ? config2.fallbackValue : "error"
+                    }
+                  });
+                }
+              }
+            });
+          })
+        );
+        result.forEach(({ name, result: result2 }) => {
+          if (responses.named)
+            responses.named[name] = result2;
+        });
+      }
+    }
+    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(callback3) {
+    this.fieldStateSubscription$ = this.fieldState$.pipe(debounceTime(100)).subscribe({
+      next: callback3
+    });
+  }
+  /**
+   * 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(callback3) {
+    this.valueSubject$.subscribe({
+      next: callback3
+    });
+  }
+};
+
+// libs/form-engine-core/src/managers/form.ts
+import { debounceTime as debounceTime2, map as map2, Subject as Subject2, Subscription as Subscription2 } from "rxjs";
+import { get as get2, isEqual as isEqual2, isNil as isNil2, set } from "lodash";
+var IVARPROPNAME = "iVars";
+var FormCore = 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) {
+    this.schema = entry.schema;
+    this.fields = /* @__PURE__ */ new Map();
+    this.initialValues = entry.initialValues || entry.schema?.initialValues;
+    this.action = entry.action || entry.schema?.action;
+    this.method = entry.method || entry.schema?.method;
+    this._iVars = entry.iVars || entry.schema?.iVars || {};
+    this.onSubmit = entry.onSubmit;
+    this.mappers = entry.mappers;
+    this.schema && _FormCore.checkIndexes(this.schema.components);
+    this.templateSubject$ = new Subject2();
+    this.submitSubject$ = new Subject2();
+    this.apiResponseSubject$ = new Subject2();
+    this.dataSubject$ = new Subject2();
+    this.dataCallbackSubscription$ = new Subscription2();
+    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);
+    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() {
+    this.fields.forEach(
+      ({
+        component,
+        props,
+        name,
+        validations: validations3,
+        visibilityConditions,
+        resetValues,
+        errorMessages,
+        apiSchema,
+        metadata
+      }, key) => {
+        const template = {
+          component,
+          props,
+          name,
+          validations: validations3,
+          visibilityConditions,
+          resetValues,
+          errorMessages,
+          apiSchema,
+          metadata
+        };
+        traverseObject(template, key).forEach(
+          (element) => this.subscribedTemplates.push(element)
+        );
+      }
+    );
+  }
+  /**
+   *
+   * @param {(payload: { field: string; data: TFormValues }) => void} callback callback function to call on data
+   */
+  subscribeData(callback3) {
+    this.dataCallbackSubscription$ = this.dataSubject$.pipe(
+      debounceTime2(100),
+      map2(({ key }) => ({ field: key, data: this.getFormValues() }))
+    ).subscribe({
+      next: callback3
+    });
+  }
+  /**
+   * 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 value2 = get2(this.iVars, [property, ...path]);
+      return value2;
+    }
+    if (!this.fields.has(key))
+      return console.warn(`failed to get value from ${key}`);
+    return path.length > 0 ? get2(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: value2
+  }) {
+    const field = this.fields.get(key);
+    if (!field) {
+      console.warn(`failed to update field ${key}`);
+      return;
+    }
+    if (path.length > 0) {
+      if (property === "props" && path[0] === field.valuePropName && key !== originKey) {
+        field.emitValue({ event: "ON_FIELD_CHANGE", value: value2 });
+        return;
+      }
+      const fieldProp = field[property];
+      let propState;
+      if (Array.isArray(fieldProp)) {
+        propState = [...fieldProp];
+      } else if (typeof fieldProp === "object" && !isNil2(fieldProp)) {
+        propState = { ...fieldProp };
+      } else {
+        console.warn(
+          `invalid template property, skipping evaluation of ${field.name} with ${fieldProp}`
+        );
+        return;
+      }
+      set(propState, path, value2);
+      field[property] = propState;
+      return;
+    }
+    field[property] = value2;
+    return;
+  }
+  /**
+   * Extracts parameters from an expression.
+   *
+   * @param {string} expression - The expression containing parameters.
+   * @returns {string[]} An array of extracted parameters.
+   */
+  extractParams(expression) {
+    const regex3 = /\${(.*?)}/g;
+    const extractedValues = [];
+    let match;
+    while (!isNil2(match = regex3.exec(expression))) {
+      extractedValues.push(match[1]);
+    }
+    const operatorRegex = /\s*(\|\||&&|!)\s*/g;
+    const splittedString = extractedValues.map((el) => el.split(operatorRegex));
+    const result = splittedString.map((splittedStringVal) => {
+      return splittedStringVal.filter(Boolean).reduce((acc, curr) => {
+        if (curr.match(/^\|\||&&|!$/)) {
+          return `${acc}${curr}`;
+        }
+        let value2;
+        const element = curr.split(".");
+        const currElementContent = element.length > 1 ? this.getValue({
+          key: element[0],
+          property: element[1],
+          path: element.slice(2)
+        }) : element;
+        let currValue;
+        try {
+          currValue = JSON.parse(currElementContent);
+        } catch (e) {
+          currValue = currElementContent;
+        }
+        switch (typeof currValue) {
+          case "string":
+            value2 = `\`${currValue}\``;
+            break;
+          case "boolean":
+          case "undefined":
+          case "number":
+            value2 = currValue;
+            break;
+          case "object":
+            if (currValue === null) {
+              value2 = null;
+            }
+            value2 = JSON.stringify(currValue);
+            break;
+          default:
+            value2 = currValue;
+        }
+        return `${acc}${value2}`;
+      }, "");
+    });
+    return result.map((el) => {
+      try {
+        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 regex3 = /\${(.*?)}/g;
+    return expression.replace(regex3, () => 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 regex3 = /^\${[^${}]*}$/;
+    return !regex3.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?.[0];
+          }
+          const destinationValue = this.getValue({
+            key: destinationKey,
+            property: destinationProperty,
+            path: destinationPath
+          });
+          if (!isEqual2(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 }) {
+    return key;
+  }
+  static {
+    /**
+     * 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
+     */
+    this.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;
+    };
+  }
+  /**
+   * 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?.visibilityConditions;
+    if (!structVisibility || !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 = validations2[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?.resetValues;
+    if (!structResetValue || !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 = validations2[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) => {
+      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: this.initialValues?.[structElement.name],
+            templateSubject$: this.templateSubject$,
+            apiResponseSubject$: this.apiResponseSubject$,
+            dataSubject$: this.dataSubject$
+          })
+        );
+      } else {
+        currField.children = structElement?.children?.map((el) => el.name) || 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) => {
+      if (!keys.includes(key)) {
+        this.fields.get(key)?.destroyField();
+        this.fields.delete(key);
+      }
+    });
+    this.subscribeTemplates();
+    this.fields.forEach((_, key) => {
+      if (!prevKeys.includes(key)) {
+        this.fields.get(key)?.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();
+  }
+};
+
+// libs/form-engine-core/src/managers/formGroup.ts
+var FormGroup = class {
+  /**
+   * Creates an instance of FormGroup.
+   */
+  constructor() {
+    this.forms = /* @__PURE__ */ 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 }) {
+    this.forms.get(key)?.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) => {
+      const res = this.forms.get(index)?.getFormValues();
+      isValid = isValid && (res?.isValid || false);
+      values = { ...values, ...res?.values || {} };
+      erroredFields = [...erroredFields, ...res?.erroredFields || []];
+    });
+    return {
+      erroredFields,
+      isValid,
+      values
+    };
+  }
+};
+export {
+  FormCore,
+  FormField,
+  FormGroup,
+  TMutationEnum
+};