@xlabs-store/core 0.0.1

package/dist/cjs/schema-builder-CYnX7lKi.js

@@ -0,0 +1,1505 @@
+'use strict';
+
+var locale_service = require('./locale.service-Cz-aZQnr.js');
+
+class ValueUtil {
+    static number(value) {
+        return Number(value);
+    }
+    static string(value) {
+        return String(value);
+    }
+    static boolean(value) {
+        return Boolean(value);
+    }
+    static date(value) {
+        return new Date(value);
+    }
+    static detect(filed, value) {
+        switch (filed.type) {
+            case 'number':
+                return ValueUtil.number(value);
+            case 'email':
+            case 'text':
+            case 'textarea':
+            case 'phone':
+            case 'url':
+            case 'password':
+            case 'color':
+            case 'file':
+                return ValueUtil.string(value);
+            case 'switch':
+                return ValueUtil.boolean(value);
+            case 'date':
+            case 'datetime':
+                return ValueUtil.date(value);
+            default:
+                return value;
+        }
+    }
+}
+
+/**
+ * getNestedValue - Navigate through nested objects using dot notation.
+ * @param obj The source object
+ * @param path The path to the value (e.g., 'user.name')
+ * @returns The value at the specified path or undefined
+ */
+function getNestedValue(obj, path) {
+    if (!obj || !path)
+        return undefined;
+    const keys = path.split('.');
+    let result = obj;
+    for (const key of keys) {
+        if (result && typeof result === 'object' && key in result) {
+            result = result[key];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return result;
+}
+/**
+ * getFieldValue - Resolve field values from either formValues or context.
+ * @param field The field identifier (starts with $ for context)
+ * @param formValues The form values object
+ * @param context The context object
+ * @returns The resolved value
+ */
+function getFieldValue(field, formValues, context) {
+    if (!field)
+        return undefined;
+    if (field.startsWith('$')) {
+        const contextPath = field.substring(1);
+        return getNestedValue(context, contextPath);
+    }
+    return getNestedValue(formValues, field);
+}
+/**
+ * evaluateCondition - Pure utility to evaluate a condition against data sources.
+ * @param condition The condition object { field, operator, value }
+ * @param formValues Current form values
+ * @param context External context ($ fields)
+ * @returns boolean
+ */
+function evaluateCondition(condition, formValues, context) {
+    if (!condition || !condition.field || !condition.operator) {
+        return false;
+    }
+    const { field, operator, value: expectedValue } = condition;
+    const actualValue = getFieldValue(field, formValues, context);
+    const result = (() => {
+        switch (operator) {
+            case 'equals':
+                return actualValue === expectedValue;
+            case 'notEquals':
+                return actualValue !== expectedValue;
+            case 'contains':
+                if (Array.isArray(actualValue)) {
+                    return actualValue.includes(expectedValue);
+                }
+                if (typeof actualValue === 'string') {
+                    return actualValue.includes(String(expectedValue));
+                }
+                return false;
+            case 'notContains':
+                if (Array.isArray(actualValue)) {
+                    return !actualValue.includes(expectedValue);
+                }
+                if (typeof actualValue === 'string') {
+                    return !actualValue.includes(String(expectedValue));
+                }
+                return true;
+            case 'greaterThan':
+                return Number(actualValue) > Number(expectedValue);
+            case 'lessThan':
+                return Number(actualValue) < Number(expectedValue);
+            case 'greaterThanOrEqual':
+                return Number(actualValue) >= Number(expectedValue);
+            case 'lessThanOrEqual':
+                return Number(actualValue) <= Number(expectedValue);
+            case 'isNotEmpty':
+            case 'notEmpty':
+                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));
+            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);
+                }
+                if (typeof expectedValue === 'string') {
+                    return expectedValue.split(',').map(v => v.trim()).includes(String(actualValue));
+                }
+                return false;
+            case 'notIn':
+                if (Array.isArray(expectedValue)) {
+                    return !expectedValue.includes(actualValue);
+                }
+                if (typeof expectedValue === 'string') {
+                    return !expectedValue.split(',').map(v => v.trim()).includes(String(actualValue));
+                }
+                return true;
+            default:
+                return false;
+        }
+    })();
+    return result;
+}
+
+class ConditionOperators {
+    get mapping() {
+        return {
+            equals: this.equals.bind(this),
+            notEquals: this.notEquals.bind(this),
+            contains: this.contains.bind(this),
+            notContains: this.notContains.bind(this),
+            greaterThan: this.greaterThan.bind(this),
+            lessThan: this.lessThan.bind(this),
+            greaterThanOrEqual: this.greaterThanOrEqual.bind(this),
+            lessThanOrEqual: this.lessThanOrEqual.bind(this),
+            isEmpty: this.isEmpty.bind(this),
+            isNotEmpty: this.isNotEmpty.bind(this),
+            startsWith: this.startsWith.bind(this),
+            endsWith: this.endsWith.bind(this),
+            in: this.in.bind(this),
+            notIn: this.notIn.bind(this),
+        };
+    }
+    equals(option, field, value) {
+        value = ValueUtil.detect(field, value);
+        return option.value === value;
+    }
+    notEquals(option, field, value) {
+        value = ValueUtil.detect(field, value);
+        return option.value !== value;
+    }
+    contains(option, field, value) {
+        value = ValueUtil.detect(field, value);
+        if (Array.isArray(value)) {
+            return value.includes(option.value);
+        }
+        if (typeof value === 'string') {
+            return value.includes(String(option.value));
+        }
+        return false;
+    }
+    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);
+            return Number.isFinite(cmp) ? value > cmp : false;
+        }
+        return false;
+    }
+    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);
+            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));
+    }
+    isNotEmpty(_option, field, value) {
+        value = ValueUtil.detect(field, value);
+        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);
+        }
+        if (typeof value === 'string') {
+            return !value.includes(String(option.value));
+        }
+        return true;
+    }
+    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);
+            return Number.isFinite(cmp) ? value >= cmp : false;
+        }
+        return false;
+    }
+    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);
+            return Number.isFinite(cmp) ? value <= cmp : false;
+        }
+        return false;
+    }
+    startsWith(option, field, value) {
+        value = ValueUtil.detect(field, value);
+        if (typeof value === 'string') {
+            return value.startsWith(String(option.value));
+        }
+        return false;
+    }
+    endsWith(option, field, value) {
+        value = ValueUtil.detect(field, value);
+        if (typeof value === 'string') {
+            return value.endsWith(String(option.value));
+        }
+        return false;
+    }
+    in(option, field, value) {
+        value = ValueUtil.detect(field, value);
+        if (Array.isArray(option.value)) {
+            return option.value.includes(value);
+        }
+        if (typeof option.value === 'string') {
+            return option.value
+                .split(',')
+                .map((v) => v.trim())
+                .includes(String(value));
+        }
+        return false;
+    }
+    notIn(option, field, value) {
+        value = ValueUtil.detect(field, value);
+        if (Array.isArray(option.value)) {
+            return !option.value.includes(value);
+        }
+        if (typeof option.value === 'string') {
+            return !option.value
+                .split(',')
+                .map((v) => v.trim())
+                .includes(String(value));
+        }
+        return true;
+    }
+    run(option, values, context) {
+        return evaluateCondition({
+            field: option.field,
+            operator: option.condition,
+            value: option.value,
+        }, values, context);
+    }
+}
+class ConditionBuilder extends ConditionOperators {
+    builder;
+    get form() {
+        return this.builder.form;
+    }
+    get schema() {
+        return this.builder.schema;
+    }
+    get conditions() {
+        return this.schema.conditions || [];
+    }
+    executors = [];
+    isCheckingAll = false;
+    constructor(builder) {
+        super();
+        this.builder = builder;
+        this.extract();
+    }
+    checkAll() {
+        this.isCheckingAll = true;
+        this.executors.forEach((executor) => executor());
+        this.isCheckingAll = false;
+        this.builder.notifySubscribers();
+    }
+    extract() {
+        this.conditions.forEach((cond) => {
+            if ('when' in cond) {
+                this.advanced(cond);
+            }
+            else if ('conditions' in cond) {
+                this.group(cond);
+            }
+            else {
+                this.condition(cond);
+            }
+        });
+    }
+    getEvaluationValues() {
+        const values = {};
+        // Map by ID
+        this.form.mappingById.forEach((field, id) => {
+            if (field.control) {
+                values[id] = field.control.value;
+            }
+        });
+        // Map by Name (for stability and backward compatibility)
+        this.form.mapping.forEach((field, name) => {
+            if (field.control) {
+                values[name] = field.control.value;
+            }
+        });
+        return values;
+    }
+    group(option) {
+        const executor = () => {
+            const values = this.getEvaluationValues();
+            this.builder.callEvent('beforeConditionCheck', option, values);
+            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);
+            if (groupStatus) {
+                option.actions.forEach((action) => {
+                    this.execute(action.action, action.actionField);
+                });
+            }
+            this.builder.callEvent('afterConditionCheck', option, values, groupStatus);
+            if (!this.isCheckingAll) {
+                this.builder.notifySubscribers();
+            }
+        };
+        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());
+            }
+        });
+        this.executors.push(executor);
+        executor();
+    }
+    advanced(option) {
+        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);
+                if (field || rule.field?.startsWith('$')) {
+                    const mockCond = {
+                        id: option.id,
+                        field: rule.field,
+                        condition: rule.operator,
+                        value: rule.value,
+                        action: 'show',
+                        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);
+                // If targetField found, use its id as key to execute (execute will resolve correctly)
+                const targetKey = targetField ? (targetField.id || targetField.name) : action.target;
+                this.execute(action.action, targetKey, action.value);
+            });
+            this.builder.callEvent('afterConditionCheck', option, values, isMatch);
+            if (!this.isCheckingAll) {
+                this.builder.notifySubscribers();
+            }
+        };
+        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());
+            }
+        });
+        this.executors.push(executor);
+        executor();
+    }
+    condition(option) {
+        const executor = () => {
+            const field = this.form.mappingById.get(option.field) || this.form.mapping.get(option.field);
+            if (field && 'control' in field && field.control) {
+                const val = field.control.value;
+                const values = this.getEvaluationValues();
+                this.builder.callEvent('beforeConditionCheck', option, val);
+                const status = this.run(option, values, this.builder.context);
+                status ? this.execute(option.action, option.actionField) : undefined;
+                this.builder.callEvent('afterConditionCheck', option, val, status);
+                if (!this.isCheckingAll) {
+                    this.builder.notifySubscribers();
+                }
+            }
+        };
+        const field = this.form.mappingById.get(option.field) || this.form.mapping.get(option.field);
+        if (field && 'control' in field && field.control) {
+            const control = field.control;
+            control.subscribe(() => executor());
+            this.executors.push(executor);
+        }
+        executor();
+    }
+    execute(action, actionField, value) {
+        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);
+            if (field) {
+                switch (action) {
+                    case 'show':
+                        field.hidden = false;
+                        break;
+                    case 'hide':
+                        field.hidden = true;
+                        break;
+                    case 'enable':
+                        field.disabled = false;
+                        break;
+                    case 'disable':
+                        field.disabled = true;
+                        break;
+                    case 'require':
+                        field.required = true;
+                        break;
+                    case 'unrequire':
+                        field.required = false;
+                        break;
+                    case 'setContent':
+                        field.content = value;
+                        break;
+                    case 'setLabel':
+                        field.label = String(value);
+                        break;
+                }
+            }
+        }
+    }
+}
+
+class AbstractControl {
+    _value;
+    _errors = null;
+    _status = 'VALID';
+    _parent = null;
+    _validators = [];
+    _asyncValidators = [];
+    // private _updateOn: 'change' | 'blur' | 'submit' = 'change';
+    _subscribers = new Set();
+    _touched = false;
+    _dirty = false;
+    constructor(validators, asyncValidators) {
+        if (validators)
+            this._validators = validators;
+        if (asyncValidators)
+            this._asyncValidators = asyncValidators;
+    }
+    // Getters
+    get value() {
+        return this._value;
+    }
+    get errors() {
+        return this._errors;
+    }
+    get status() {
+        return this._status;
+    }
+    get valid() {
+        return this._status === 'VALID';
+    }
+    get invalid() {
+        return this._status === 'INVALID';
+    }
+    get pending() {
+        return this._status === 'PENDING';
+    }
+    get disabled() {
+        return this._status === 'DISABLED';
+    }
+    get parent() {
+        return this._parent;
+    }
+    get touched() {
+        return this._touched;
+    }
+    get untouched() {
+        return !this._touched;
+    }
+    get dirty() {
+        return this._dirty;
+    }
+    get pristine() {
+        return !this._dirty;
+    }
+    // Validation
+    runValidators() {
+        let errors = null;
+        for (const validator of this._validators) {
+            const validationError = validator(this);
+            if (validationError) {
+                errors = errors || {};
+                Object.assign(errors, validationError);
+            }
+        }
+        return errors;
+    }
+    async runAsyncValidators() {
+        let errors = null;
+        for (const validator of this._asyncValidators) {
+            const validationError = await validator(this._value);
+            if (validationError) {
+                errors = errors || {};
+                Object.assign(errors, validationError);
+            }
+        }
+        return errors;
+    }
+    async updateValueAndValidity(options = {}) {
+        const { emitEvent = true } = options;
+        if (this._status === 'DISABLED') {
+            return;
+        }
+        // Run sync validators
+        this._errors = this.runValidators();
+        this._status = this._errors ? 'INVALID' : 'VALID';
+        // Run async validators if sync validators pass
+        if (this._asyncValidators.length > 0 && !this._errors) {
+            this._status = 'PENDING';
+            if (emitEvent)
+                this.notifySubscribers();
+            const asyncErrors = await this.runAsyncValidators();
+            if (asyncErrors) {
+                this._errors = { ...(this._errors ?? {}), ...asyncErrors };
+                this._status = 'INVALID';
+            }
+            else {
+                this._status = 'VALID';
+            }
+        }
+        if (emitEvent) {
+            this.notifySubscribers();
+            if (this._parent) {
+                this._parent.updateValueAndValidity({ emitEvent: true });
+            }
+        }
+    }
+    // State management
+    markAsTouched() {
+        this._touched = true;
+    }
+    markAsUntouched() {
+        this._touched = false;
+    }
+    markAsDirty() {
+        this._dirty = true;
+    }
+    markAsPristine() {
+        this._dirty = false;
+    }
+    disable() {
+        this._status = 'DISABLED';
+        this.notifySubscribers();
+    }
+    enable() {
+        this._status = 'VALID';
+        this.updateValueAndValidity();
+    }
+    // Validators management
+    setValidators(validators) {
+        this._validators = validators;
+        this.updateValueAndValidity();
+    }
+    setAsyncValidators(validators) {
+        this._asyncValidators = validators;
+        this.updateValueAndValidity();
+    }
+    clearValidators() {
+        this._validators = [];
+        this.updateValueAndValidity();
+    }
+    clearAsyncValidators() {
+        this._asyncValidators = [];
+        this.updateValueAndValidity();
+    }
+    registerValidator(validator) {
+        this._validators.push(validator);
+        this.updateValueAndValidity();
+    }
+    registerValidatorAsync(validator) {
+        this._asyncValidators.push(validator);
+        this.updateValueAndValidity();
+    }
+    // Parent management
+    setParent(parent) {
+        this._parent = parent;
+    }
+    // Subscription
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    notifySubscribers() {
+        this._subscribers.forEach(callback => callback(this._value));
+    }
+    setValueInternal(value) {
+        this._value = value;
+    }
+    // Error helpers
+    hasError(errorCode) {
+        return this._errors ? this._errors[errorCode] !== undefined : false;
+    }
+    getError(errorCode) {
+        return this._errors ? this._errors[errorCode] : null;
+    }
+}
+
+class FormControl extends AbstractControl {
+    constructor(initialValue = null, validatorsOrOptions, asyncValidators) {
+        let validators = [];
+        let asyncValidatorsList = [];
+        if (Array.isArray(validatorsOrOptions)) {
+            validators = validatorsOrOptions;
+            asyncValidatorsList = asyncValidators || [];
+        }
+        else if (validatorsOrOptions) {
+            validators = validatorsOrOptions.validators || [];
+            asyncValidatorsList = validatorsOrOptions.asyncValidators || [];
+        }
+        super(validators, asyncValidatorsList);
+        this.setValueInternal(initialValue);
+        this.updateValueAndValidity({ emitEvent: false });
+    }
+    setValue(value, options = {}) {
+        const { emitEvent = true } = options;
+        this.setValueInternal(value);
+        this.markAsDirty();
+        this.updateValueAndValidity({ emitEvent });
+    }
+    patchValue(value, options = {}) {
+        this.setValue(value, options);
+    }
+    reset(value = null, options = {}) {
+        this.setValueInternal(value);
+        this.markAsPristine();
+        this.markAsUntouched();
+        this.updateValueAndValidity(options);
+    }
+}
+
+class FormArray extends AbstractControl {
+    _controls = [];
+    constructor(controls, validatorsOrOptions, asyncValidators) {
+        let validators = [];
+        let asyncValidatorsList = [];
+        if (Array.isArray(validatorsOrOptions)) {
+            validators = validatorsOrOptions;
+            asyncValidatorsList = asyncValidators || [];
+        }
+        else if (validatorsOrOptions) {
+            validators = validatorsOrOptions.validators || [];
+            asyncValidatorsList = validatorsOrOptions.asyncValidators || [];
+        }
+        super(validators, asyncValidatorsList);
+        this._controls = controls;
+        controls.forEach((control) => {
+            control.setParent(this);
+        });
+        this.updateValueAndValidity({ emitEvent: false });
+    }
+    get controls() {
+        return this._controls;
+    }
+    get value() {
+        return this._controls
+            .filter((control) => !control.disabled)
+            .map((control) => control.value);
+    }
+    get length() {
+        return this._controls.length;
+    }
+    at(index) {
+        return this._controls[index] || null;
+    }
+    push(control) {
+        this._controls.push(control);
+        control.setParent(this);
+        this.updateValueAndValidity();
+    }
+    insert(index, control) {
+        this._controls.splice(index, 0, control);
+        control.setParent(this);
+        this.updateValueAndValidity();
+    }
+    removeAt(index) {
+        if (this._controls[index]) {
+            this._controls.splice(index, 1);
+            this.updateValueAndValidity();
+        }
+    }
+    setControl(index, control) {
+        if (this._controls[index]) {
+            this._controls[index] = control;
+            control.setParent(this);
+            this.updateValueAndValidity();
+        }
+    }
+    clear() {
+        this._controls = [];
+        this.updateValueAndValidity();
+    }
+    setValue(value, options = {}) {
+        if (value.length !== this._controls.length) {
+            throw new Error('setValue: value array length must match controls array length');
+        }
+        value.forEach((val, index) => {
+            this._controls[index].setValue(val, { emitEvent: false });
+        });
+        this.markAsDirty();
+        this.updateValueAndValidity(options);
+    }
+    patchValue(value, options = {}) {
+        value.forEach((val, index) => {
+            if (this._controls[index]) {
+                this._controls[index].patchValue(val, { emitEvent: false });
+            }
+        });
+        this.updateValueAndValidity(options);
+    }
+    reset(value = [], options = {}) {
+        this._controls.forEach((control, index) => {
+            control.reset(value[index], { emitEvent: false });
+        });
+        this.markAsPristine();
+        this.markAsUntouched();
+        this.updateValueAndValidity(options);
+    }
+    getRawValue() {
+        return this._controls.map((control) => control.value);
+    }
+}
+
+class FormGroup extends AbstractControl {
+    _controls = {};
+    constructor(controls, validatorsOrOptions, asyncValidators) {
+        let validators = [];
+        let asyncValidatorsList = [];
+        if (Array.isArray(validatorsOrOptions)) {
+            validators = validatorsOrOptions;
+            asyncValidatorsList = asyncValidators || [];
+        }
+        else if (validatorsOrOptions) {
+            validators = validatorsOrOptions.validators || [];
+            asyncValidatorsList = validatorsOrOptions.asyncValidators || [];
+        }
+        super(validators, asyncValidatorsList);
+        this._controls = controls;
+        Object.values(controls).forEach((control) => {
+            control.setParent(this);
+        });
+        this.updateValueAndValidity({ emitEvent: false });
+    }
+    get controls() {
+        return this._controls;
+    }
+    get value() {
+        const value = {};
+        Object.keys(this._controls).forEach((key) => {
+            const control = this._controls[key];
+            if (!control.disabled) {
+                value[key] = control.value;
+            }
+        });
+        return value;
+    }
+    setValue(value, options = {}) {
+        Object.keys(value).forEach((key) => {
+            if (!this._controls[key]) {
+                throw new Error(`Cannot find form control with name: ${key}`);
+            }
+            this._controls[key].setValue(value[key], { emitEvent: false });
+        });
+        this.markAsDirty();
+        this.updateValueAndValidity(options);
+    }
+    patchValue(value, options = {}) {
+        Object.keys(value).forEach((key) => {
+            if (this._controls[key]) {
+                this._controls[key].patchValue(value[key], { emitEvent: false });
+            }
+        });
+        this.updateValueAndValidity(options);
+    }
+    reset(value = {}, options = {}) {
+        Object.keys(this._controls).forEach((key) => {
+            this._controls[key].reset(value[key], { emitEvent: false });
+        });
+        this.markAsPristine();
+        this.markAsUntouched();
+        this.updateValueAndValidity(options);
+    }
+    // Control management
+    addControl(name, control) {
+        this._controls[name] = control;
+        control.setParent(this);
+        this.updateValueAndValidity();
+    }
+    removeControl(name) {
+        if (this._controls[name]) {
+            delete this._controls[name];
+            this.updateValueAndValidity();
+        }
+    }
+    setControl(name, control) {
+        if (this._controls[name]) {
+            this.removeControl(name);
+        }
+        this.addControl(name, control);
+    }
+    contains(name) {
+        return this._controls[name] !== undefined;
+    }
+    get(path) {
+        const pathArray = Array.isArray(path) ? path : path.split('.');
+        if (pathArray.length === 0)
+            return null;
+        let control = this._controls[pathArray[0]] || null;
+        for (let i = 1; i < pathArray.length && control; i++) {
+            if (control instanceof FormGroup) {
+                control = control.controls[pathArray[i]] || null;
+            }
+            else if (control instanceof FormArray) {
+                const index = parseInt(pathArray[i], 10);
+                control = control.at(index) || null;
+            }
+            else {
+                return null;
+            }
+        }
+        return control;
+    }
+    /**
+     * Override to aggregate validity from child controls
+     */
+    async updateValueAndValidity(options = {}) {
+        const { emitEvent = true } = options;
+        if (this._status === 'DISABLED') {
+            return;
+        }
+        // First run own validators
+        this._errors = this.runValidators();
+        // Then check all child controls
+        let hasInvalidChild = false;
+        const childErrors = {};
+        for (const key of Object.keys(this._controls)) {
+            const control = this._controls[key];
+            if (control.invalid) {
+                hasInvalidChild = true;
+                if (control.errors) {
+                    childErrors[key] = control.errors;
+                }
+            }
+        }
+        // Aggregate errors from children
+        if (hasInvalidChild) {
+            this._errors = this._errors || {};
+            Object.assign(this._errors, childErrors);
+            this._status = 'INVALID';
+        }
+        else if (this._errors) {
+            this._status = 'INVALID';
+        }
+        else {
+            this._status = 'VALID';
+        }
+        if (emitEvent) {
+            this.notifySubscribers();
+            if (this._parent) {
+                await this._parent.updateValueAndValidity({ emitEvent: true });
+            }
+        }
+    }
+    getRawValue() {
+        const value = {};
+        Object.keys(this._controls).forEach((key) => {
+            value[key] = this._controls[key].value;
+        });
+        return value;
+    }
+}
+
+class Validators {
+    static required(control) {
+        const value = control.value;
+        if (value === null || value === undefined || value === '' ||
+            (Array.isArray(value) && value.length === 0)) {
+            return { required: true };
+        }
+        return null;
+    }
+    static email(control) {
+        if (!control.value)
+            return null;
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(control.value) ? null : { email: true };
+    }
+    static min(min) {
+        return (control) => {
+            if (!control.value || isNaN(control.value))
+                return null;
+            return control.value < min ? { min: { min, actual: control.value } } : null;
+        };
+    }
+    static max(max) {
+        return (control) => {
+            if (!control.value || isNaN(control.value))
+                return null;
+            return control.value > max ? { max: { max, actual: control.value } } : null;
+        };
+    }
+    static minLength(minLength) {
+        return (control) => {
+            if (!control.value || typeof control.value !== 'string')
+                return null;
+            return control.value.length < minLength
+                ? { minLength: { minLength: minLength, actualLength: control.value.length } }
+                : null;
+        };
+    }
+    static maxLength(maxLength) {
+        return (control) => {
+            if (!control.value || typeof control.value !== 'string')
+                return null;
+            return control.value.length > maxLength
+                ? { maxLength: { maxLength: maxLength, actualLength: control.value.length } }
+                : null;
+        };
+    }
+    static pattern(pattern) {
+        return (control) => {
+            if (!control.value)
+                return null;
+            const regex = typeof pattern === 'string' ? new RegExp(`^(?:${pattern})$`) : pattern;
+            return regex.test(control.value) ? null : { pattern: { requiredPattern: pattern, actualValue: control.value } };
+        };
+    }
+    static hasUppercase(control) {
+        if (!control.value)
+            return null;
+        return /[A-Z]/.test(control.value) ? null : { hasUppercase: true };
+    }
+    static hasNumber(control) {
+        if (!control.value)
+            return null;
+        return /[0-9]/.test(control.value) ? null : { hasNumber: true };
+    }
+    static hasSpecialChar(control) {
+        if (!control.value)
+            return null;
+        return /[!@#$%^&*(),.?":{}|<>]/.test(control.value) ? null : { hasSpecialChar: true };
+    }
+    static integer(control) {
+        if (control.value === null || control.value === undefined || control.value === '')
+            return null;
+        const num = Number(control.value);
+        return !isNaN(num) && Number.isInteger(num) ? null : { integer: true };
+    }
+    static number(control) {
+        if (control.value === null || control.value === undefined || control.value === '')
+            return null;
+        const num = Number(control.value);
+        return !isNaN(num) ? null : { number: true };
+    }
+}
+
+class FormBuilder {
+    control(value, validatorsOrOptions, asyncValidators) {
+        return new FormControl(value, validatorsOrOptions, asyncValidators);
+    }
+    group(controls, options) {
+        const formControls = {};
+        Object.keys(controls).forEach(key => {
+            const control = controls[key];
+            if (control instanceof AbstractControl) {
+                formControls[key] = control;
+            }
+            else if (Array.isArray(control)) {
+                // [value, validators, asyncValidators]
+                formControls[key] = new FormControl(control[0], control[1], control[2]);
+            }
+            else {
+                formControls[key] = new FormControl(control);
+            }
+        });
+        return new FormGroup(formControls, options?.validators, options?.asyncValidators);
+    }
+    array(controls, options) {
+        const formControls = controls.map(control => {
+            if (control instanceof AbstractControl) {
+                return control;
+            }
+            else if (Array.isArray(control)) {
+                return new FormControl(control[0], control[1], control[2]);
+            }
+            else {
+                return new FormControl(control);
+            }
+        });
+        return new FormArray(formControls, options?.validators, options?.asyncValidators);
+    }
+}
+
+const FORM_INPUT_TYPE = [
+    'text',
+    'password',
+    'email',
+    'number',
+    'phone',
+    'url',
+    'date',
+    'datetime',
+    'time',
+    'color',
+    'checkbox',
+    'radio',
+    'file',
+    'range',
+    'textarea',
+    'select',
+    'switch',
+    'slider',
+    'rate',
+    'tags',
+    'daterange',
+    'tree-select',
+    'transfer',
+    'cascader',
+    'auto-complete',
+    'editor',
+    'location',
+    'input',
+    'captcha',
+    'address',
+    'table',
+];
+
+class Utils {
+    static isEmpty(value) {
+        return value === null || value === undefined || value === '';
+    }
+    static isNotEmpty(value) {
+        return value !== null && value !== undefined && value !== '';
+    }
+    static isFieldGroup(field) {
+        return 'elements' in field && Array.isArray(field.elements);
+    }
+    static isInputField(type) {
+        return FORM_INPUT_TYPE.includes(type);
+    }
+    static builderFromControl(field) {
+        try {
+            const validators = Utils.buildValidators(field);
+            const initialValue = field.defaultValue ?? field.targetKeys ?? field.defaultChecked ?? '';
+            const control = new FormControl(initialValue, validators);
+            field.control = control;
+            return { field, control };
+        }
+        catch (error) {
+            throw new Error(`Error building control for field ${field?.name}: ${error}`);
+        }
+    }
+    static buildValidators(field) {
+        const validators = [];
+        if (field.required) {
+            validators.push(Validators.required);
+        }
+        if ('minLength' in field && !Utils.isEmpty(field.minLength)) {
+            validators.push(Validators.minLength(field.minLength));
+        }
+        if ('maxLength' in field && !Utils.isEmpty(field.maxLength)) {
+            validators.push(Validators.maxLength(field.maxLength));
+        }
+        if ('pattern' in field && !Utils.isEmpty(field.pattern)) {
+            validators.push(Validators.pattern(field.pattern));
+        }
+        if (field.type === 'email') {
+            validators.push(Validators.email);
+        }
+        if ('min' in field && !Utils.isEmpty(field.min)) {
+            validators.push(Validators.min(Number(field.min)));
+        }
+        if ('max' in field && !Utils.isEmpty(field.max)) {
+            validators.push(Validators.max(Number(field.max)));
+        }
+        if (field.hasUppercase) {
+            validators.push(Validators.hasUppercase);
+        }
+        if (field.hasNumber) {
+            validators.push(Validators.hasNumber);
+        }
+        if (field.hasSpecialChar) {
+            validators.push(Validators.hasSpecialChar);
+        }
+        // ── 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);
+                        break;
+                    case 'minLength':
+                        if (!Utils.isEmpty(cfg.value))
+                            validators.push(Validators.minLength(Number(cfg.value)));
+                        break;
+                    case 'maxLength':
+                        if (!Utils.isEmpty(cfg.value))
+                            validators.push(Validators.maxLength(Number(cfg.value)));
+                        break;
+                    case 'pattern':
+                        if (!Utils.isEmpty(cfg.value))
+                            validators.push(Validators.pattern(cfg.value));
+                        break;
+                    case 'min':
+                        if (!Utils.isEmpty(cfg.value))
+                            validators.push(Validators.min(Number(cfg.value)));
+                        break;
+                    case 'max':
+                        if (!Utils.isEmpty(cfg.value))
+                            validators.push(Validators.max(Number(cfg.value)));
+                        break;
+                    case 'hasUppercase':
+                        validators.push(Validators.hasUppercase);
+                        break;
+                    case 'hasNumber':
+                        validators.push(Validators.hasNumber);
+                        break;
+                    case 'hasSpecialChar':
+                        validators.push(Validators.hasSpecialChar);
+                        break;
+                    case 'integer':
+                        validators.push(Validators.integer);
+                        break;
+                    case 'number':
+                        validators.push(Validators.number);
+                        break;
+                }
+            }
+        }
+        // ─────────────────────────────────────────────────────────────────────
+        return validators;
+    }
+    static translate(message, params) {
+        if (!message)
+            return '';
+        if (!params)
+            return message;
+        return message.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+            return params[key] !== undefined ? params[key] : `{{${key}}}`;
+        });
+    }
+    static messageValidator() {
+        // Direct check of resources — currently no validation bundle exists
+        const bundle = locale_service.translate('validation', {}, {});
+        return {
+            required: bundle.required || 'This field is required',
+            email: bundle.email || 'Invalid email',
+            min: bundle.min || 'Value is too small',
+            max: bundle.max || 'Value is too large',
+            minLength: bundle.minLength || 'Value is too short',
+            maxLength: bundle.maxLength || 'Value is too long',
+            pattern: bundle.pattern || 'Invalid pattern',
+            hasUppercase: bundle.hasUppercase || 'Uppercase letter required',
+            hasNumber: bundle.hasNumber || 'Number required',
+            hasSpecialChar: bundle.hasSpecialChar || 'Special character required',
+            type: bundle.type || 'Invalid type',
+            integer: bundle.integer || 'Value must be an integer',
+            number: bundle.number || 'Value must be a number',
+            custom: bundle.custom || 'Invalid value',
+        };
+    }
+}
+
+class FormMapping extends FormGroup {
+    builder;
+    mapping = new Map();
+    mappingById = new Map();
+    mappingObject = {};
+    fb = new FormBuilder();
+    get schema() {
+        return this.builder.schema;
+    }
+    is_custom_submit = false;
+    constructor(builder) {
+        super({});
+        this.builder = builder;
+        this.mapping = this.toMapping();
+        this.mappingObject = this.toMappingObject();
+        this.toFormMapping(this.mappingObject, this);
+    }
+    toMapping() {
+        const mappingRecursive = (fields) => {
+            const paths = new Map();
+            if (!fields || !Array.isArray(fields))
+                return paths;
+            for (const field of fields) {
+                if (!field)
+                    continue;
+                if (field.type === 'button' && field.htmlType === 'submit') {
+                    this.is_custom_submit = true;
+                    // Don't continue here, we still want to map button for conditions
+                }
+                // Map all elements with a name or id regardless of whether they have a control
+                if (field.name) {
+                    paths.set(field.name, field);
+                }
+                if (field.id) {
+                    this.mappingById.set(field.id, field);
+                    // If it doesn't have a name, still add it to main mapping by id so it can be found by key
+                    if (!field.name) {
+                        paths.set(field.id, field);
+                    }
+                }
+                if (Utils.isFieldGroup(field)) {
+                    const child_paths = mappingRecursive(field.elements);
+                    // Safely merge Maps
+                    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();
+        }
+        return mappingRecursive(elements);
+    }
+    toMappingObject() {
+        const applyField = (root, field) => {
+            const path = field.name;
+            const segments = path.split('.');
+            let current = root;
+            for (let i = 0; i < segments.length; i++) {
+                let seg = segments[i];
+                const isArray = seg.endsWith('[]');
+                const key = isArray ? seg.replace('[]', '') : seg;
+                const isLast = i === segments.length - 1;
+                if (isArray) {
+                    // Nếu chưa tồn tại hoặc không phải mảng → khởi tạo mảng với 1 object rỗng
+                    const existing = current[key];
+                    if (!Array.isArray(existing)) {
+                        current[key] = [{}];
+                    }
+                    // Đảm bảo phần tử đầu tiên là object (FormMappingOptions)
+                    const arr = current[key];
+                    if (!arr[0] || typeof arr[0] !== 'object' || Array.isArray(arr[0])) {
+                        arr[0] = {};
+                    }
+                    // Đi vào phần tử đầu tiên của mảng
+                    current = arr[0];
+                    continue;
+                }
+                // Nếu là cuối → gán null
+                if (isLast) {
+                    if (!current[key]) {
+                        current[key] = field.name;
+                    }
+                    break;
+                }
+                // Chưa phải cuối → object
+                if (!current[key]) {
+                    current[key] = {};
+                }
+                current = current[key];
+            }
+        };
+        const root = {};
+        for (const [_key, field] of Array.from(this.mapping.entries())) {
+            applyField(root, field);
+        }
+        return root;
+    }
+    toFormMapping(option, root) {
+        for (const [key, value] of Object.entries(option)) {
+            if (Array.isArray(value)) {
+                const formArray = this.fb.array([]);
+                for (const item of value) {
+                    if (item instanceof Object && !(item instanceof Array)) {
+                        const formGroup = this.fb.group({});
+                        this.toFormMapping(item, formGroup);
+                        formArray.push(formGroup);
+                    }
+                    else {
+                        // Trường hợp mảng giá trị đơn giản
+                        const field = this.mapping.get(item);
+                        if (!field) {
+                            console.warn(`Field with name ${item} not found in mapping.`);
+                            continue;
+                        }
+                        const { control } = Utils.builderFromControl(field);
+                        this.validateOnUseApi(field);
+                        control.subscribe((value) => {
+                            this.builder.callEvent('onFieldChange', field.name, value);
+                        });
+                        formArray.push(control);
+                    }
+                }
+                if (root instanceof FormGroup) {
+                    root.addControl(key, formArray);
+                }
+                else {
+                    root.push(formArray);
+                }
+            }
+            else if (value instanceof Object) {
+                const formGroup = root;
+                const childGroup = new FormGroup({});
+                this.toFormMapping(value, childGroup);
+                formGroup.addControl(key, childGroup);
+            }
+            else {
+                // Giá trị là FormField
+                const field = this.mapping.get(value);
+                if (!field) {
+                    console.warn(`Field with name ${value} not found in mapping.`);
+                    continue;
+                }
+                const formGroup = root;
+                this.validateOnUseApi(field);
+                const { control } = Utils.builderFromControl(field);
+                control.subscribe((value) => {
+                    this.builder.callEvent('onFieldChange', field.name, value);
+                });
+                formGroup.addControl(key, control);
+            }
+        }
+    }
+    validateOnUseApi(field) {
+    }
+    /**
+     * Mark all form controls as touched to trigger validation message display
+     */
+    markAllAsTouched() {
+        // Mark all controls in the mapping as touched
+        for (const [_key, field] of Array.from(this.mapping.entries())) {
+            if (field.control) {
+                field.control.markAsTouched();
+            }
+        }
+    }
+    onSubmit() { }
+    onReset() { }
+}
+
+class SchemaValidator {
+    /**
+     * Validates a schema object and returns an array of error messages.
+     * If the array is empty, the schema is valid.
+     */
+    static validate(schema) {
+        const errors = [];
+        if (!schema) {
+            errors.push('Schema is undefined or null.');
+            return errors;
+        }
+        const elements = schema.elements || schema.fields;
+        if (elements && Array.isArray(elements)) {
+            if (elements.length === 0) {
+                errors.push('Schema elements array is empty.');
+            }
+            elements.forEach((element, index) => {
+                this.validateField(element, `elements[${index}]`, errors);
+            });
+        }
+        else {
+            errors.push('Schema must contain an "elements" or "fields" array.');
+        }
+        return errors;
+    }
+    static validateField(field, path, errors) {
+        if (!field) {
+            errors.push(`Field at ${path} is undefined or null.`);
+            return;
+        }
+        if (!field.type) {
+            errors.push(`Field at ${path} is missing required property "type".`);
+        }
+        // Panels, grids, and containers usually have nested elements
+        if (['panel', 'grid', 'container'].includes(field.type)) {
+            if ('elements' in field && Array.isArray(field.elements)) {
+                field.elements.forEach((child, childIndex) => {
+                    this.validateField(child, `${path}.elements[${childIndex}]`, errors);
+                });
+            }
+        }
+    }
+}
+
+class SchemaBuilder {
+    schema;
+    form;
+    context = {};
+    get fields() {
+        return this.schema?.elements || this.schema?.fields || [];
+    }
+    events = {};
+    plugins = [];
+    _subscribers = new Set();
+    on(name, fn) {
+        this.events[name] = fn;
+        return this;
+    }
+    conditions;
+    constructor(schema) {
+        this.schema = schema;
+        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.callEvent('onInit');
+    }
+    callEvent(name, ...args) {
+        const event = this.events[name];
+        if (event) {
+            const ctx = {
+                builder: this,
+                form: this.form,
+                schema: this.schema,
+            };
+            event(ctx, ...args);
+        }
+    }
+    async use(plugin, options) {
+        this.plugins.push(plugin);
+        await plugin(this, options);
+        return this;
+    }
+    subscribe(callback) {
+        this._subscribers.add(callback);
+        return () => this._subscribers.delete(callback);
+    }
+    notifySubscribers() {
+        this._subscribers.forEach((callback) => callback(this.form.value));
+    }
+}
+
+exports.SchemaBuilder = SchemaBuilder;
+exports.Utils = Utils;