@bolttech/form-engine-core 0.0.1-beta.2 → 0.0.1-beta.21

package/index.esm.js

@@ -1,6 +1,6 @@
-import { Subscription, Subject, combineLatest, startWith, filter, groupBy, mergeMap, debounceTime, map } from 'rxjs';
+import { Subject, Subscription, combineLatest, startWith, groupBy, mergeMap, debounceTime, filter, map } from 'rxjs';
 import creditCardType from 'credit-card-type';
-import { isNumber as isNumber$1, isNil, isEqual, get, set } from 'lodash';
+import { isNumber as isNumber$1, isFunction, isEqual, get, isNil, set } from 'lodash';
 import { getCurrencySymbol } from '@gaignoux/currency';
 
 var TMutationEnum;
@@ -44,6 +44,12 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+const DEFAULT_API_DEBOUNCE_TIME = 1000;
+const DEFAULT_STATE_REFRESH_TIME = 100;
+const TEMPLATE_REGEX_DELIMITATOR = /\${(.*?)}/g;
+const TEMPLATE_REGEX_OPERATOR_SPLITTER = /\s*(\|\||&&|!)\s*/g;
+const TEMPLATE_REGEX_OPERATOR_MATCHER = /^\|\||&&|!$/;
+
 /**
  * Makes an HTTP request using XMLHttpRequest.
  *
@@ -96,15 +102,17 @@ function makeRequest(method, url, headers, body) {
  * ```
  */
 function extractFieldKeys(expression) {
-  const regex = /\${(.*?)}/g;
+  const regex = TEMPLATE_REGEX_DELIMITATOR;
   const extractedValues = [];
   let match;
   while ((match = regex.exec(expression)) !== null) {
     extractedValues.push(match[1]);
   }
+  const operatorRegex = TEMPLATE_REGEX_OPERATOR_SPLITTER;
+  const splittedString = extractedValues.map(el => el.split(operatorRegex).filter(item => !operatorRegex.test(item))).flat().filter(el => el.split('.').length > 1);
   return {
-    originFieldKeys: Array.from(new Set(extractedValues.map(el => el.split('.')[0]))),
-    originPropertyKeys: Array.from(new Set(extractedValues.map(el => el.split('.')[1])))
+    originFieldKeys: Array.from(new Set(splittedString.map(el => el.split('.')[0]))),
+    originPropertyKeys: Array.from(new Set(splittedString.map(el => el.split('.')[1])))
   };
 }
 /**
@@ -142,7 +150,7 @@ function traverseObject(obj, path) {
           if (typeof item === 'object') {
             result.push(...traverseObject(item, `${path ? `${path}.` : ``}${key}.${index}`));
           } else if (typeof item === 'string') {
-            if (String(item).includes('$')) {
+            if (String(item).includes('${')) {
               // const extractedPath = item.replace(/\$|{|}/g, '').split('.');
               const extractedOriginPath = `${path ? `${path}.` : ``}${key}`.split('.');
               result.push(Object.assign(Object.assign({
@@ -158,7 +166,7 @@ function traverseObject(obj, path) {
       } else if (typeof value === 'object') {
         result.push(...traverseObject(value, `${path ? `${path}.` : ``}${key}`));
       } else if (typeof value === 'string') {
-        if (value.includes('$')) {
+        if (value.includes('${')) {
           // const extractedPath = value.replace(/\$|{|}/g, '').split('.');
           const destinationPath = `${path ? `${path}.` : ``}${key}`.split('.');
           result.push(Object.assign(Object.assign({
@@ -681,16 +689,9 @@ const currency = (value, masks) => {
   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) {
@@ -1928,41 +1929,44 @@ const conditions = (value, validations) => {
 };
 
 /**
- * Validates if a date value falls between two specified dates.
+ * @internal
+ * Validates if a date string matches a specific date format.
+ * The function accepts strings with '/' or '-' separators and removes them before validating the format.
  *
- * @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`.
+ * @param {string} string - The date string to be validated. It can contain '/' or '-' separators.
+ * @param {string} format - The expected date format. It can be one of the following:
+ *                          'DDMMYYYY', 'YYYYMMDD', 'YYYYDDMM', 'MMDDYYYY',
+ *                          'DMYYYY', 'YYYYMD', 'YYYYDM', 'MDYYYY'.
+ * @returns {boolean} - Returns `false` if the date string matches the specified format, otherwise `true`.
  *
  * @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: '<=' }
- *   ]
- * };
+ * // Returns false
+ * invalidStringDate("25/07/1997", "DDMMYYYY");
  *
- * const result1 = betweenDates('2023-06-01', validations);
- * console.log(result1); // false (date is within the range)
+ * @example
+ * // Returns false
+ * invalidStringDate("1997-07-25", "YYYYMMDD");
  *
- * const result2 = betweenDates('2024-01-01', validations);
- * console.log(result2); // true (date is outside the range)
- * ```
+ * @example
+ * // Returns true, as the format does not match
+ * invalidStringDate("1997/25/07", "MMDDYYYY");
  */
