@xlabs-store/core 0.0.1 → 0.0.3

package/dist/cjs/{schema-builder-CYnX7lKi.js → schema-builder-DAwDwgIM.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var locale_service = require('./locale.service-Cz-aZQnr.js');
+var locale_service = require('./locale.service-DT6E8Rzd.js');
 
 class ValueUtil {
     static number(value) {
@@ -92,12 +92,26 @@ function evaluateCondition(condition, formValues, context) {
     const result = (() => {
         switch (operator) {
             case 'equals':
+                if ((typeof actualValue === 'string' && typeof expectedValue === 'number') ||
+                    (typeof actualValue === 'number' && typeof expectedValue === 'string')) {
+                    return String(actualValue) === String(expectedValue);
+                }
                 return actualValue === expectedValue;
             case 'notEquals':
+                if ((typeof actualValue === 'string' && typeof expectedValue === 'number') ||
+                    (typeof actualValue === 'number' && typeof expectedValue === 'string')) {
+                    return String(actualValue) !== String(expectedValue);
+                }
                 return actualValue !== expectedValue;
             case 'contains':
                 if (Array.isArray(actualValue)) {
-                    return actualValue.includes(expectedValue);
+                    return actualValue.some(item => {
+                        if ((typeof item === 'string' && typeof expectedValue === 'number') ||
+                            (typeof item === 'number' && typeof expectedValue === 'string')) {
+                            return String(item) === String(expectedValue);
+                        }
+                        return item === expectedValue;
+                    });
                 }
                 if (typeof actualValue === 'string') {
                     return actualValue.includes(String(expectedValue));
@@ -105,7 +119,13 @@ function evaluateCondition(condition, formValues, context) {
                 return false;
             case 'notContains':
                 if (Array.isArray(actualValue)) {
-                    return !actualValue.includes(expectedValue);
+                    return !actualValue.some(item => {
+                        if ((typeof item === 'string' && typeof expectedValue === 'number') ||
+                            (typeof item === 'number' && typeof expectedValue === 'string')) {
+                            return String(item) === String(expectedValue);
+                        }
+                        return item === expectedValue;
+                    });
                 }
                 if (typeof actualValue === 'string') {
                     return !actualValue.includes(String(expectedValue));
@@ -121,34 +141,56 @@ function evaluateCondition(condition, formValues, context) {
                 return Number(actualValue) <= Number(expectedValue);
             case 'isNotEmpty':
             case 'notEmpty':
-                return (actualValue !== null &&
-                    actualValue !== undefined &&
-                    actualValue !== '' &&
-                    !(Array.isArray(actualValue) && actualValue.length === 0));
+                return actualValue !== null && actualValue !== undefined && actualValue !== '' && !(Array.isArray(actualValue) && actualValue.length === 0);
             case 'isEmpty':
             case 'empty':
-                return (actualValue === null ||
-                    actualValue === undefined ||
-                    actualValue === '' ||
-                    (Array.isArray(actualValue) && actualValue.length === 0));
+                return actualValue === null || actualValue === undefined || actualValue === '' || (Array.isArray(actualValue) && actualValue.length === 0);
             case 'startsWith':
                 return String(actualValue).startsWith(String(expectedValue));
             case 'endsWith':
                 return String(actualValue).endsWith(String(expectedValue));
             case 'in':
                 if (Array.isArray(expectedValue)) {
-                    return expectedValue.includes(actualValue);
+                    return expectedValue.some(item => {
+                        if ((typeof item === 'string' && typeof actualValue === 'number') ||
+                            (typeof item === 'number' && typeof actualValue === 'string')) {
+                            return String(item) === String(actualValue);
+                        }
+                        return item === actualValue;
+                    });
                 }
                 if (typeof expectedValue === 'string') {
-                    return expectedValue.split(',').map(v => v.trim()).includes(String(actualValue));
+                    return expectedValue
+                        .split(',')
+                        .map(v => v.trim())
+                        .some(item => {
+                        if (typeof actualValue === 'number') {
+                            return item === String(actualValue);
+                        }
+                        return item === actualValue;
+                    });
                 }
                 return false;
             case 'notIn':
                 if (Array.isArray(expectedValue)) {
-                    return !expectedValue.includes(actualValue);
+                    return !expectedValue.some(item => {
+                        if ((typeof item === 'string' && typeof actualValue === 'number') ||
+                            (typeof item === 'number' && typeof actualValue === 'string')) {
+                            return String(item) === String(actualValue);
+                        }
+                        return item === actualValue;
+                    });
                 }
                 if (typeof expectedValue === 'string') {
-                    return !expectedValue.split(',').map(v => v.trim()).includes(String(actualValue));
+                    return !expectedValue
+                        .split(',')
+                        .map(v => v.trim())
+                        .some(item => {
+                        if (typeof actualValue === 'number') {
+                            return item === String(actualValue);
+                        }
+                        return item === actualValue;
+                    });
                 }
                 return true;
             default:
@@ -179,16 +221,30 @@ class ConditionOperators {
     }
     equals(option, field, value) {
         value = ValueUtil.detect(field, value);
+        if ((typeof value === 'string' && typeof option.value === 'number') ||
+            (typeof value === 'number' && typeof option.value === 'string')) {
+            return String(value) === String(option.value);
+        }
         return option.value === value;
     }
     notEquals(option, field, value) {
         value = ValueUtil.detect(field, value);
+        if ((typeof value === 'string' && typeof option.value === 'number') ||
+            (typeof value === 'number' && typeof option.value === 'string')) {
+            return String(value) !== String(option.value);
+        }
         return option.value !== value;
     }
     contains(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (Array.isArray(value)) {
-            return value.includes(option.value);
+            return value.some(item => {
+                if ((typeof item === 'string' && typeof option.value === 'number') ||
+                    (typeof item === 'number' && typeof option.value === 'string')) {
+                    return String(item) === String(option.value);
+                }
+                return item === option.value;
+            });
         }
         if (typeof value === 'string') {
             return value.includes(String(option.value));
@@ -198,9 +254,7 @@ class ConditionOperators {
     greaterThan(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (typeof value === 'number') {
-            const cmp = typeof option.value === 'number'
-                ? option.value
-                : Number(option.value ?? NaN);
+            const cmp = typeof option.value === 'number' ? option.value : Number(option.value ?? NaN);
             return Number.isFinite(cmp) ? value > cmp : false;
         }
         return false;
@@ -208,29 +262,29 @@ class ConditionOperators {
     lessThan(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (typeof value === 'number') {
-            const cmp = typeof option.value === 'number'
-                ? option.value
-                : Number(option.value ?? NaN);
+            const cmp = typeof option.value === 'number' ? option.value : Number(option.value ?? NaN);
             return Number.isFinite(cmp) ? value < cmp : false;
         }
         return false;
     }
     isEmpty(_option, field, value) {
         value = ValueUtil.detect(field, value);
-        return (value == null ||
-            value === '' ||
-            (Array.isArray(value) && value.length === 0));
+        return value == null || value === '' || (Array.isArray(value) && value.length === 0);
     }
     isNotEmpty(_option, field, value) {
         value = ValueUtil.detect(field, value);
-        return !(value == null ||
-            value === '' ||
-            (Array.isArray(value) && value.length === 0));
+        return !(value == null || value === '' || (Array.isArray(value) && value.length === 0));
     }
     notContains(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (Array.isArray(value)) {
-            return !value.includes(option.value);
+            return !value.some(item => {
+                if ((typeof item === 'string' && typeof option.value === 'number') ||
+                    (typeof item === 'number' && typeof option.value === 'string')) {
+                    return String(item) === String(option.value);
+                }
+                return item === option.value;
+            });
         }
         if (typeof value === 'string') {
             return !value.includes(String(option.value));
@@ -240,9 +294,7 @@ class ConditionOperators {
     greaterThanOrEqual(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (typeof value === 'number') {
-            const cmp = typeof option.value === 'number'
-                ? option.value
-                : Number(option.value ?? NaN);
+            const cmp = typeof option.value === 'number' ? option.value : Number(option.value ?? NaN);
             return Number.isFinite(cmp) ? value >= cmp : false;
         }
         return false;
@@ -250,9 +302,7 @@ class ConditionOperators {
     lessThanOrEqual(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (typeof value === 'number') {
-            const cmp = typeof option.value === 'number'
-                ? option.value
-                : Number(option.value ?? NaN);
+            const cmp = typeof option.value === 'number' ? option.value : Number(option.value ?? NaN);
             return Number.isFinite(cmp) ? value <= cmp : false;
         }
         return false;
@@ -274,26 +324,48 @@ class ConditionOperators {
     in(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (Array.isArray(option.value)) {
-            return option.value.includes(value);
+            return option.value.some(item => {
+                if ((typeof item === 'string' && typeof value === 'number') ||
+                    (typeof item === 'number' && typeof value === 'string')) {
+                    return String(item) === String(value);
+                }
+                return item === value;
+            });
         }
         if (typeof option.value === 'string') {
             return option.value
                 .split(',')
-                .map((v) => v.trim())
-                .includes(String(value));
+                .map(v => v.trim())
+                .some(item => {
+                if (typeof value === 'number') {
+                    return item === String(value);
+                }
+                return item === value;
+            });
         }
         return false;
     }
     notIn(option, field, value) {
         value = ValueUtil.detect(field, value);
         if (Array.isArray(option.value)) {
-            return !option.value.includes(value);
+            return !option.value.some(item => {
+                if ((typeof item === 'string' && typeof value === 'number') ||
+                    (typeof item === 'number' && typeof value === 'string')) {
+                    return String(item) === String(value);
+                }
+                return item === value;
+            });
         }
         if (typeof option.value === 'string') {
             return !option.value
                 .split(',')
-                .map((v) => v.trim())
-                .includes(String(value));
+                .map(v => v.trim())
+                .some(item => {
+                if (typeof value === 'number') {
+                    return item === String(value);
+                }
+                return item === value;
+            });
         }
         return true;
     }
@@ -325,12 +397,12 @@ class ConditionBuilder extends ConditionOperators {
     }
     checkAll() {
         this.isCheckingAll = true;
-        this.executors.forEach((executor) => executor());
+        this.executors.forEach(executor => executor());
         this.isCheckingAll = false;
         this.builder.notifySubscribers();
     }
     extract() {
-        this.conditions.forEach((cond) => {
+        this.conditions.forEach(cond => {
             if ('when' in cond) {
                 this.advanced(cond);
             }
@@ -362,14 +434,12 @@ class ConditionBuilder extends ConditionOperators {
         const executor = () => {
             const values = this.getEvaluationValues();
             this.builder.callEvent('beforeConditionCheck', option, values);
-            const statuses = option.conditions.map((cond) => {
+            const statuses = option.conditions.map(cond => {
                 return this.run(cond, values, this.builder.context);
             });
-            const groupStatus = option.operator === 'and'
-                ? statuses.every(Boolean)
-                : statuses.some(Boolean);
+            const groupStatus = option.operator === 'and' ? statuses.every(Boolean) : statuses.some(Boolean);
             if (groupStatus) {
-                option.actions.forEach((action) => {
+                option.actions.forEach(action => {
                     this.execute(action.action, action.actionField);
                 });
             }
@@ -378,11 +448,11 @@ class ConditionBuilder extends ConditionOperators {
                 this.builder.notifySubscribers();
             }
         };
-        option.conditions.forEach((cond) => {
+        option.conditions.forEach(cond => {
             const field = this.form.mapping.get(cond.field);
             if (field && 'control' in field && field.control) {
                 const control = field.control;
-                control.subscribe((_val) => executor());
+                control.subscribe(_val => executor());
             }
         });
         this.executors.push(executor);
@@ -392,9 +462,8 @@ class ConditionBuilder extends ConditionOperators {
         const executor = () => {
             const values = this.getEvaluationValues();
             this.builder.callEvent('beforeConditionCheck', option, values);
-            const results = option.when.rules.map((rule) => {
-                const field = this.form.mappingById.get(rule.field) ??
-                    this.form.mapping.get(rule.field);
+            const results = option.when.rules.map(rule => {
+                const field = this.form.mappingById.get(rule.field) ?? this.form.mapping.get(rule.field);
                 if (field || rule.field?.startsWith('$')) {
                     const mockCond = {
                         id: option.id,
@@ -402,19 +471,18 @@ class ConditionBuilder extends ConditionOperators {
                         condition: rule.operator,
                         value: rule.value,
                         action: 'show',
-                        actionField: 'none'
+                        actionField: 'none',
                     };
                     return this.run(mockCond, values, this.builder.context);
                 }
                 return false;
             });
             const isMatch = option.when.operator === 'or' ? results.some(Boolean) : results.every(Boolean);
-            const actions = isMatch ? option.then : (option.else || []);
-            actions.forEach((action) => {
-                const targetField = this.form.mappingById.get(action.target) ??
-                    this.form.mapping.get(action.target);
+            const actions = isMatch ? option.then : option.else || [];
+            actions.forEach(action => {
+                const targetField = this.form.mappingById.get(action.target) ?? this.form.mapping.get(action.target);
                 // If targetField found, use its id as key to execute (execute will resolve correctly)
-                const targetKey = targetField ? (targetField.id || targetField.name) : action.target;
+                const targetKey = targetField ? targetField.id || targetField.name : action.target;
                 this.execute(action.action, targetKey, action.value);
             });
             this.builder.callEvent('afterConditionCheck', option, values, isMatch);
@@ -422,9 +490,8 @@ class ConditionBuilder extends ConditionOperators {
                 this.builder.notifySubscribers();
             }
         };
-        option.when.rules.forEach((rule) => {
-            const field = this.form.mappingById.get(rule.field) ??
-                this.form.mapping.get(rule.field);
+        option.when.rules.forEach(rule => {
+            const field = this.form.mappingById.get(rule.field) ?? this.form.mapping.get(rule.field);
             if (field && 'control' in field && field.control) {
                 field.control.subscribe(() => executor());
             }
@@ -456,9 +523,7 @@ class ConditionBuilder extends ConditionOperators {
         executor();
     }
     execute(action, actionField, value) {
-        const actionFieldIds = actionField === 'all'
-            ? Array.from(this.form.mapping.keys())
-            : [actionField];
+        const actionFieldIds = actionField === 'all' ? Array.from(this.form.mapping.keys()) : [actionField];
         for (const fieldId of actionFieldIds) {
             const field = this.form.mappingById.get(fieldId) || this.form.mapping.get(fieldId);
             console.log(`[ConditionEngine] Executing action '${action}' on field '${fieldId}'. Field found:`, !!field, 'Value:', value);
@@ -494,6 +559,121 @@ class ConditionBuilder extends ConditionOperators {
     }
 }
 
+/**
+ * FormulaBuilder - Handles automatic calculations for number fields
+ * Support formulas like "$width * $height" or "$price * $quantity * (1 - $discount/100)"
+ */
+class FormulaBuilder {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+        this.extract();
+    }
+    /**
+     * Scan schema for fields with formula property
+     */
+    extract() {
+        const fields = Array.from(this.builder.form.mapping.values());
+        fields.forEach(field => {
+            // We only support number type for now as requested
+            if (field.type === 'number' && field.formula) {
+                this.setupFormula(field);
+            }
+        });
+    }
+    /**
+     * Setup subscription and calculation for a field
+     */
+    setupFormula(field) {
+        const formula = field.formula;
+        const depNames = this.getDependencies(formula);
+        const recalculate = () => {
+            const values = this.getEvaluationValues();
+            const result = this.evaluate(formula, values);
+            const control = field.control;
+            if (control && control.value !== result) {
+                control.setValue(result);
+            }
+        };
+        // Track which fields we've already subscribed to for this formula
+        const subscribed = new Set();
+        depNames.forEach(name => {
+            if (subscribed.has(name))
+                return;
+            const depField = this.builder.form.mappingById.get(name) || this.builder.form.mapping.get(name);
+            if (depField && depField.control) {
+                depField.control.subscribe(() => {
+                    recalculate();
+                });
+                subscribed.add(name);
+            }
+        });
+        // Initial calculation
+        setTimeout(() => recalculate(), 0);
+    }
+    /**
+     * Extract field names/ids from formula (prefixed with $)
+     */
+    getDependencies(formula) {
+        // Matches $name or $$id
+        const matches = formula.match(/[\$]{1,2}[a-zA-Z0-9_-]+/g) || [];
+        return matches.map(m => m.replace(/^[\$]{1,2}/, ''));
+    }
+    /**
+     * Helper to get all current values for evaluation
+     */
+    getEvaluationValues() {
+        const values = {};
+        // Map values by both Name and ID to support both in formulas
+        this.builder.form.mappingById.forEach((field, id) => {
+            if (field.control) {
+                values[id] = field.control.value;
+            }
+        });
+        this.builder.form.mapping.forEach((field, name) => {
+            if (field.control) {
+                values[name] = field.control.value;
+            }
+        });
+        return values;
+    }
+    /**
+     * Evaluate the formula string
+     */
+    evaluate(formula, values) {
+        try {
+            let expression = formula;
+            const depNames = this.getDependencies(formula);
+            // Sort dependencies by length descending to avoid partial replacements
+            // e.g., if we have $val and $value, replace $value first.
+            depNames.sort((a, b) => b.length - a.length);
+            depNames.forEach(name => {
+                const val = values[name] !== undefined ? values[name] : 0;
+                // Match $name or $$name but only as whole words (handle non-word chars after name)
+                // We escape special regex characters in the name if any.
+                const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const regex = new RegExp(`\\$[\\$]?${escapedName}(\\b|[^a-zA-Z0-9_-])`, 'g');
+                expression = expression.replace(regex, (_match, suffix) => {
+                    return String(val || 0) + (suffix || '');
+                });
+            });
+            // Basic safety: only allow numbers, math operators, dot, and parentheses
+            const safeExpression = expression.replace(/[^0-9\+\-\*\/\(\)\. ]/g, '');
+            if (!safeExpression.trim())
+                return 0;
+            // Use Function for execution
+            // eslint-disable-next-line no-new-func
+            const result = new Function(`return ${safeExpression}`)();
+            const numResult = Number(result);
+            return isFinite(numResult) ? numResult : 0;
+        }
+        catch (e) {
+            console.warn('Formula Evaluation Error:', e, 'Formula:', formula);
+            return 0;
+        }
+    }
+}
+
 class AbstractControl {
     _value;
     _errors = null;
@@ -718,7 +898,7 @@ class FormArray extends AbstractControl {
         }
         super(validators, asyncValidatorsList);
         this._controls = controls;
-        controls.forEach((control) => {
+        controls.forEach(control => {
             control.setParent(this);
         });
         this.updateValueAndValidity({ emitEvent: false });
@@ -727,9 +907,7 @@ class FormArray extends AbstractControl {
         return this._controls;
     }
     get value() {
-        return this._controls
-            .filter((control) => !control.disabled)
-            .map((control) => control.value);
+        return this._controls.filter(control => !control.disabled).map(control => control.value);
     }
     get length() {
         return this._controls.length;
@@ -791,7 +969,7 @@ class FormArray extends AbstractControl {
         this.updateValueAndValidity(options);
     }
     getRawValue() {
-        return this._controls.map((control) => control.value);
+        return this._controls.map(control => control.value);
     }
 }
 
@@ -810,7 +988,7 @@ class FormGroup extends AbstractControl {
         }
         super(validators, asyncValidatorsList);
         this._controls = controls;
-        Object.values(controls).forEach((control) => {
+        Object.values(controls).forEach(control => {
             control.setParent(this);
         });
         this.updateValueAndValidity({ emitEvent: false });
@@ -820,7 +998,7 @@ class FormGroup extends AbstractControl {
     }
     get value() {
         const value = {};
-        Object.keys(this._controls).forEach((key) => {
+        Object.keys(this._controls).forEach(key => {
             const control = this._controls[key];
             if (!control.disabled) {
                 value[key] = control.value;
@@ -829,7 +1007,7 @@ class FormGroup extends AbstractControl {
         return value;
     }
     setValue(value, options = {}) {
-        Object.keys(value).forEach((key) => {
+        Object.keys(value).forEach(key => {
             if (!this._controls[key]) {
                 throw new Error(`Cannot find form control with name: ${key}`);
             }
@@ -839,7 +1017,7 @@ class FormGroup extends AbstractControl {
         this.updateValueAndValidity(options);
     }
     patchValue(value, options = {}) {
-        Object.keys(value).forEach((key) => {
+        Object.keys(value).forEach(key => {
             if (this._controls[key]) {
                 this._controls[key].patchValue(value[key], { emitEvent: false });
             }
@@ -847,7 +1025,7 @@ class FormGroup extends AbstractControl {
         this.updateValueAndValidity(options);
     }
     reset(value = {}, options = {}) {
-        Object.keys(this._controls).forEach((key) => {
+        Object.keys(this._controls).forEach(key => {
             this._controls[key].reset(value[key], { emitEvent: false });
         });
         this.markAsPristine();
@@ -937,7 +1115,7 @@ class FormGroup extends AbstractControl {
     }
     getRawValue() {
         const value = {};
-        Object.keys(this._controls).forEach((key) => {
+        Object.keys(this._controls).forEach(key => {
             value[key] = this._controls[key].value;
         });
         return value;
@@ -947,8 +1125,7 @@ class FormGroup extends AbstractControl {
 class Validators {
     static required(control) {
         const value = control.value;
-        if (value === null || value === undefined || value === '' ||
-            (Array.isArray(value) && value.length === 0)) {
+        if (value === null || value === undefined || value === '' || (Array.isArray(value) && value.length === 0)) {
             return { required: true };
         }
         return null;
@@ -975,20 +1152,18 @@ class Validators {
     }
     static minLength(minLength) {
         return (control) => {
-            if (!control.value || typeof control.value !== 'string')
+            if (control.value === null || control.value === undefined || control.value === '')
                 return null;
-            return control.value.length < minLength
-                ? { minLength: { minLength: minLength, actualLength: control.value.length } }
-                : null;
+            const value = String(control.value);
+            return value.length < minLength ? { minLength: { minLength: minLength, actualLength: value.length } } : null;
         };
     }
     static maxLength(maxLength) {
         return (control) => {
-            if (!control.value || typeof control.value !== 'string')
+            if (control.value === null || control.value === undefined || control.value === '')
                 return null;
-            return control.value.length > maxLength
-                ? { maxLength: { maxLength: maxLength, actualLength: control.value.length } }
-                : null;
+            const value = String(control.value);
+            return value.length > maxLength ? { maxLength: { maxLength: maxLength, actualLength: value.length } } : null;
         };
     }
     static pattern(pattern) {
@@ -1026,6 +1201,19 @@ class Validators {
         const num = Number(control.value);
         return !isNaN(num) ? null : { number: true };
     }
+    static sameAs(fieldName) {
+        return (control) => {
+            if (!control.value)
+                return null;
+            const parent = control.parent;
+            if (!parent || typeof parent.get !== 'function')
+                return null;
+            const targetControl = parent.get(fieldName);
+            if (!targetControl)
+                return null;
+            return control.value === targetControl.value ? null : { sameAs: { fieldName } };
+        };
+    }
 }
 
 class FormBuilder {
@@ -1156,12 +1344,22 @@ class Utils {
         if (field.hasSpecialChar) {
             validators.push(Validators.hasSpecialChar);
         }
+        if (field.type === 'number') {
+            const f = field;
+            if (f.numberType === 'integer') {
+                validators.push(Validators.integer);
+            }
+            else if (f.numberType === 'decimal') {
+                validators.push(Validators.number);
+            }
+        }
         // ── Structured validators array (new format) ──────────────────────────
         if (Array.isArray(field.validators) && field.validators.length > 0) {
             for (const cfg of field.validators) {
                 switch (cfg.type) {
                     case 'required':
-                        validators.push(Validators.required);
+                        if (!validators.includes(Validators.required))
+                            validators.push(Validators.required);
                         break;
                     case 'minLength':
                         if (!Utils.isEmpty(cfg.value))
@@ -1184,19 +1382,28 @@ class Utils {
                             validators.push(Validators.max(Number(cfg.value)));
                         break;
                     case 'hasUppercase':
-                        validators.push(Validators.hasUppercase);
+                        if (!validators.includes(Validators.hasUppercase))
+                            validators.push(Validators.hasUppercase);
                         break;
                     case 'hasNumber':
-                        validators.push(Validators.hasNumber);
+                        if (!validators.includes(Validators.hasNumber))
+                            validators.push(Validators.hasNumber);
                         break;
                     case 'hasSpecialChar':
-                        validators.push(Validators.hasSpecialChar);
+                        if (!validators.includes(Validators.hasSpecialChar))
+                            validators.push(Validators.hasSpecialChar);
                         break;
                     case 'integer':
-                        validators.push(Validators.integer);
+                        if (!validators.includes(Validators.integer))
+                            validators.push(Validators.integer);
                         break;
                     case 'number':
-                        validators.push(Validators.number);
+                        if (!validators.includes(Validators.number))
+                            validators.push(Validators.number);
+                        break;
+                    case 'sameAs':
+                        if (!Utils.isEmpty(cfg.value))
+                            validators.push(Validators.sameAs(cfg.value));
                         break;
                 }
             }
@@ -1280,19 +1487,40 @@ class FormMapping extends FormGroup {
                     // Safely merge Maps
                     child_paths.forEach((v, k) => paths.set(k, v));
                 }
+                // Support tabs and columns mapping recursively
+                if ((field.type === 'tabs' || String(field.type).startsWith('columns-')) && field.items && Array.isArray(field.items)) {
+                    for (const item of field.items) {
+                        if (item && Array.isArray(item.elements)) {
+                            const child_paths = mappingRecursive(item.elements);
+                            child_paths.forEach((v, k) => paths.set(k, v));
+                        }
+                    }
+                }
             }
             return paths;
         };
         // Support both 'elements' and 'fields' for compatibility
         const elements = this.schema?.elements || this.schema?.fields;
-        if (!elements || !Array.isArray(elements)) {
-            return new Map();
+        const actions = this.schema?.actions || [];
+        const paths = mappingRecursive(elements);
+        // Also map actions so they can be targeted by conditions
+        if (actions && Array.isArray(actions)) {
+            for (const action of actions) {
+                if (action.id) {
+                    this.mappingById.set(action.id, action);
+                    if (!action.id.startsWith('action-')) {
+                        paths.set(action.id, action);
+                    }
+                }
+            }
         }
-        return mappingRecursive(elements);
+        return paths;
     }
     toMappingObject() {
         const applyField = (root, field) => {
             const path = field.name;
+            if (!path)
+                return;
             const segments = path.split('.');
             let current = root;
             for (let i = 0; i < segments.length; i++) {
@@ -1354,7 +1582,7 @@ class FormMapping extends FormGroup {
                         }
                         const { control } = Utils.builderFromControl(field);
                         this.validateOnUseApi(field);
-                        control.subscribe((value) => {
+                        control.subscribe(value => {
                             this.builder.callEvent('onFieldChange', field.name, value);
                         });
                         formArray.push(control);
@@ -1383,10 +1611,14 @@ class FormMapping extends FormGroup {
                 const formGroup = root;
                 this.validateOnUseApi(field);
                 const { control } = Utils.builderFromControl(field);
-                control.subscribe((value) => {
+                control.subscribe(value => {
                     this.builder.callEvent('onFieldChange', field.name, value);
                 });
                 formGroup.addControl(key, control);
+                if (this.builder.showErrorCheckbox) {
+                    const errorControl = this.fb.control(false);
+                    formGroup.addControl(`isError_${field.name}`, errorControl);
+                }
             }
         }
     }
@@ -1405,6 +1637,56 @@ class FormMapping extends FormGroup {
     }
     onSubmit() { }
     onReset() { }
+    get value() {
+        const val = super.value;
+        this.cleanSubmitData(val);
+        return val;
+    }
+    getRawValue() {
+        const val = super.getRawValue();
+        this.cleanSubmitData(val);
+        return val;
+    }
+    cleanSubmitData(obj) {
+        if (!obj)
+            return;
+        for (const [_key, field] of Array.from(this.mapping.entries())) {
+            if (field && field.submitData === false && field.name) {
+                this.deletePath(obj, field.name);
+            }
+        }
+    }
+    deletePath(obj, path) {
+        if (!obj || !path)
+            return;
+        const segments = path.split('.');
+        let current = obj;
+        for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            if (seg.endsWith('[]')) {
+                const key = seg.replace('[]', '');
+                const arr = current[key];
+                if (Array.isArray(arr)) {
+                    const subPath = segments.slice(i + 1).join('.');
+                    arr.forEach(item => this.deletePath(item, subPath));
+                }
+                return;
+            }
+            else {
+                current = current[seg];
+                if (!current)
+                    return;
+            }
+        }
+        const lastSeg = segments[segments.length - 1];
+        if (lastSeg.endsWith('[]')) {
+            const key = lastSeg.replace('[]', '');
+            delete current[key];
+        }
+        else {
+            delete current[lastSeg];
+        }
+    }
 }
 
 class SchemaValidator {
@@ -1453,6 +1735,7 @@ class SchemaValidator {
 
 class SchemaBuilder {
     schema;
+    showErrorCheckbox = false;
     form;
     context = {};
     get fields() {
@@ -1466,14 +1749,17 @@ class SchemaBuilder {
         return this;
     }
     conditions;
-    constructor(schema) {
+    formulas;
+    constructor(schema, options = {}) {
         this.schema = schema;
+        this.showErrorCheckbox = !!options.showErrorCheckbox;
         this.form = new FormMapping(this);
         const schemaErrors = SchemaValidator.validate(this.schema);
         if (schemaErrors.length > 0) {
             console.error('SchemaBuilder Error: The provided schema is invalid.', schemaErrors);
         }
         this.conditions = new ConditionBuilder(this);
+        this.formulas = new FormulaBuilder(this);
         this.callEvent('onInit');
     }
     callEvent(name, ...args) {
@@ -1497,7 +1783,7 @@ class SchemaBuilder {
         return () => this._subscribers.delete(callback);
     }
     notifySubscribers() {
-        this._subscribers.forEach((callback) => callback(this.form.value));
+        this._subscribers.forEach(callback => callback(this.form.value));
     }
 }