adaptform 2.0.4 → 2.1.0

package/dist/index.mjs

@@ -6,7 +6,7 @@ var Field = class {
     this._errors = [];
     this.isValid = null;
     this.isTouched = false;
-    this.filed_type = new TypeConstructor(options ?? {});
+    this.fieldType = new TypeConstructor(options ?? {});
     this.defaultValue = defaultValue ?? null;
     for (const plugin of this.options.plugins ?? []) {
       plugin.init?.(this);
@@ -18,24 +18,38 @@ var Field = class {
       this._valueClear = null;
       this.isValid = null;
     }
+    this.isTouched = false;
   }
-  // ========== Геттеры/сеттеры ==========
+  // ========== Getters and setters ==========
   get plugins() {
     return [...this.options.plugins ?? []].sort((a, b) => {
       return (a.pluginOptions?.priority ?? 0) - (b.pluginOptions?.priority ?? 0);
     });
   }
   get options() {
-    return this.filed_type.options;
+    return this.fieldType.options;
   }
   set options(options) {
-    let cur_options = this.filed_type.options;
-    this.filed_type.options = Object.assign(cur_options, options);
+    const currentOptions = this.fieldType.options;
+    this.fieldType.options = Object.assign(currentOptions, options);
   }
   get rawValue() {
     return this._rawValue;
   }
   set rawValue(input) {
+    this.setRawValue(input);
+  }
+  setRawValue(input, validate = true) {
+    this.assignRawValue(input);
+    this._errors = [];
+    this.isTouched = true;
+    if (validate) {
+      this.checkAndSetValid();
+    } else {
+      this.isValid = null;
+    }
+  }
+  assignRawValue(input) {
     let rawValue = input;
     for (const plugin of this.plugins) {
       if (plugin.toRawValue) {
@@ -49,10 +63,7 @@ var Field = class {
       }
     }
     this._rawValue = rawValue;
-    this._valueClear = this.filed_type.cast(valueClear);
-    this._errors = [];
-    this.isTouched = true;
-    this.checkAndSetValid();
+    this._valueClear = this.fieldType.cast(valueClear);
   }
   get errors() {
     return this._errors;
@@ -71,7 +82,7 @@ var Field = class {
   get valueClear() {
     return this._valueClear;
   }
-  // ========== Валидация ==========
+  // ========== Validation ==========
   isRequired(form) {
     let isRequired;
     if (typeof this.options.isRequired === "function") {
@@ -92,11 +103,11 @@ var Field = class {
     }
     if (this._valueClear === null) {
       this._errors.push(
-        this.options.messages?.type ?? `\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${this.filed_type.getTypeName()}`
+        this.options.messages?.type ?? `\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${this.fieldType.getTypeName()}`
       );
       return false;
     }
-    const typeErrors = this.filed_type.validate(this._valueClear, form);
+    const typeErrors = this.fieldType.validate(this._valueClear, form);
     if (typeErrors.length > 0) {
       this._errors.push(...typeErrors);
       return false;
@@ -121,55 +132,61 @@ var Field = class {
   get isEmpty() {
     let isEmpty = false;
     if (this._rawValue === null || this._rawValue === void 0) isEmpty = true;
-    else if (this._rawValue === "") isEmpty = true;
+    else if (typeof this._rawValue === "string" && this._rawValue.trim() === "") isEmpty = true;
     else if (Array.isArray(this._rawValue) && this._rawValue.length === 0) isEmpty = true;
     return isEmpty;
   }
-  // ========== Вспомогательные методы ==========
+  // ========== Helper methods ==========
   reset() {
     if (this.defaultValue !== null && this.defaultValue !== void 0) {
-      this.rawValue = this.defaultValue;
-      this.isValid = true;
+      this.assignRawValue(this.defaultValue);
     } else {
       this._rawValue = null;
       this._valueClear = null;
-      this.isValid = null;
     }
     this._errors = [];
+    this.isValid = null;
     this.isTouched = false;
   }
 };
 
+// src/core/fields/arrayUtils.ts
+function isValidArrayIndex(index, length) {
+  return Number.isInteger(index) && index >= 0 && index < length;
+}
+
 // src/core/fields/ArrayField.ts
 var ArrayField = class {
   constructor(factory, options = {}, initial = []) {
     this.factory = factory;
     this._items = [];
     this._errors = [];
+    this._hasValidationResult = false;
     this.isTouched = false;
     this.options = {
       isRequired: true,
       messages: {},
       ...options
     };
-    this._items = initial.map((v) => this.factory(v));
+    this._items = initial.map((value) => this.factory(value));
+    this.checkValid();
   }
   // ===== value =====
   set itemsValue(items) {
     this.clear();
-    for (const i of items) {
-      this.add(i, false);
+    for (const item of items) {
+      this.add(item, false);
     }
     this.checkValid();
   }
   get itemsValue() {
-    return this._items.map((i) => i.valueClear);
+    return this._items.map((item) => item.valueClear);
   }
   get items() {
     return this._items;
   }
   // ===== actions =====
-  add(value, force_check) {
+  add(value, force_check = true) {
     const field = this.factory(value);
     this.isTouched = true;
     this._items.push(field);
@@ -177,6 +194,7 @@ var ArrayField = class {
     return field;
   }
   remove(index) {
+    if (!isValidArrayIndex(index, this._items.length)) return;
     this._items.splice(index, 1);
     this.checkValid();
   }
@@ -195,6 +213,7 @@ var ArrayField = class {
     return isRequired;
   }
   checkValid(form) {
+    this._hasValidationResult = true;
     this._errors = [];
     if (this.isRequired(form) && this._items.length === 0) {
       this._errors.push(
@@ -220,7 +239,8 @@ var ArrayField = class {
       if (!ok) valid = false;
     }
     if (this.options.validate) {
-      const result = this.options.validate(this._items, form);
+      const values = this._items.map((item) => item.valueClear);
+      const result = this.options.validate(values, form);
       if (result === false) {
         this._errors.push(
           this.options.messages?.validate ?? "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u0438"
@@ -238,7 +258,9 @@ var ArrayField = class {
     return this.checkValid(form);
   }
   get isValid() {
-    return this._errors.length === 0 && this._items.every((i) => i.isValid === true);
+    if (!this._hasValidationResult) return false;
+    if (this._errors.length > 0) return false;
+    return this._items.every((item) => item.isValid === true);
   }
   get error() {
     return this._errors[0] ?? "";
@@ -246,16 +268,19 @@ var ArrayField = class {
   set error(message) {
     if (message) {
       this._errors = [message];
+      this._hasValidationResult = true;
     } else {
       this._errors = [];
+      this._hasValidationResult = false;
     }
   }
   get errors() {
     return this._errors;
   }
   reset() {
-    this._items.forEach((i) => i.reset());
+    this._items.forEach((item) => item.reset());
     this._errors = [];
+    this._hasValidationResult = false;
     this.isTouched = false;
   }
 };
@@ -267,37 +292,45 @@ var ArrayFormField = class {
     this.options = options;
     this._forms = [];
     this._errors = [];
+    this._hasValidationResult = false;
     this.isTouched = false;
     this._forms = initial.map((data) => {
       const form = new this.FormConstructor();
-      form.fields = data;
+      form.setFields(data, false);
       return form;
     });
+    this.checkValid();
   }
   // ===== value =====
   set forms(forms) {
-    this.clear();
-    for (const f of forms) {
-      this.add(f, false);
+    this.setForms(forms);
+  }
+  setForms(forms, validate = true) {
+    this._forms = [];
+    for (const formData of forms) {
+      this.add(formData, false);
     }
-    this.checkValid();
+    if (validate) this.checkValid();
   }
   get forms() {
     return this._forms;
   }
   get formsFieldsValue() {
-    return this._forms.map((i) => i.fieldsValue);
+    return this._forms.map((form) => form.fieldsValue);
   }
   // ===== actions =====
-  add(data, force_check) {
+  add(data, force_check = true) {
     const form = new this.FormConstructor();
-    if (data) form.fields = data;
+    if (data !== void 0 && data !== null) {
+      form.setFields(data, false);
+    }
     this.isTouched = true;
     this._forms.push(form);
     if (force_check) this.checkValid();
     return form;
   }
   remove(index) {
+    if (!isValidArrayIndex(index, this._forms.length)) return;
     this._forms.splice(index, 1);
     this.checkValid();
   }
@@ -306,8 +339,9 @@ var ArrayFormField = class {
     this.checkValid();
   }
   reset() {
-    this._forms.forEach((f) => f.reset());
+    this._forms.forEach((form) => form.reset());
     this._errors = [];
+    this._hasValidationResult = false;
     this.isTouched = false;
   }
   // ===== validation =====
@@ -321,8 +355,9 @@ var ArrayFormField = class {
     return isRequired;
   }
   checkValid(form) {
+    this._hasValidationResult = true;
     this._errors = [];
-    if (this.isRequired(form) && this.forms.length === 0) {
+    if (this.isRequired(form) && this._forms.length === 0) {
       this._errors.push(
         this.options.messages?.isRequired ?? "\u0414\u043E\u0431\u0430\u0432\u044C\u0442\u0435 \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D \u044D\u043B\u0435\u043C\u0435\u043D\u0442"
       );
@@ -341,12 +376,12 @@ var ArrayFormField = class {
       return false;
     }
     let valid = true;
-    for (const form2 of this.forms) {
-      const ok = form2.checkValid(form2);
+    for (const nestedForm of this._forms) {
+      const ok = nestedForm.checkValid(nestedForm);
       if (!ok) valid = false;
     }
     if (this.options.validate) {
-      const result = this.options.validate(this.forms, form);
+      const result = this.options.validate(this._forms, form);
       if (result === false) {
         this._errors.push(
           this.options.messages?.validate ?? "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u0438"
@@ -364,7 +399,9 @@ var ArrayFormField = class {
     return this.checkValid(form);
   }
   get isValid() {
-    return this._errors.length === 0 && this._forms.every((i) => i.checkValid() === true);
+    if (!this._hasValidationResult) return false;
+    if (this._errors.length > 0) return false;
+    return this._forms.every((form) => form.isValid);
   }
   get errors() {
     return this._errors;
@@ -375,16 +412,269 @@ var ArrayFormField = class {
   set error(message) {
     if (message) {
       this._errors = [message];
+      this._hasValidationResult = true;
     } else {
       this._errors = [];
+      this._hasValidationResult = false;
     }
   }
 };
 
+// src/core/ErrorsShema.ts
+var ErrorsSchema = class _ErrorsSchema {
+  constructor() {
+    this._staticRules = /* @__PURE__ */ new Map();
+    this._dynamicRules = [];
+    this._valueTransformers = [];
+  }
+  /**
+   * Add a static rule that matches an exact error key.
+   * @param errorKey - Exact error key returned by the server.
+   * @param fieldName - Form field name or a function that resolves it dynamically.
+   */
+  staticKey(errorKey, fieldName) {
+    this._staticRules.set(errorKey, fieldName);
+    return this;
+  }
+  /**
+   * Add a dynamic rule using a regular expression.
+   * @param pattern - Regular expression used to match an error key.
+   * @param mapping - Field name or function that derives it from the match.
+   * @param options - Additional options, such as rule priority.
+   */
+  dynamicKey(pattern, mapping, options) {
+    this._dynamicRules.push({
+      pattern,
+      mapping,
+      priority: options?.priority ?? 0
+    });
+    this._dynamicRules.sort((a, b) => b.priority - a.priority);
+    return this;
+  }
+  /**
+   * Set a handler for errors that do not match any rule.
+   */
+  fallback(handler) {
+    this._fallbackHandler = handler;
+    return this;
+  }
+  /**
+   * Add a transformer for error values.
+   * Useful for normalizing messages, such as server responses containing arrays.
+   */
+  transformValue(transformer) {
+    this._valueTransformers.push(transformer);
+    return this;
+  }
+  /**
+   * Create a schema from a simple mapping object.
+   */
+  static fromObject(mapping) {
+    const schema = new _ErrorsSchema();
+    for (const [errorKey, fieldName] of Object.entries(mapping)) {
+      schema.staticKey(errorKey, fieldName);
+    }
+    return schema;
+  }
+  /**
+   * Create a schema for an array of similarly structured forms.
+   */
+  static forArray(itemSchema, arrayFieldName, indexExtractor) {
+    const schema = new _ErrorsSchema();
+    for (const transformer of itemSchema._valueTransformers) {
+      schema.transformValue(transformer);
+    }
+    const escapedArrayFieldName = arrayFieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const indexPattern = indexExtractor ? "(.+?)" : "(?:\\[(\\d+)\\]|\\.(\\d+))";
+    schema.dynamicKey(
+      new RegExp(`^${escapedArrayFieldName}${indexPattern}\\.(.+)$`),
+      (match, value) => {
+        const sourceKey = match[0];
+        const index = indexExtractor ? indexExtractor(sourceKey) : Number(match[1] ?? match[2]);
+        if (!Number.isInteger(index) || index < 0) {
+          return "";
+        }
+        const fieldPath = match[indexExtractor ? 2 : 3];
+        const itemMapping = itemSchema.findMapping(fieldPath, value);
+        const mappedFieldPath = itemMapping ? typeof itemMapping === "function" ? itemMapping(value) : itemMapping : fieldPath;
+        return `${arrayFieldName}.${index}.${mappedFieldPath}`;
+      },
+      { priority: 100 }
+    );
+    return schema;
+  }
+  /**
+   * Parse errors while applying configured value transformers.
+   * Supports nested structures using dot notation.
+   */
+  parseErrors(errors, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(errors)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (this.isNestedObject(value)) {
+        const nestedErrors = this.parseErrors(value, fullKey);
+        Object.assign(result, nestedErrors);
+        continue;
+      }
+      if (value === null || value === void 0) {
+        continue;
+      }
+      let transformedValue = value;
+      for (const transformer of this._valueTransformers) {
+        transformedValue = transformer(transformedValue);
+      }
+      const mapping = this.findMapping(fullKey, transformedValue);
+      if (mapping) {
+        if (typeof mapping === "function") {
+          const fieldName = mapping(transformedValue);
+          if (fieldName) {
+            result[fieldName] = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
+          }
+        } else {
+          result[mapping] = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Parse server errors and return detailed metadata.
+   */
+  parseErrorsDetailed(errors, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(errors)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (this.isNestedObject(value)) {
+        const nestedErrors = this.parseErrorsDetailed(value, fullKey);
+        Object.assign(result, nestedErrors);
+        continue;
+      }
+      if (value === null || value === void 0) {
+        continue;
+      }
+      let transformedValue = value;
+      for (const transformer of this._valueTransformers) {
+        transformedValue = transformer(transformedValue);
+      }
+      const matchResult = this.findMappingDetailed(fullKey, transformedValue);
+      if (matchResult) {
+        const message = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
+        result[matchResult.fieldName] = {
+          fieldName: matchResult.fieldName,
+          message,
+          sourceKey: fullKey,
+          matchedBy: matchResult.matchedBy
+        };
+      }
+    }
+    return result;
+  }
+  /**
+   * Create a schema for a nested form.
+   */
+  nest(prefix) {
+    const nestedSchema = new _ErrorsSchema();
+    for (const [key, mapping] of this._staticRules.entries()) {
+      nestedSchema.staticKey(`${prefix}.${key}`, mapping);
+    }
+    for (const rule of this._dynamicRules) {
+      const newPattern = new RegExp(`^${prefix}\\.${rule.pattern.source.replace(/^\^/, "")}`);
+      nestedSchema.dynamicKey(newPattern, rule.mapping, { priority: rule.priority });
+    }
+    for (const transformer of this._valueTransformers) {
+      nestedSchema.transformValue(transformer);
+    }
+    if (this._fallbackHandler) {
+      nestedSchema.fallback((key, value) => {
+        if (key.startsWith(`${prefix}.`)) {
+          return this._fallbackHandler(key.slice(prefix.length + 1), value);
+        }
+        return null;
+      });
+    }
+    return nestedSchema;
+  }
+  /**
+   * Clone the current schema.
+   */
+  clone() {
+    const cloned = new _ErrorsSchema();
+    for (const [key, mapping] of this._staticRules.entries()) {
+      cloned._staticRules.set(key, mapping);
+    }
+    for (const rule of this._dynamicRules) {
+      cloned._dynamicRules.push({ ...rule });
+    }
+    cloned._fallbackHandler = this._fallbackHandler;
+    cloned._valueTransformers = [...this._valueTransformers];
+    return cloned;
+  }
+  /**
+   * Merge the current schema with another schema.
+   */
+  merge(other) {
+    const merged = this.clone();
+    for (const [key, mapping] of other._staticRules.entries()) {
+      merged._staticRules.set(key, mapping);
+    }
+    merged._dynamicRules.push(...other._dynamicRules);
+    merged._dynamicRules.sort((a, b) => b.priority - a.priority);
+    merged._valueTransformers.push(...other._valueTransformers);
+    if (other._fallbackHandler) {
+      merged._fallbackHandler = other._fallbackHandler;
+    }
+    return merged;
+  }
+  isNestedObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+  }
+  findMappingDetailed(key, value) {
+    if (this._staticRules.has(key)) {
+      const mapping = this._staticRules.get(key);
+      const fieldName = typeof mapping === "function" ? mapping(value) : mapping;
+      return fieldName ? { fieldName, matchedBy: "static" } : null;
+    }
+    for (const rule of this._dynamicRules) {
+      const match = key.match(rule.pattern);
+      if (match) {
+        const fieldName = typeof rule.mapping === "function" ? rule.mapping(match, value) : rule.mapping;
+        return fieldName ? { fieldName, matchedBy: "dynamic" } : null;
+      }
+    }
+    if (this._fallbackHandler) {
+      const fieldName = this._fallbackHandler(key, value);
+      return fieldName ? { fieldName, matchedBy: "fallback" } : null;
+    }
+    return null;
+  }
+  findMapping(key, value) {
+    if (this._staticRules.has(key)) {
+      return this._staticRules.get(key);
+    }
+    for (const rule of this._dynamicRules) {
+      const match = key.match(rule.pattern);
+      if (match) {
+        if (typeof rule.mapping === "function") {
+          const fieldName = rule.mapping(match, value);
+          return fieldName;
+        }
+        return rule.mapping;
+      }
+    }
+    if (this._fallbackHandler) {
+      const fieldName = this._fallbackHandler(key, value);
+      return fieldName;
+    }
+    return null;
+  }
+};
+var DefaultErrorsSchema = new ErrorsSchema().fallback((key) => key);
+
 // src/core/Form.ts
 var Form = class {
   constructor() {
     this._globalErrors = {};
+    this.errorsShema = DefaultErrorsSchema;
   }
   get _fields() {
     const fields = {};
@@ -405,7 +695,7 @@ var Form = class {
         isFormValid = false;
       }
     }
-    return isFormValid;
+    return isFormValid && Object.keys(this._globalErrors).length === 0;
   }
   get fieldsValue() {
     const data = {};
@@ -422,24 +712,36 @@ var Form = class {
     return data;
   }
   set fields(data) {
+    this.setFields(data);
+  }
+  setFields(data, validate = true) {
     const fields = this._fields;
     for (const key of Object.keys(data)) {
       const field = fields[key];
       if (field) {
-        if (field instanceof Field) field.rawValue = data[key];
+        if (field instanceof Field) field.setRawValue(data[key], false);
         else if (field instanceof ArrayField) field.itemsValue = data[key];
-        else if (field instanceof ArrayFormField) field.forms = data[key];
+        else if (field instanceof ArrayFormField) field.setForms(data[key], false);
         else console.error(`Invalid field "${key}" type`);
       }
     }
+    if (validate) this.checkValid();
   }
   get allErrors() {
     const errors = {};
     const fields = this._fields;
     for (const key of Object.keys(fields)) {
-      const fieldErrors = fields[key].errors;
-      if (fieldErrors.length > 0) {
-        errors[key] = fieldErrors;
+      const field = fields[key];
+      if (field instanceof ArrayFormField) {
+        const formErrors = this.collectArrayFormErrors(field);
+        if (formErrors.length > 0) {
+          errors[key] = formErrors;
+        }
+      } else {
+        const fieldErrors = field.errors;
+        if (fieldErrors.length > 0) {
+          errors[key] = fieldErrors;
+        }
       }
     }
     for (const key of Object.keys(this._globalErrors)) {
@@ -450,20 +752,95 @@ var Form = class {
     }
     return errors;
   }
+  /**
+   * Recursively collect all errors from an ArrayFormField.
+   */
+  collectArrayFormErrors(arrayField) {
+    const allErrors = [];
+    allErrors.push(...arrayField.errors);
+    for (let i = 0; i < arrayField.forms.length; i++) {
+      const form = arrayField.forms[i];
+      const formAllErrors = form.allErrors;
+      for (const [fieldName, fieldErrors] of Object.entries(formAllErrors)) {
+        for (const error of fieldErrors) {
+          allErrors.push(`\u0424\u043E\u0440\u043C\u0430 ${i + 1}, ${fieldName}: ${error}`);
+        }
+      }
+    }
+    return allErrors;
+  }
   get globalErrors() {
     return { ...this._globalErrors };
   }
   set errors(errors) {
+    this.clearErrorsRecursively();
     const fields = this._fields;
+    const parsedErrors = this.errorsShema.parseErrors(errors);
+    for (const [fieldName, errorMessage] of Object.entries(parsedErrors)) {
+      this.applyErrorToField(fieldName, errorMessage, fields, this);
+    }
+  }
+  clearErrorsRecursively() {
     this._globalErrors = {};
-    for (const key of Object.keys(errors)) {
-      const keys = key.split(".");
-      const cleanKey = keys.length > 1 ? keys[1] : key;
-      if (cleanKey in fields && fields[cleanKey]) {
-        fields[cleanKey].error = errors[key];
+    for (const field of Object.values(this._fields)) {
+      if (field instanceof Field) {
+        field.error = null;
+      } else if (field instanceof ArrayField) {
+        field.error = null;
+        for (const item of field.items) item.error = null;
+      } else if (field instanceof ArrayFormField) {
+        field.error = null;
+        for (const nestedForm of field.forms) nestedForm.clearErrorsRecursively();
+      }
+    }
+  }
+  /**
+   * Apply an error to the corresponding field.
+   * Supports nested fields using dot notation.
+   */
+  applyErrorToField(fieldPath, errorMessage, fields, targetForm) {
+    if (!targetForm) {
+      console.error("applyErrorToField: targetForm is undefined");
+      return;
+    }
+    if (fieldPath in fields && fields[fieldPath]) {
+      fields[fieldPath].error = errorMessage;
+      return;
+    }
+    const parts = fieldPath.split(".");
+    const rootField = parts[0];
+    if (rootField in fields && fields[rootField]) {
+      const field = fields[rootField];
+      if (parts.length === 1) {
+        field.error = errorMessage;
+      } else if (parts.length > 1) {
+        this.applyNestedError(field, parts.slice(1), errorMessage, fieldPath, targetForm);
+      }
+    } else {
+      targetForm.setGlobalError(fieldPath, errorMessage);
+    }
+  }
+  applyNestedError(field, pathParts, errorMessage, fullPath, targetForm) {
+    if (!targetForm) {
+      console.error("applyNestedError: targetForm is undefined");
+      return;
+    }
+    const [currentPart, ...remainingParts] = pathParts;
+    if (field instanceof ArrayFormField) {
+      const index = parseInt(currentPart);
+      if (!isNaN(index) && index >= 0 && index < field.forms.length) {
+        const form = field.forms[index];
+        if (remainingParts.length > 0) {
+          const formFields = form["_fields"];
+          this.applyErrorToField(remainingParts.join("."), errorMessage, formFields, form);
+        } else {
+          form.setGlobalError(`index_${index}`, errorMessage);
+        }
       } else {
-        this._globalErrors[key] = errors[key];
+        targetForm.setGlobalError(fullPath, errorMessage);
       }
+    } else {
+      targetForm.setGlobalError(fullPath, errorMessage);
     }
   }
   setGlobalError(key, message) {
@@ -486,7 +863,7 @@ var Form = class {
     }
     return false;
   }
-  // Проверить, валидна ли форма
+  // Check whether the form is valid.
   get isValid() {
     const fields = this._fields;
     for (const key of Object.keys(fields)) {
@@ -494,32 +871,50 @@ var Form = class {
     }
     return Object.keys(this._globalErrors).length === 0;
   }
-  // Получить все значения в виде FormData (для отправки на сервер)
+  // Serialize form values for multipart requests.
   toFormData() {
     const formData = new FormData();
     const data = this.fieldsValue;
     for (const [key, value] of Object.entries(data)) {
-      if (value instanceof Date) {
+      if (value === null || value === void 0) continue;
+      if (typeof Blob !== "undefined" && value instanceof Blob) {
+        formData.append(key, value);
+      } else if (value instanceof Date) {
         formData.append(key, value.toISOString());
-      } else if (value !== null && value !== void 0) {
+      } else if (typeof value === "object") {
+        const serialized = JSON.stringify(value);
+        if (serialized !== void 0) formData.append(key, serialized);
+      } else {
         formData.append(key, String(value));
       }
     }
     return formData;
   }
-  // Получить все значения в виде JSON
+  // Get all values in JSON-compatible form.
   toJSON() {
-    const data = this.fieldsValue;
     const json = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (value instanceof Date) {
-        json[key] = value.toISOString();
-      } else {
-        json[key] = value;
-      }
+    for (const [key, value] of Object.entries(this.fieldsValue)) {
+      json[key] = this.serializeJsonValue(value);
     }
     return json;
   }
+  serializeJsonValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.serializeJsonValue(item));
+    }
+    if (value !== null && typeof value === "object") {
+      const prototype = Object.getPrototypeOf(value);
+      if (prototype === Object.prototype || prototype === null) {
+        return Object.fromEntries(
+          Object.entries(value).map(([key, nestedValue]) => [key, this.serializeJsonValue(nestedValue)])
+        );
+      }
+    }
+    return value;
+  }
 };
 
 // src/core/plugins/FieldPlugin.ts
@@ -539,13 +934,13 @@ var MaskPlugin = class extends BasePlugin {
     this.maskParts = [];
     this.config = config;
   }
-  init(field) {
+  init(_field) {
     this.parseMask();
   }
-  toRawValue(value, field) {
+  toRawValue(value, _field) {
     return this.applyMask(value);
   }
-  toValueClear(value, field) {
+  toValueClear(value, _field) {
     return this.removeMask(value);
   }
   parseMask() {
@@ -744,8 +1139,12 @@ var StringType = class extends FieldType {
         this.options.messages?.maxLength ?? `\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u0430\u044F \u0434\u043B\u0438\u043D\u0430 ${this.options.maxLength} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432`
       );
     }
-    if (this.options.pattern != null && !this.options.pattern.test(value)) {
-      errors.push(this.options.messages?.pattern ?? "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442");
+    if (this.options.pattern != null) {
+      const { source, flags } = this.options.pattern;
+      const stablePattern = new RegExp(source, flags.replace(/[gy]/g, ""));
+      if (!stablePattern.test(value)) {
+        errors.push(this.options.messages?.pattern ?? "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0444\u043E\u0440\u043C\u0430\u0442");
+      }
     }
     return errors;
   }
@@ -758,15 +1157,21 @@ var StringType = class extends FieldType {
 var NumberType = class extends FieldType {
   cast(rawValue) {
     if (rawValue === null || rawValue === void 0) return null;
-    if (typeof rawValue === "number" && !isNaN(rawValue)) return rawValue;
+    if (typeof rawValue === "number") return Number.isFinite(rawValue) ? rawValue : null;
     if (typeof rawValue === "string") {
-      const num = Number(rawValue);
-      return isNaN(num) ? null : num;
+      const normalized = rawValue.trim();
+      if (normalized.length === 0) return null;
+      const num = Number(normalized);
+      return Number.isFinite(num) ? num : null;
     }
     return null;
   }
   validate(value) {
     const errors = [];
+    if (!Number.isFinite(value)) {
+      errors.push(this.options.messages?.invalid ?? "\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u043E\u043D\u0435\u0447\u043D\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C");
+      return errors;
+    }
     if (!Number.isInteger(value)) {
       errors.push(this.options.messages?.invalid ?? "\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u0446\u0435\u043B\u044B\u043C \u0447\u0438\u0441\u043B\u043E\u043C");
     }
@@ -811,7 +1216,7 @@ var DecimalType = class extends FieldType {
     if (typeof rawValue === "string") {
       return this.castString(rawValue);
     }
-    if (typeof rawValue === "number" && !isNaN(rawValue)) {
+    if (typeof rawValue === "number" && Number.isFinite(rawValue)) {
       return rawValue;
     }
     return null;
@@ -827,13 +1232,13 @@ var DecimalType = class extends FieldType {
   }
   validate(value) {
     const errors = [];
-    value = typeof value === "number" ? this.numberToString(value) : value;
+    value = typeof value === "number" ? String(value) : value;
     if (!this.isValidNumberString(value)) {
       errors.push(this.options.messages?.invalid ?? "\u041F\u0440\u0438\u043C\u0435\u0440: 1.00");
       return errors;
     }
-    const maxDigits = this.options.maxDigits || 8;
-    const decimalPlaces = this.options.decimalPlaces || 2;
+    const maxDigits = this.options.maxDigits ?? 8;
+    const decimalPlaces = this.options.decimalPlaces ?? 2;
     const maxIntDigits = maxDigits - decimalPlaces;
     const isNegative = value.startsWith("-");
     const normalizedValue = isNegative ? value.substring(1) : value;
@@ -907,10 +1312,6 @@ var DecimalType = class extends FieldType {
     if (dotCount > 1) return false;
     return pattern.test(value);
   }
-  numberToString(value) {
-    const decimalPlaces = this.options.decimalPlaces;
-    return value.toFixed(decimalPlaces);
-  }
   getTypeName() {
     return "\u0434\u0435\u0441\u044F\u0442\u0438\u0447\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E";
   }
@@ -987,7 +1388,7 @@ var DateType = class extends FieldType {
   getTypeName() {
     return this.options.isDatetime ? "\u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F" : "\u0434\u0430\u0442\u0430";
   }
-  // Сравнение дат с учётом времени
+  // Compare dates with optional time precision.
   compareDates(value, boundary, type) {
     if (this.options.isDatetime) {
       if (type === "min") {
@@ -1010,6 +1411,6 @@ var DateType = class extends FieldType {
   }
 };
 
-export { ArrayField, ArrayFormField, BasePlugin, BooleanType, DateType, DecimalType, Field, FieldType, Form, MaskPlugin, NumberType, StringType };
+export { ArrayField, ArrayFormField, BasePlugin, BooleanType, DateType, DecimalType, DefaultErrorsSchema, ErrorsSchema, Field, FieldType, Form, MaskPlugin, NumberType, StringType };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map