-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;
-    }
+const invalidStringDate = (value, format) => {
+  if (!value.includes('/') && !value.includes('-') || !format) {
+    return true;
   }
-  return fail;
+  const valueParts = value.replace(/[-/]/g, '');
+  const dateMapper = {
+    DDMMYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    YYYYMMDD: /^(\d{4})(\d{2})(\d{2})$/,
+    YYYYDDMM: /^(\d{4})(\d{2})(\d{2})$/,
+    MMDDYYYY: /^(\d{2})(\d{2})(\d{4})$/,
+    DMYYYY: /^(\d{1,2})(\d{1,2})(\d{4})$/,
+    YYYYMD: /^(\d{4})(\d{1,2})(\d{1,2})$/,
+    YYYYDM: /^(\d{4})(\d{1,2})(\d{1,2})$/,
+    MDYYYY: /^(\d{1,2})(\d{1,2})(\d{4})$/
+  };
+  return !dateMapper[format].test(valueParts);
 };
 /**
  * @internal
@@ -2015,6 +2019,44 @@ const dateRearrangeMapper = {
   MMDDYYYY: value => value,
   timestamp: value => new Date(value).toString()
 };
+/**
+ * @function betweenDates
+ * 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;
+};
 /**
  * @function date
  * Validates a date value based on various date conditions and intervals.
@@ -2048,22 +2090,24 @@ const dateRearrangeMapper = {
  * ```
  */
 const date = (value, validations) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
   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());
+  const mappedValue = dateRearrangeMapper[(_e = validations.date) === null || _e === void 0 ? void 0 : _e.origin.format](originValue).toString();
+  if (invalidStringDate(mappedValue, (_f = validations.date) === null || _f === void 0 ? void 0 : _f.origin.format)) return false;
+  let originDate = new Date(mappedValue);
   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());
+  if ((_h = (_g = validations.date) === null || _g === void 0 ? void 0 : _g.target) === null || _h === void 0 ? void 0 : _h.format) {
+    target = new Date(dateRearrangeMapper[(_k = (_j = validations.date) === null || _j === void 0 ? void 0 : _j.target) === null || _k === void 0 ? void 0 : _k.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) {
+    if (((_l = validations.date.target) === null || _l === void 0 ? void 0 : _l.value) && target) {
       date.setDate(target.getDate());
       date.setMonth(target.getMonth());
     }
@@ -2082,7 +2126,7 @@ const date = (value, validations) => {
     '===': originTimestamp === targetTimestamp,
     '!==': originTimestamp !== targetTimestamp
   };
-  return operationsMapper[(_l = validations.date) === null || _l === void 0 ? void 0 : _l.operator];
+  return operationsMapper[(_m = validations.date) === null || _m === void 0 ? void 0 : _m.operator];
 };
 /**
  * @function validDate
@@ -2111,11 +2155,69 @@ const validDate = (value, validations) => {
   const month = parseInt(dateParts[0], 10) - 1; // Month is zero-based
   const day = parseInt(dateParts[1], 10);
   const date = new Date(year, month, day);
+  /* This line is here because we need to guarantee that the field will not be valid while typing,
+  * that is, imagine the scenario where the user wants to type 1995, when typing 19 or 199,
+  * the function returns valid, as there is a year 19 or 199.
+  */
+  console.log('ValidDate: ', date.getFullYear());
+  if (date.getFullYear() < 1900) {
+    return true;
+  }
   // Check if the date is valid
   const isValidDate = date.getFullYear() === year && date.getMonth() === month && date.getDate() === day;
   return !isValidDate;
 };
 
+/**
+ * @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.
+ * @param {TValidationHandler} validations - An object containing every validation methods to be executed.
+ * @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')
+ */
+function run$1(value, handlers, validations) {
+  const runner = [];
+  Object.keys(handlers).forEach(rule => {
+    runner.push(validations[rule](value, {
+      [rule]: handlers[rule]
+    }));
+  });
+  return runner;
+}
+/**
+ * Validates a given value based on specified validation methods inside a custom named validation.
+ *
+ * @param {unknown} value - The value to be validated.
+ * @param {TValidationMethods} methods - The validation methods to be applied.
+ * @param {TValidationHandler} validations - An object containing every validation methods to be executed.
+ * @returns {boolean} - Returns true if any of the validation methods pass, otherwise false.
+ *
+ * @example
+ * const value = 'example@example.com';
+ * const methods = {
+ *   required: true,
+ *   email: true
+ * };
+ *
+ * const isValid = validateValue(value, methods);
+ * console.log(isValid); // Output: true
+ */
+var namedRule = ((value, methods, validations) => {
+  if (!methods) return false;
+  return run$1(value, methods, validations).some(validation => validation);
+});
+
 /**
  * @internal
  * An object mapping validation keys to their respective validation functions.
@@ -2150,7 +2252,6 @@ const validations$1 = {
   notEmpty,
   bool,
   exists,
-  greaterThan: () => true,
   isNumber,
   conditions,
   validDate,
@@ -2174,20 +2275,26 @@ const validations$1 = {
  * const results = run('test@example.com', handlers);
  * console.log(results); // [false, false, true] (value fails 'max', passes 'required', passes 'email')
  */
-const run = (value, handlers) => {
+function run(value, handlers) {
   const runner = [];
   Object.keys(handlers).forEach(rule => {
-    runner.push(validations$1[rule](value, {
-      [rule]: handlers[rule]
-    }));
+    let handler;
+    if (isFunction(validations$1[rule])) {
+      handler = validations$1[rule](value, {
+        [rule]: handlers[rule]
+      });
+    } else {
+      handler = namedRule(value, handlers[rule], validations$1);
+    }
+    runner.push(handler);
   });
   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.
+ * @param {TValidationMethods} methods - 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
@@ -2212,15 +2319,15 @@ const run = (value, handlers) => {
  * console.log(result2); // false
  * ```
  */
-const multipleValidations = (value, validations) => {
-  if (!validations.multipleValidations) return false;
-  const runner = run(value, validations.multipleValidations.validations);
+const multipleValidations = (value, methods) => {
+  if (!methods.multipleValidations) return false;
+  const runner = run(value, methods.multipleValidations.validations);
   const rulesMapper = {
     AND: () => runner.every(validation => validation),
     OR: () => runner.some(validation => validation),
     NOT: () => !runner.every(validation => validation)
   };
-  return rulesMapper[validations.multipleValidations.rule]();
+  return rulesMapper[methods.multipleValidations.rule]();
 };
 
 const validations = {
@@ -2247,7 +2354,6 @@ const validations = {
   notEmpty,
   bool,
   exists,
-  greaterThan: () => true,
   isNumber,
   conditions,
   multipleValidations,
@@ -2256,6 +2362,53 @@ const validations = {
   validDate
 };
 
+/**
+ * Custom RXJS Subject to gracefully handle errors on unsubscribed Subjects
+ * that were unmounted due to adapter external handling such as visibility
+ */
+class SafeSubject extends Subject {
+  constructor(isMounted) {
+    super();
+    this.isMounted = isMounted;
+  }
+  next(value) {
+    if (this.isMounted()) {
+      super.next(value);
+    }
+  }
+}
+
+/**
+ * @internal
+ * Handles the validation of a given value based on specified validation methods and rules.
+ *
+ * @param {string | number | boolean | unknown} value - The value to be validated.
+ * @param {TSchemaValidation} validations - The schema validations to be applied.
+ * @param {TValidationHandler} methods - The validation handler methods.
+ * @param {keyof TValidationMethods} key - The specific key of the validation method to be used.
+ * @returns {boolean} - Returns true if the value passes the validation, otherwise false.
+ *
+ * @example
+ * const value = 'example@example.com';
+ * const validations = {
+ *   required: true,
+ *   customName: { email: true }
+ * };
+ * const methods = {
+ *   email: (value) => /\S+@\S+\.\S+/.test(value)
+ * };
+ * const key = 'required';
+ *
+ * const isValid = handleValidation(value, validations, methods, key);
+ * console.log(isValid); // Output: true
+ */
+function handleValidation(value, validations, methods, key) {
+  if (isFunction(methods[key])) {
+    return methods[key](value, validations);
+  }
+  return namedRule(value, validations[key], methods);
+}
+
 /**
  * Represents a form field with observables for managing form state, validations, and API requests.
  */
@@ -2282,40 +2435,41 @@ class FormField {
     resetValue,
     initialValue,
     templateSubject$,
-    apiResponseSubject$,
+    fieldEventSubject$,
     dataSubject$,
     mapper
   }) {
     var _a, _b, _c, _d, _e, _f, _g;
     this.fieldStateSubscription$ = new Subscription();
+    this.originalSchema = schemaComponent;
     this.config = {
-      defaultAPIdebounceTimeMS: Number(config === null || config === void 0 ? void 0 : config.defaultAPIdebounceTimeMS) ? Number(config === null || config === void 0 ? void 0 : config.defaultAPIdebounceTimeMS) : 1000,
-      defaultStateRefreshTimeMS: Number(config === null || config === void 0 ? void 0 : config.defaultStateRefreshTimeMS) ? Number(config === null || config === void 0 ? void 0 : config.defaultStateRefreshTimeMS) : 100
+      defaultAPIdebounceTimeMS: Number(config === null || config === void 0 ? void 0 : config.defaultAPIdebounceTimeMS) ? Number(config === null || config === void 0 ? void 0 : config.defaultAPIdebounceTimeMS) : DEFAULT_API_DEBOUNCE_TIME,
+      defaultStateRefreshTimeMS: Number(config === null || config === void 0 ? void 0 : config.defaultStateRefreshTimeMS) ? Number(config === null || config === void 0 ? void 0 : config.defaultStateRefreshTimeMS) : DEFAULT_STATE_REFRESH_TIME
     };
     this.name = schemaComponent.name;
+    this.nameToSubmit = schemaComponent.nameToSubmit;
     this.component = schemaComponent.component;
     this.path = path;
     this.children = children;
     this.validations = schemaComponent.validations;
-    this.errorMessages = schemaComponent.errorMessages;
+    this.errorMessages = (_a = schemaComponent.validations) === null || _a === void 0 ? void 0 : _a.messages;
     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;
+    if ((_b = mapper.events) === null || _b === void 0 ? void 0 : _b.setValue) this.valuePropName = mapper.events.setValue;
     this.mapper = mapper;
     this.validateVisibility = validateVisibility;
     this.resetValue = resetValue;
     this.templateSubject$ = templateSubject$;
-    this.apiResponseSubject$ = apiResponseSubject$;
+    this.fieldEventSubject$ = fieldEventSubject$;
     this.dataSubject$ = dataSubject$;
     this._props = schemaComponent.props || {};
-    this._value = '';
-    this._stateValue = '';
     this._metadata = '';
+    this.errorsString = '';
+    this.errorsList = [];
     this.initialValue = initialValue;
     this._visibility = true;
     this._api = {
@@ -2331,9 +2485,10 @@ class FormField {
       }, {})
     };
     this._errors = {};
-    this._errorsString = '';
     this._valid = false;
+    this._mounted = true;
     this.initializeObservers();
+    this.value = this.initialValue || '';
   }
   /**
    * method to initialize all recycled Subjects and initialize Observers on field instance creation or rerender
@@ -2341,53 +2496,38 @@ class FormField {
   initializeObservers() {
     var _a;
     if (!this.valueSubject$ || this.valueSubject$.closed) {
-      this.valueSubject$ = new Subject();
+      this.valueSubject$ = new SafeSubject(() => this._mounted);
     }
     if (!this.errorSubject$ || this.errorSubject$.closed) {
-      this.errorSubject$ = new Subject();
+      this.errorSubject$ = new SafeSubject(() => this._mounted);
     }
     if (!this.visibilitySubject$ || this.visibilitySubject$.closed) {
-      this.visibilitySubject$ = new Subject();
+      this.visibilitySubject$ = new SafeSubject(() => this._mounted);
     }
     if (!this.apiSubject$ || this.apiSubject$.closed) {
-      this.apiSubject$ = new Subject();
+      this.apiSubject$ = new SafeSubject(() => this._mounted);
     }
     if (!this.propsSubject$ || this.propsSubject$.closed) {
-      this.propsSubject$ = new Subject();
+      this.propsSubject$ = new SafeSubject(() => this._mounted);
     }
     if (!this.fieldStateSubscription$ || this.fieldStateSubscription$.closed) {
       this.fieldStateSubscription$ = new Subscription();
     }
     if (!this.apiEventQueueSubject$ || this.apiEventQueueSubject$.closed) {
-      this.apiEventQueueSubject$ = new Subject();
+      this.apiEventQueueSubject$ = new SafeSubject(() => this._mounted);
     }
     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))
+      props: this.propsSubject$.pipe(startWith(this._props)),
+      errors: this.errorSubject$.pipe(startWith(Object.assign({}, ((_a = this.mapper.events) === null || _a === void 0 ? void 0 : _a.setErrorMessage) && {
+        [this.mapper.events.setErrorMessage]: this.errorsString
+      })))
     });
-    !this.apiEventQueueSubject$.observed && this.apiEventQueueSubject$.pipe(this.debounceDistinct(({
+    !this.apiEventQueueSubject$.observed && this.apiEventQueueSubject$.pipe(groupBy(({
       event
-    }) => event, (_a = this.config) === null || _a === void 0 ? void 0 : _a.defaultAPIdebounceTimeMS), filter(() => this.apiSubject$ && !this.apiSubject$.closed)).subscribe(payload => {
+    }) => event), mergeMap(group$ => group$.pipe(debounceTime(this.config.defaultAPIdebounceTimeMS))), filter(() => this.apiSubject$ && !this.apiSubject$.closed)).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.
@@ -2414,7 +2554,7 @@ class FormField {
   /**
    * Retrieves the current state value of the form field.
    *
-   * @returns {unknown} - The current state value of the form field.
+   * @returns {Record<string,unknown>} - The current state value of the form field.
    */
   get stateValue() {
     return this._stateValue;
@@ -2422,14 +2562,6 @@ class FormField {
   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.
    *
@@ -2444,6 +2576,7 @@ class FormField {
    * @param {unknown} value - The new value to be set.
    */
   set value(value) {
+    var _a, _b, _c;
     /*
       too much unstable, if the valueChangeEvent parses the template event
       value, might occur unexpected results
@@ -2463,22 +2596,19 @@ class FormField {
     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._stateValue = ((_a = this.mapper.events) === null || _a === void 0 ? void 0 : _a.setValue) ? {
+        [this.mapper.events.setValue]: this.maskValue(this.formatValue(val['_value']))
+      } : {};
       this._metadata = val._metadata;
     } else {
       this._value = this.formatValue(val);
-      this._stateValue = this.maskValue(this.formatValue(val));
+      this._stateValue = ((_b = this.mapper.events) === null || _b === void 0 ? void 0 : _b.setValue) ? {
+        [(_c = this.mapper.events) === null || _c === void 0 ? void 0 : _c.setValue]: this.maskValue(this.formatValue(val))
+      } : {};
+      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.stateValue && this.valueSubject$.next(this.stateValue);
     this.templateSubject$.next({
       key: this.name,
       event: 'ON_VALUE'
@@ -2500,6 +2630,23 @@ class FormField {
   set visibility(visible) {
     if (typeof visible === 'undefined' || visible === this.visibility) return;
     this._visibility = visible;
+    /**
+     * I was sure I would not require to gambiarra, but..
+     * in order to ignore an hidden value on a form submit
+     * or revalidate it when it comes back to visibility
+     * I needed to...
+     * I don't recommend setting private properties like this
+     * this will force the field to be valid when it's hidden
+     * and trigger the validation when it's visible
+     */
+    if (!this.visibility) {
+      this.value = '';
+      this._valid = true;
+    } else {
+      this.setFieldValidity({
+        event: 'ON_FIELD_MOUNT'
+      });
+    }
     this.visibilitySubject$.next(this.visibility);
     this.templateSubject$.next({
       key: this.name,
@@ -2528,10 +2675,17 @@ class FormField {
    * @param {TErrorMessages} errors - The new error messages to be set.
    */
   set errors(errors) {
+    var _a;
     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.errorsList = Object.values(this.errors);
+    this.errorsString = this.errorsList.join(', ');
+    /**
+     * if any error receives a list of errors, set a prop for it, currently only supporting a single string
+     */
+    ((_a = this.mapper.events) === null || _a === void 0 ? void 0 : _a.setErrorMessage) && this.errorSubject$.next({
+      [this.mapper.events.setErrorMessage]: this.errorsString
+    });
     this.templateSubject$.next({
       key: this.name,
       event: 'ON_PROPS'
@@ -2567,11 +2721,8 @@ class FormField {
    * 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({
@@ -2581,6 +2732,7 @@ class FormField {
     this.initializeObservers();
     this.subscribeValue(valueSubscription);
     this.subscribeState(propsSubscription);
+    this._mounted = true;
   }
   /**
    * Sets the value of the form field and emits associated events.
@@ -2622,6 +2774,11 @@ class FormField {
     this.apiEventQueueSubject$.next({
       event
     });
+    this.fieldEventSubject$.next({
+      event,
+      fieldName: this.name,
+      fieldInstance: this
+    });
   }
   /**
    * Sets the validity state of the field based on the provided validation rules and triggers error message updates.
@@ -2632,53 +2789,43 @@ class FormField {
   setFieldValidity({
     event
   }) {
-    var _a;
-    if (!this.validations) {
+    var _a, _b, _c, _d;
+    if (!this.validations || !this.visibility) {
+      this.errors = {};
       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;
+    const errors = {};
+    const schemaValidations = (_a = this.validations) === null || _a === void 0 ? void 0 : _a.methods;
     schemaValidations && Object.keys(schemaValidations).forEach(validationKey => {
-      var _a, _b;
-      const error = validations[validationKey](this.value, schemaValidations);
+      const error = handleValidation(this.value, schemaValidations, validations, validationKey);
       // 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];
+      if (error && this.errorMessages) {
+        if (validationKey in this.errorMessages) {
+          const messages = this.errorMessages;
+          errors[validationKey] = messages[validationKey];
+        } else if ('default' in this.errorMessages) {
+          errors[validationKey] = this.errorMessages.default;
         }
+      } 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
-    });
-  }
-  /**
-   * WIP expensive function to get updated field validity on each event
-   */
-  updateValidityFlag() {
-    var _a;
-    let valid = true;
-    const schemaValidations = (_a = this.validations) === null || _a === void 0 ? void 0 : _a.config;
-    schemaValidations && Object.keys(schemaValidations).forEach(validationKey => {
-      const error = validations[validationKey](this.value, schemaValidations);
-      valid = !error && valid;
-    });
-    this._valid = valid;
+    if ((_c = (_b = this.validations) === null || _b === void 0 ? void 0 : _b.eventMessages) === null || _c === void 0 ? void 0 : _c[event]) {
+      const eventMessages = {};
+      (_d = this.validations.eventMessages[event]) === null || _d === void 0 ? void 0 : _d.forEach(method => {
+        if (method in errors) {
+          eventMessages[method] = errors[method];
+        }
+      });
+      this.errors = eventMessages;
+    } else if (event === 'ON_FORM_SUBMIT') {
+      this.errors = errors;
+    }
   }
   /**
    * Formats the field value using the specified formatters, if available.
@@ -2712,7 +2859,7 @@ class FormField {
     let valid = true;
     const preConditions = config.preConditions;
     preConditions && Object.keys(preConditions).forEach(validationKey => {
-      const error = validations[validationKey](this.value, preConditions);
+      const error = handleValidation(this.value, preConditions, validations, validationKey);
       valid = valid && !error;
     });
     if (config.blockRequestWhenInvalid) {
@@ -2808,6 +2955,7 @@ class FormField {
    * @returns {void}
    */
   destroyField() {
+    this._mounted = false;
     this.valueSubject$.unsubscribe();
     this.visibilitySubject$.unsubscribe();
     this.fieldStateSubscription$.unsubscribe();
@@ -2854,26 +3002,29 @@ class FormCore {
    * @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;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    this.mappers = new Map();
     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.config = entry.config;
-    this.mappers = entry.mappers;
+    this.config = {
+      defaultAPIdebounceTimeMS: Number((_e = entry.config) === null || _e === void 0 ? void 0 : _e.defaultAPIdebounceTimeMS) ? Number((_f = entry.config) === null || _f === void 0 ? void 0 : _f.defaultAPIdebounceTimeMS) : DEFAULT_API_DEBOUNCE_TIME,
+      defaultStateRefreshTimeMS: Number((_g = entry.config) === null || _g === void 0 ? void 0 : _g.defaultStateRefreshTimeMS) ? Number((_h = entry.config) === null || _h === void 0 ? void 0 : _h.defaultStateRefreshTimeMS) : DEFAULT_STATE_REFRESH_TIME
+    };
+    (_j = entry.mappers) === null || _j === void 0 ? void 0 : _j.map(mapper => {
+      this.mappers.set(mapper.componentName, mapper);
+    });
     this.schema && FormCore.checkIndexes(this.schema.components);
     this.templateSubject$ = new Subject();
     this.submitSubject$ = new Subject();
-    this.apiResponseSubject$ = new Subject();
+    this.fieldEventSubject$ = new Subject();
     this.dataSubject$ = new Subject();
-    this.dataCallbackSubscription$ = new Subscription();
     this.subscribedTemplates = [];
     this.schema && this.serializeStructure(this.schema.components);
     this.schema && this.subscribeTemplates();
@@ -2882,8 +3033,6 @@ class FormCore {
       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
@@ -2934,20 +3083,17 @@ class FormCore {
    * 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.subscribedTemplates = [];
     this.fields.forEach(({
-      component,
-      props,
-      name,
-      validations,
-      visibilityConditions,
-      resetValues,
-      errorMessages,
-      apiSchema,
-      metadata
+      originalSchema: {
+        component,
+        props,
+        name,
+        validations,
+        visibilityConditions,
+        resetValues,
+        api
+      }
     }, key) => {
       const template = {
         component,
@@ -2956,28 +3102,10 @@ class FormCore {
         validations,
         visibilityConditions,
         resetValues,
-        errorMessages,
-        apiSchema,
-        metadata
+        apiSchema: api
       };
       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) {
-    var _a, _b;
-    this.dataCallbackSubscription$ = this.dataSubject$.pipe(debounceTime(Number((_a = this.config) === null || _a === void 0 ? void 0 : _a.defaultStateRefreshTimeMS) ? Number((_b = this.config) === null || _b === void 0 ? void 0 : _b.defaultStateRefreshTimeMS) : 100), map(({
-      key
-    }) => ({
-      field: key,
-      data: this.getFormValues()
-    }))).subscribe({
-      next: callback
-    });
   }
   /**
    * Gets the value of a property from a field.
@@ -2997,8 +3125,12 @@ class FormCore {
       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];
+    const field = this.fields.get(key);
+    if (!field) return console.warn(`failed to get value from ${key}`);
+    if (property === 'props' && path[0] === field.valuePropName) {
+      return field.stateValue;
+    }
+    return path.length > 0 ? get(field[property], path) : field[property];
   }
   /**
    * Sets the value of a property in a field.
@@ -3031,7 +3163,6 @@ class FormCore {
         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
@@ -3062,18 +3193,17 @@ class FormCore {
    * @returns {string[]} An array of extracted parameters.
    */
   extractParams(expression) {
-    const regex = /\${(.*?)}/g;
+    const regex = TEMPLATE_REGEX_DELIMITATOR;
     const extractedValues = [];
     let match;
     while (!isNil(match = regex.exec(expression))) {
       extractedValues.push(match[1]);
     }
-    const operatorRegex = /\s*(\|\||&&|!)\s*/g;
+    const operatorRegex = TEMPLATE_REGEX_OPERATOR_SPLITTER;
     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(/^\|\||&&|!$/)) {
+        if (curr.match(TEMPLATE_REGEX_OPERATOR_MATCHER)) {
           return `${acc}${curr}`;
         }
         let value;
@@ -3104,6 +3234,11 @@ class FormCore {
           case 'object':
             if (currValue === null) {
               value = null;
+              break;
+            }
+            if (currValue instanceof Date) {
+              value = `new Date(\`${currValue}\`)`;
+              break;
             }
             value = JSON.stringify(currValue);
             break;
@@ -3115,7 +3250,6 @@ class FormCore {
     });
     return result.map(el => {
       try {
-        // console.log(el);
         return new Function(`return ${el}`)();
       } catch (e) {
         console.log(e);
@@ -3131,8 +3265,8 @@ class FormCore {
    * @returns {string} The expression string with the replacements made.
    */
   replaceExpression(expression, values) {
-    const regex = /\${(.*?)}/g;
-    return expression.replace(regex, () => values.shift() || '');
+    const regex = TEMPLATE_REGEX_DELIMITATOR;
+    return expression.replace(regex, () => String(values.shift()) || '');
   }
   /**
    * Checks if an expression string contains string concatenation within a marked expression.
@@ -3188,34 +3322,6 @@ class FormCore {
       }
     });
   }
-  /**
-   * 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.
    *
@@ -3233,13 +3339,13 @@ class FormCore {
     structVisibility.forEach(structElement => {
       if (!structElement.events.includes(event)) return;
       Object.keys(structElement.validations).forEach(validationKey => {
-        const error = validations[validationKey](field.value, structElement.validations);
+        const error = handleValidation(field.value, structElement.validations, validations, validationKey);
         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;
+            if (!this.fields.has(fieldKey)) console.warn(`failed to update visibility onto field ${fieldKey}`);else this.fields.get(fieldKey).visibility = structElement.showOnlyIfTrue ? error : !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;
+          if (!this.fields.has(structElement.fields)) console.warn(`failed to update visibility onto field ${structElement.fields}`);else this.fields.get(structElement.fields).visibility = structElement.showOnlyIfTrue ? error : !error;
         }
       });
     });
@@ -3261,7 +3367,7 @@ class FormCore {
     structResetValue.forEach(structElement => {
       if (!structElement.events.includes(event)) return;
       Object.keys(structElement.validations).forEach(validationKey => {
-        const error = validations[validationKey](field.value, structElement.validations);
+        const error = handleValidation(field.value, structElement.validations, validations, validationKey);
         if (!error) {
           if (Array.isArray(structElement.fields)) {
             structElement.fields.forEach((fieldKey, index) => {
@@ -3281,6 +3387,54 @@ class FormCore {
       });
     });
   }
+  /**
+   * Adds a field onto the form instance regardless there is a schema or not
+   *
+   * @param fieldSchema
+   */
+  addField({
+    fieldSchema,
+    mapperElement
+  }) {
+    var _a, _b, _c;
+    if (this.fields.has(fieldSchema.name)) {
+      throw new Error(`field name ${fieldSchema.name} already defined`);
+    }
+    const mapper = mapperElement || ((_a = this.mappers) === null || _a === void 0 ? void 0 : _a.get(fieldSchema.component));
+    if (!mapper) throw new Error(`mapper not found for ${fieldSchema.component}, add it to the mappers configuration`);
+    this.fields.set(fieldSchema.name, new FormField({
+      schemaComponent: fieldSchema,
+      mapper,
+      children: fieldSchema.children ? fieldSchema.children.map(el => el.name) : [],
+      validateVisibility: this.validateVisibility.bind(this),
+      resetValue: this.resetValue.bind(this),
+      initialValue: (_b = this.initialValues) === null || _b === void 0 ? void 0 : _b[fieldSchema.name],
+      templateSubject$: this.templateSubject$,
+      fieldEventSubject$: this.fieldEventSubject$,
+      dataSubject$: this.dataSubject$,
+      config: this.config
+    }));
+    this.subscribeTemplates();
+    this.refreshTemplates({
+      event: 'ON_FIELDS',
+      key: fieldSchema.name
+    });
+    (_c = this.fields.get(fieldSchema.name)) === null || _c === void 0 ? void 0 : _c.emitEvents({
+      event: 'ON_FIELD_MOUNT'
+    });
+  }
+  removeField({
+    key
+  }) {
+    var _a;
+    (_a = this.fields.get(key)) === null || _a === void 0 ? void 0 : _a.destroyField();
+    this.fields.delete(key);
+    this.subscribeTemplates();
+    this.templateSubject$.next({
+      key,
+      event: 'ON_FIELDS'
+    });
+  }
   /**
    * Serializes the schema structure to create form fields.
    *
@@ -3290,10 +3444,15 @@ class FormCore {
   serializeStructure(struct, path) {
     if (!struct) return;
     struct.forEach(structElement => {
-      var _a, _b;
+      var _a, _b, _c;
       const currField = this.fields.get(structElement.name);
       if (!currField) {
-        const mapper = this.mappers.find(mapEl => mapEl.componentName === structElement.component);
+        let mapper;
+        if (structElement === null || structElement === void 0 ? void 0 : structElement.mapper) {
+          mapper = structElement === null || structElement === void 0 ? void 0 : structElement.mapper;
+        } else {
+          mapper = (_a = this.mappers) === null || _a === void 0 ? void 0 : _a.get(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,
@@ -3302,19 +3461,20 @@ class FormCore {
           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],
+          initialValue: (_b = this.initialValues) === null || _b === void 0 ? void 0 : _b[structElement.name],
           templateSubject$: this.templateSubject$,
-          apiResponseSubject$: this.apiResponseSubject$,
+          fieldEventSubject$: this.fieldEventSubject$,
           dataSubject$: this.dataSubject$,
           config: this.config
         }));
       } 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.children = ((_c = structElement === null || structElement === void 0 ? void 0 : structElement.children) === null || _c === void 0 ? void 0 : _c.map(el => el.name)) || (currField === null || currField === void 0 ? void 0 : currField.children) || [];
         currField.path = path;
+        currField.originalSchema = structElement;
         currField.templateSubject$ = this.templateSubject$;
       }
       if (structElement.children) {
-        return this.serializeStructure(structElement.children, `${path ? `${path}.` : ``}${structElement.name}`);
+        this.serializeStructure(structElement.children, `${path ? `${path}.` : ``}${structElement.name}`);
       }
     });
   }
@@ -3371,7 +3531,7 @@ class FormCore {
     const values = {};
     this.fields.forEach((val, key) => {
       if (val.value) {
-        values[key] = val.value;
+        set(values, val.nameToSubmit || key, val.value);
       }
     });
     console.log(values);
@@ -3386,7 +3546,7 @@ class FormCore {
     const erroredFields = [];
     this.fields.forEach((val, key) => {
       if (val.value) {
-        values[key] = val.value;
+        set(values, val.nameToSubmit || key, val.value);
       }
       if (!val.valid) {
         erroredFields.push(key);
@@ -3398,6 +3558,35 @@ class FormCore {
       isValid: this.isValid
     };
   }
+  subscribeFieldEvent({
+    callback
+  }) {
+    const sub = this.fieldEventSubject$.pipe(groupBy(payload => payload.event), mergeMap(group$ => group$.pipe(debounceTime(this.config.defaultStateRefreshTimeMS)))).subscribe({
+      next: callback
+    });
+    return sub;
+  }
+  /**
+   *
+   * @param {(payload: { field: string; data: TFormValues }) => void} callback callback function to call on data
+   */
+  subscribeData(callback) {
+    const sub = this.dataSubject$.pipe(groupBy(payload => payload.event), mergeMap(group$ => group$.pipe(debounceTime(this.config.defaultStateRefreshTimeMS))), map(({
+      key
+    }) => ({
+      field: key,
+      data: this.getFormValues()
+    }))).subscribe({
+      next: callback
+    });
+    return sub;
+  }
+  subscribeOnSubmit(callback) {
+    const sub = this.submitSubject$.pipe(map(() => this.getFormValues())).subscribe({
+      next: callback
+    });
+    return sub;
+  }
   /**
    * Submits the form by triggering form field events and invoking the onSubmit callback.
    */
@@ -3410,12 +3599,11 @@ class FormCore {
     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.fieldEventSubject$.unsubscribe();
     this.dataSubject$.unsubscribe();
     this.fields.forEach(field => field.destroyField());
   }
@@ -3431,15 +3619,22 @@ class FormCore {
  */
 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);
+  const helper = (struct, 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) {
+        helper(structElement.children, indexes);
+      }
     }
+  };
+  helper(struct, indexes);
+  const duppedIndexes = indexes.filter((item, index) => indexes.indexOf(item) !== index);
+  if (duppedIndexes.length > 0) {
+    throw new Error(`duplicated indexes found on schema: ${JSON.stringify(duppedIndexes)}`);
   }
   return indexes;
 };
@@ -3454,6 +3649,25 @@ class FormGroup {
   constructor() {
     this.forms = new Map();
   }
+  /**
+   * Creates an empty form with given index
+   *
+   * @param {string} options.index
+   * @param {TMapper<unknown>} options.mappers
+   */
+  createFormWithIndex({
+    index,
+    mappers
+  }) {
+    const formInstance = new FormCore({
+      index,
+      mappers
+    });
+    this.addForm({
+      key: index,
+      formInstance
+    });
+  }
   /**
    * Adds a form instance to the form group.
    *
@@ -3496,6 +3710,20 @@ class FormGroup {
     (_a = this.forms.get(key)) === null || _a === void 0 ? void 0 : _a.destroy();
     this.forms.delete(key);
   }
+  /**
+   * removes a field given a form and field index
+   *
+   * @param {string} options.formIndex
+   * @param {string} options.fieldIndex
+   */
+  removeField({
+    formIndex,
+    fieldIndex
+  }) {
+    var _a, _b, _c;
+    (_b = (_a = this.forms.get(formIndex)) === null || _a === void 0 ? void 0 : _a.fields.get(fieldIndex)) === null || _b === void 0 ? void 0 : _b.destroyField();
+    (_c = this.forms.get(formIndex)) === null || _c === void 0 ? void 0 : _c.fields.delete(fieldIndex);
+  }
   /**
    * Checks if the specified key already exists in the form group.
    *
@@ -3521,22 +3749,49 @@ class FormGroup {
    * @param {string[]} indexes form indexes to be submitted
    * @returns
    */
-  submitMultipleFormsByIndex(indexes) {
+  submitMultipleFormsByIndex(indexes, callback) {
     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();
+      var _a, _b;
+      (_a = this.forms.get(index)) === null || _a === void 0 ? void 0 : _a.submit();
+      const res = (_b = this.forms.get(index)) === null || _b === void 0 ? void 0 : _b.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 {
+    isValid && callback && callback({
       erroredFields,
       isValid,
       values
-    };
+    });
+  }
+  onDataSubscription({
+    ids,
+    callback
+  }) {
+    const subs = ids.reduce((acc, formId) => {
+      var _a;
+      // @TODO add config on debounceTime on this events
+      const sub = (_a = this.forms.get(formId)) === null || _a === void 0 ? void 0 : _a.dataSubject$.pipe(groupBy(payload => `${formId}.${payload.event}`), mergeMap(group$ => group$.pipe(debounceTime(100))), map(({
+        key
+      }) => {
+        var _a;
+        return {
+          formField: key,
+          values: (_a = this.forms.get(formId)) === null || _a === void 0 ? void 0 : _a.getFormValues()
+        };
+      }));
+      if (sub) {
+        acc[formId] = sub;
+      } else {
+        console.warn(`failed to register form id ${formId}`);
+      }
+      return acc;
+    }, {});
+    const sub = combineLatest(subs).subscribe(callback);
+    return sub;
   }
 }