adaptform 2.0.5 → 2.2.0

package/dist/index.cjs

@@ -1,13 +1,334 @@
 'use strict';
 
+// src/core/state/value.ts
+function copyValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  const remember = (copy) => {
+    seen.set(value, copy);
+    return copy;
+  };
+  if (value instanceof Date) return remember(new Date(value.getTime()));
+  if (value instanceof RegExp) return remember(new RegExp(value.source, value.flags));
+  if (value instanceof ArrayBuffer) return remember(value.slice(0));
+  if (ArrayBuffer.isView(value)) {
+    const bytes = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+    return remember(value instanceof DataView ? new DataView(bytes) : new value.constructor(bytes));
+  }
+  if (value instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    seen.set(value, result);
+    for (const [key, item] of value) result.set(copyValue(key, seen), copyValue(item, seen));
+    return result;
+  }
+  if (value instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    seen.set(value, result);
+    for (const item of value) result.add(copyValue(item, seen));
+    return result;
+  }
+  if (Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) {
+    const result = Array.isArray(value) ? new Array(value.length) : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, result);
+    for (const key of Object.keys(value)) Object.defineProperty(result, key, {
+      value: copyValue(value[key], seen),
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    return result;
+  }
+  return value;
+}
+function equalValue(a, b, seen = /* @__PURE__ */ new WeakMap()) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+  if (seen.get(a)?.has(b)) return true;
+  const matches = seen.get(a) ?? /* @__PURE__ */ new WeakSet();
+  matches.add(b);
+  seen.set(a, matches);
+  if (a instanceof Date && b instanceof Date) return Object.is(a.getTime(), b.getTime());
+  if (a instanceof RegExp && b instanceof RegExp) return a.source === b.source && a.flags === b.flags;
+  if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) return equalValue(new Uint8Array(a), new Uint8Array(b), seen);
+  if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+    const av = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+    const bv = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+    return av.length === bv.length && av.every((byte, i) => byte === bv[i]);
+  }
+  if (a instanceof Map && b instanceof Map) return equalValue([...a], [...b], seen);
+  if (a instanceof Set && b instanceof Set) return equalValue([...a], [...b], seen);
+  if ("isLuxonDateTime" in a && a.isLuxonDateTime === true && "equals" in a && typeof a.equals === "function") {
+    return a.equals(b);
+  }
+  if (!Array.isArray(a) && Object.getPrototypeOf(a) !== Object.prototype && Object.getPrototypeOf(a) !== null) return false;
+  if (Array.isArray(a) && Array.isArray(b) && a.length !== b.length) return false;
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every((key) => Object.prototype.hasOwnProperty.call(b, key) && equalValue(a[key], b[key], seen));
+}
+
+// src/core/state/snapshot.ts
+function snapshotValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return value;
+  if (typeof value !== "object") return Object.freeze({ kind: "Opaque", type: typeof value });
+  const previous = seen.get(value);
+  if (previous) return previous;
+  if (value instanceof Date) return Object.freeze({ kind: "Date", timestamp: value.getTime() });
+  if (value instanceof RegExp) return Object.freeze({ kind: "RegExp", source: value.source, flags: value.flags });
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return Object.freeze({ kind: value.constructor.name, bytes: Object.freeze([...bytes]) });
+  }
+  if ("isLuxonDateTime" in value && value.isLuxonDateTime === true && "toISO" in value && typeof value.toISO === "function") {
+    return Object.freeze({ kind: "DateTime", iso: value.toISO() });
+  }
+  if (value instanceof Map || value instanceof Set) {
+    const result = { kind: value instanceof Map ? "Map" : "Set" };
+    seen.set(value, result);
+    result.entries = snapshotValue([...value], seen);
+    return Object.freeze(result);
+  }
+  if (Array.isArray(value)) {
+    const result = [];
+    seen.set(value, result);
+    for (const item of value) result.push(snapshotValue(item, seen));
+    return Object.freeze(result);
+  }
+  if (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) {
+    const result = /* @__PURE__ */ Object.create(null);
+    seen.set(value, result);
+    for (const [key, item] of Object.entries(value)) result[key] = snapshotValue(item, seen);
+    return Object.freeze(result);
+  }
+  return Object.freeze({ kind: "Opaque", type: value.constructor?.name ?? "object" });
+}
+function freezeSnapshot(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return value;
+  seen.add(value);
+  for (const item of Object.values(value)) freezeSnapshot(item, seen);
+  return Object.freeze(value);
+}
+
+// src/core/state/ObservableNode.ts
+var mutationDepth = 0;
+var flushing = false;
+var publishing = false;
+var batchDepth = 0;
+var validations = /* @__PURE__ */ new Map();
+var batchRoots = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Set();
+function flush() {
+  if (mutationDepth || flushing) return;
+  flushing = true;
+  let failure;
+  let failed = false;
+  try {
+    while (pending.size) {
+      const stores = [...pending];
+      const before = stores.map((store) => store.committed());
+      pending.clear();
+      for (const store of stores) store.refresh();
+      const changed = stores.filter((store, index) => !equalValue(before[index], store.committed()));
+      publishing = true;
+      try {
+        for (const store of changed) {
+          try {
+            store.notify();
+          } catch (error) {
+            if (!failed) {
+              failure = error;
+              failed = true;
+            }
+          }
+        }
+      } finally {
+        publishing = false;
+      }
+    }
+  } finally {
+    flushing = false;
+  }
+  if (failed) throw failure;
+}
+var SnapshotStore = class {
+  constructor(capture, getChildren) {
+    this.capture = capture;
+    this.getChildren = getChildren;
+    this.initialized = false;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.parents = /* @__PURE__ */ new Set();
+    this.children = /* @__PURE__ */ new Set();
+  }
+  reconcile(seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(this)) return;
+    seen.add(this);
+    const next = new Set(this.listeners.size || this.parents.size ? this.getChildren() : []);
+    for (const child of this.children) {
+      if (!next.has(child)) {
+        child.parents.delete(this);
+        child.reconcile(seen);
+      }
+    }
+    const previous = this.children;
+    this.children = next;
+    for (const child of next) {
+      if (!previous.has(child)) {
+        child.parents.add(this);
+        child.reconcile(seen);
+      }
+    }
+  }
+  read() {
+    if (!mutationDepth && !publishing) this.refresh();
+    else if (!this.initialized) this.refresh();
+    return this.snapshot;
+  }
+  committed() {
+    return this.snapshot;
+  }
+  refresh() {
+    this.reconcile();
+    const next = freezeSnapshot(this.capture());
+    if (this.initialized && equalValue(this.snapshot, next)) return false;
+    this.snapshot = next;
+    this.initialized = true;
+    return true;
+  }
+  subscribe(listener) {
+    this.read();
+    const registration = () => listener();
+    this.listeners.add(registration);
+    this.reconcile();
+    return () => {
+      this.listeners.delete(registration);
+      this.reconcile();
+    };
+  }
+  changed(seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(this)) return;
+    seen.add(this);
+    this.reconcile();
+    if (this.listeners.size || this.parents.size || this.initialized) pending.add(this);
+    for (const parent of this.parents) parent.changed(seen);
+  }
+  notify() {
+    let failure;
+    let failed = false;
+    for (const listener of [...this.listeners]) {
+      if (!this.listeners.has(listener)) continue;
+      try {
+        listener();
+      } catch (error) {
+        if (!failed) {
+          failure = error;
+          failed = true;
+        }
+      }
+    }
+    if (failed) throw failure;
+  }
+};
+var ObservableNode = class {
+  constructor() {
+    this._stateStore = new SnapshotStore(
+      () => this.captureState(),
+      () => this.stateChildren().map((child) => child._stateStore)
+    );
+  }
+  stateChildren() {
+    return [];
+  }
+  contains(node, seen = /* @__PURE__ */ new Set()) {
+    if (this === node) return true;
+    if (seen.has(this)) return false;
+    seen.add(this);
+    return this.stateChildren().some((child) => child.contains(node, seen));
+  }
+  validateAfterMutation(callback) {
+    if (batchDepth) validations.set(this, callback);
+    else callback();
+  }
+  batchUpdate(callback, validate) {
+    this.getSnapshot();
+    return this.update(() => {
+      batchDepth++;
+      batchRoots.set(this, validate);
+      let failed = false;
+      let failure;
+      let result;
+      try {
+        result = callback();
+        if (result !== null && (typeof result === "object" || typeof result === "function") && "then" in result && typeof result.then === "function") {
+          throw new TypeError("batch callbacks must be synchronous");
+        }
+      } catch (error) {
+        failed = true;
+        failure = error;
+      } finally {
+        batchDepth--;
+      }
+      if (!batchDepth) {
+        const requested = [...validations];
+        const roots = [...batchRoots];
+        validations.clear();
+        batchRoots.clear();
+        const selected = roots.filter(([root]) => requested.some(([node]) => root.contains(node))).filter(([root], index, all) => !all.some(([other], otherIndex) => other !== root && other.contains(root) && (!root.contains(other) || otherIndex < index)));
+        const checks = [
+          ...selected.map(([, check]) => check),
+          ...requested.filter(([node]) => !selected.some(([root]) => root.contains(node))).map(([, check]) => check)
+        ];
+        for (const check of checks) {
+          try {
+            check();
+          } catch (error) {
+            if (!failed) {
+              failed = true;
+              failure = error;
+            }
+          }
+        }
+      }
+      if (failed) throw failure;
+      return result;
+    });
+  }
+  subscribe(listener) {
+    return this._stateStore.subscribe(listener);
+  }
+  getSnapshot() {
+    return this._stateStore.read();
+  }
+  update(callback) {
+    mutationDepth++;
+    let failed = false;
+    try {
+      return callback();
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      this._stateStore.changed();
+      mutationDepth--;
+      if (failed) {
+        try {
+          flush();
+        } catch {
+        }
+      } else flush();
+    }
+  }
+};
+
 // src/core/fields/Field.ts
-var Field = class {
+var Field = class extends ObservableNode {
   constructor(TypeConstructor, defaultValue, options) {
+    super();
     this._rawValue = null;
     this._valueClear = null;
+    this._baseline = null;
     this._errors = [];
-    this.isValid = null;
-    this.isTouched = false;
+    this._isValid = null;
+    this._isTouched = false;
     this.fieldType = new TypeConstructor(options ?? {});
     this.defaultValue = defaultValue ?? null;
     for (const plugin of this.options.plugins ?? []) {
@@ -20,8 +341,36 @@ var Field = class {
       this._valueClear = null;
       this.isValid = null;
     }
+    this.isTouched = false;
+    this.commitBaseline();
+  }
+  get isValid() {
+    return this._isValid;
+  }
+  set isValid(value) {
+    this.update(() => {
+      this._isValid = value;
+    });
+  }
+  get isTouched() {
+    return this._isTouched;
+  }
+  set isTouched(value) {
+    this.update(() => {
+      this._isTouched = value;
+    });
   }
-  // ========== Геттеры/сеттеры ==========
+  captureState() {
+    return {
+      rawValue: snapshotValue(this._rawValue),
+      valueClear: snapshotValue(this._valueClear),
+      errors: [...this._errors],
+      isValid: this.isValid,
+      isTouched: this.isTouched,
+      isDirty: this.isDirty
+    };
+  }
+  // ========== Getters and setters ==========
   get plugins() {
     return [...this.options.plugins ?? []].sort((a, b) => {
       return (a.pluginOptions?.priority ?? 0) - (b.pluginOptions?.priority ?? 0);
@@ -31,13 +380,30 @@ var Field = class {
     return this.fieldType.options;
   }
   set options(options) {
-    let cur_options = this.fieldType.options;
-    this.fieldType.options = Object.assign(cur_options, options);
+    this.update(() => {
+      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) {
+    return this.update(() => {
+      this.assignRawValue(input);
+      this._errors = [];
+      this.isTouched = true;
+      if (validate) {
+        this.validateAfterMutation(() => this.checkAndSetValid());
+      } else {
+        this.isValid = null;
+      }
+    });
+  }
+  assignRawValue(input) {
     let rawValue = input;
     for (const plugin of this.plugins) {
       if (plugin.toRawValue) {
@@ -52,9 +418,6 @@ var Field = class {
     }
     this._rawValue = rawValue;
     this._valueClear = this.fieldType.cast(valueClear);
-    this._errors = [];
-    this.isTouched = true;
-    this.checkAndSetValid();
   }
   get errors() {
     return this._errors;
@@ -63,17 +426,27 @@ var Field = class {
     return this._errors[0] ?? "";
   }
   set error(message) {
-    if (message) {
-      this._errors = [message];
-    } else {
-      this._errors = [];
-    }
-    this.isValid = message ? false : null;
+    this.update(() => {
+      if (message) {
+        this._errors = [message];
+      } else {
+        this._errors = [];
+      }
+      this.isValid = message ? false : null;
+    });
   }
   get valueClear() {
     return this._valueClear;
   }
-  // ========== Валидация ==========
+  get isDirty() {
+    return !equalValue(this._valueClear, this._baseline);
+  }
+  commitBaseline() {
+    return this.update(() => {
+      this._baseline = copyValue(this._valueClear);
+    });
+  }
+  // ========== Validation ==========
   isRequired(form) {
     let isRequired;
     if (typeof this.options.isRequired === "function") {
@@ -84,107 +457,165 @@ var Field = class {
     return isRequired;
   }
   checkValid(form) {
-    this._errors = [];
-    if (this.isEmpty) {
-      if (this.isRequired(form)) {
-        this._errors.push(this.options.messages?.isRequired ?? "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u0434\u043B\u044F \u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044F");
-        return false;
+    return this.update(() => {
+      this._errors = [];
+      if (this.isEmpty) {
+        if (this.isRequired(form)) {
+          this._errors.push(this.options.messages?.isRequired ?? "\u041F\u043E\u043B\u0435 \u043E\u0431\u044F\u0437\u0430\u0442\u0435\u043B\u044C\u043D\u043E \u0434\u043B\u044F \u0437\u0430\u043F\u043E\u043B\u043D\u0435\u043D\u0438\u044F");
+          return false;
+        }
+        return true;
       }
-      return true;
-    }
-    if (this._valueClear === null) {
-      this._errors.push(
-        this.options.messages?.type ?? `\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${this.fieldType.getTypeName()}`
-      );
-      return false;
-    }
-    const typeErrors = this.fieldType.validate(this._valueClear, form);
-    if (typeErrors.length > 0) {
-      this._errors.push(...typeErrors);
-      return false;
-    }
-    if (this.options.validate) {
-      const result = this.options.validate(this._valueClear, form);
-      if (result === false) {
-        this._errors.push(this.options.messages?.validate ?? "\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043D\u0435 \u043F\u0440\u043E\u0448\u043B\u043E \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u044E");
+      if (this._valueClear === null) {
+        this._errors.push(
+          this.options.messages?.type ?? `\u041E\u0436\u0438\u0434\u0430\u0435\u0442\u0441\u044F ${this.fieldType.getTypeName()}`
+        );
         return false;
       }
-      if (typeof result === "string") {
-        this._errors.push(result);
+      const typeErrors = this.fieldType.validate(this._valueClear, form);
+      if (typeErrors.length > 0) {
+        this._errors.push(...typeErrors);
         return false;
       }
-    }
-    return true;
+      if (this.options.validate) {
+        const result = this.options.validate(this._valueClear, form);
+        if (result === false) {
+          this._errors.push(this.options.messages?.validate ?? "\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u043D\u0435 \u043F\u0440\u043E\u0448\u043B\u043E \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u044E");
+          return false;
+        }
+        if (typeof result === "string") {
+          this._errors.push(result);
+          return false;
+        }
+      }
+      return true;
+    });
   }
   checkAndSetValid(form) {
-    this.isValid = this.checkValid(form);
-    return this.isValid;
+    return this.update(() => {
+      this.isValid = this.checkValid(form);
+      return this.isValid;
+    });
   }
   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;
-    } else {
-      this._rawValue = null;
-      this._valueClear = null;
+    return this.update(() => {
+      if (this.defaultValue !== null && this.defaultValue !== void 0) {
+        this.assignRawValue(this.defaultValue);
+      } else {
+        this._rawValue = null;
+        this._valueClear = null;
+      }
+      this._errors = [];
       this.isValid = null;
-    }
-    this._errors = [];
-    this.isTouched = false;
+      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 {
+var ArrayField = class extends ObservableNode {
   constructor(factory, options = {}, initial = []) {
+    super();
     this.factory = factory;
     this._items = [];
     this._errors = [];
-    this.isTouched = false;
+    this._baseline = [];
+    this._hasValidationResult = false;
+    this._isTouched = false;
     this.options = {
       isRequired: true,
       messages: {},
       ...options
     };
-    this._items = initial.map((v) => this.factory(v));
-    this.checkValid();
+    this._items = initial.map((value) => this.factory(value));
+    this.validateAfterMutation(() => this.checkValid());
+    this.commitBaseline();
+  }
+  captureState() {
+    return {
+      itemsValue: snapshotValue(this.itemsValue),
+      items: this._items.map((item) => item.getSnapshot()),
+      errors: [...this._errors],
+      isValid: this.isValid,
+      isTouched: this.isTouched,
+      isDirty: this.isDirty
+    };
+  }
+  stateChildren() {
+    return this._items;
+  }
+  get isTouched() {
+    return this._isTouched;
+  }
+  set isTouched(value) {
+    this.update(() => {
+      this._isTouched = value;
+    });
+  }
+  get isDirty() {
+    return !equalValue(this.itemsValue, this._baseline) || this._items.some((child) => child.isDirty);
+  }
+  commitBaseline() {
+    return this.update(() => {
+      for (const child of this._items) child.commitBaseline();
+      this._baseline = copyValue(this.itemsValue);
+    });
   }
   // ===== value =====
   set itemsValue(items) {
-    this.clear();
-    for (const i of items) {
-      this.add(i, false);
-    }
-    this.checkValid();
+    this.setItemsValue(items);
+  }
+  setItemsValue(items, validate = true) {
+    return this.update(() => {
+      this._items = [];
+      this.error = null;
+      for (const item of items) {
+        this.add(item, false);
+      }
+      if (validate) this.validateAfterMutation(() => 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) {
-    const field = this.factory(value);
-    this.isTouched = true;
-    this._items.push(field);
-    if (force_check) this.checkValid();
-    return field;
+  add(value, force_check = true) {
+    return this.update(() => {
+      const field = this.factory(value);
+      this.isTouched = true;
+      this._items.push(field);
+      if (force_check) this.validateAfterMutation(() => this.checkValid());
+      return field;
+    });
   }
   remove(index) {
-    this._items.splice(index, 1);
-    this.checkValid();
+    return this.update(() => {
+      if (!isValidArrayIndex(index, this._items.length)) return;
+      this._items.splice(index, 1);
+      this.validateAfterMutation(() => this.checkValid());
+    });
   }
   clear() {
-    this._items = [];
-    this.checkValid();
+    return this.update(() => {
+      this._items = [];
+      this.validateAfterMutation(() => this.checkValid());
+    });
   }
   // ===== validation =====
   isRequired(form) {
@@ -197,123 +628,186 @@ var ArrayField = class {
     return isRequired;
   }
   checkValid(form) {
-    this._errors = [];
-    if (this.isRequired(form) && this._items.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"
-      );
-      return false;
-    }
-    if (this.options.minItems != null && this._items.length < this.options.minItems) {
-      this._errors.push(
-        this.options.messages?.minItems ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.minItems}`
-      );
-      return false;
-    }
-    if (this.options.maxItems != null && this._items.length > this.options.maxItems) {
-      this._errors.push(
-        this.options.messages?.maxItems ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.maxItems}`
-      );
-      return false;
-    }
-    let valid = true;
-    for (const field of this._items) {
-      const ok = field.checkAndSetValid(form);
-      if (!ok) valid = false;
-    }
-    if (this.options.validate) {
-      const values = this._items.map((i) => i.valueClear);
-      const result = this.options.validate(values, form);
-      if (result === false) {
+    return this.update(() => {
+      this._hasValidationResult = true;
+      this._errors = [];
+      if (this.isRequired(form) && this._items.length === 0) {
         this._errors.push(
-          this.options.messages?.validate ?? "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u0438"
+          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"
         );
         return false;
       }
-      if (typeof result === "string") {
-        this._errors.push(result);
+      if (this.options.minItems != null && this._items.length < this.options.minItems) {
+        this._errors.push(
+          this.options.messages?.minItems ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.minItems}`
+        );
         return false;
       }
-    }
-    return valid && this._errors.length === 0;
+      if (this.options.maxItems != null && this._items.length > this.options.maxItems) {
+        this._errors.push(
+          this.options.messages?.maxItems ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.maxItems}`
+        );
+        return false;
+      }
+      let valid = true;
+      for (const field of this._items) {
+        const ok = field.checkAndSetValid(form);
+        if (!ok) valid = false;
+      }
+      if (this.options.validate) {
+        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"
+          );
+          return false;
+        }
+        if (typeof result === "string") {
+          this._errors.push(result);
+          return false;
+        }
+      }
+      return valid && this._errors.length === 0;
+    });
   }
   checkAndSetValid(form) {
     return this.checkValid(form);
   }
   get isValid() {
+    if (!this._hasValidationResult) return false;
     if (this._errors.length > 0) return false;
-    return this._items.every((i) => i.isValid === true);
+    return this._items.every((item) => item.isValid === true);
   }
   get error() {
     return this._errors[0] ?? "";
   }
   set error(message) {
-    if (message) {
-      this._errors = [message];
-    } else {
-      this._errors = [];
-    }
+    this.update(() => {
+      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._errors = [];
-    this.isTouched = false;
+    return this.update(() => {
+      this._items.forEach((item) => item.reset());
+      this._errors = [];
+      this._hasValidationResult = false;
+      this.isTouched = false;
+    });
   }
 };
 
 // src/core/fields/ArrayFormField.ts
-var ArrayFormField = class {
+var ArrayFormField = class extends ObservableNode {
   constructor(FormConstructor, options = {}, initial = []) {
+    super();
     this.FormConstructor = FormConstructor;
     this.options = options;
     this._forms = [];
     this._errors = [];
-    this.isTouched = false;
+    this._baseline = [];
+    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();
+    this.validateAfterMutation(() => this.checkValid());
+    this.commitBaseline();
+  }
+  captureState() {
+    return {
+      formsFieldsValue: snapshotValue(this.formsFieldsValue),
+      forms: this._forms.map((form) => form.getSnapshot()),
+      errors: [...this._errors],
+      isValid: this.isValid,
+      isTouched: this.isTouched,
+      isDirty: this.isDirty
+    };
+  }
+  stateChildren() {
+    return this._forms;
+  }
+  get isTouched() {
+    return this._isTouched;
+  }
+  set isTouched(value) {
+    this.update(() => {
+      this._isTouched = value;
+    });
+  }
+  get isDirty() {
+    return !equalValue(this.formsFieldsValue, this._baseline) || this._forms.some((child) => child.isDirty);
+  }
+  commitBaseline() {
+    return this.update(() => {
+      for (const child of this._forms) child.commitBaseline();
+      this._baseline = copyValue(this.formsFieldsValue);
+    });
   }
   // ===== value =====
   set forms(forms) {
-    this.clear();
-    for (const f of forms) {
-      this.add(f, false);
-    }
-    this.checkValid();
+    this.setForms(forms);
+  }
+  setForms(forms, validate = true) {
+    return this.update(() => {
+      this._forms = [];
+      for (const formData of forms) {
+        this.add(formData, false);
+      }
+      if (validate) this.validateAfterMutation(() => 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) {
-    const form = new this.FormConstructor();
-    if (data) form.fields = data;
-    this.isTouched = true;
-    this._forms.push(form);
-    if (force_check) this.checkValid();
-    return form;
+  add(data, force_check = true) {
+    return this.update(() => {
+      const form = new this.FormConstructor();
+      if (data !== void 0 && data !== null) {
+        form.setFields(data, false);
+      }
+      form.commitBaseline();
+      this.isTouched = true;
+      this._forms.push(form);
+      if (force_check) this.validateAfterMutation(() => this.checkValid());
+      return form;
+    });
   }
   remove(index) {
-    this._forms.splice(index, 1);
-    this.checkValid();
+    return this.update(() => {
+      if (!isValidArrayIndex(index, this._forms.length)) return;
+      this._forms.splice(index, 1);
+      this.validateAfterMutation(() => this.checkValid());
+    });
   }
   clear() {
-    this._forms = [];
-    this.checkValid();
+    return this.update(() => {
+      this._forms = [];
+      this.validateAfterMutation(() => this.checkValid());
+    });
   }
   reset() {
-    this._forms.forEach((f) => f.reset());
-    this._errors = [];
-    this.isTouched = false;
+    return this.update(() => {
+      this._forms.forEach((form) => form.reset());
+      this._errors = [];
+      this._hasValidationResult = false;
+      this.isTouched = false;
+    });
   }
   // ===== validation =====
   isRequired(form) {
@@ -326,51 +820,55 @@ var ArrayFormField = class {
     return isRequired;
   }
   checkValid(form) {
-    this._errors = [];
-    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"
-      );
-      return false;
-    }
-    if (this.options.minForms != null && this._forms.length < this.options.minForms) {
-      this._errors.push(
-        this.options.messages?.minForms ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.minForms}`
-      );
-      return false;
-    }
-    if (this.options.maxForms != null && this._forms.length > this.options.maxForms) {
-      this._errors.push(
-        this.options.messages?.maxForms ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.maxForms}`
-      );
-      return false;
-    }
-    let valid = true;
-    for (const form2 of this.forms) {
-      const ok = form2.checkValid(form2);
-      if (!ok) valid = false;
-    }
-    if (this.options.validate) {
-      const result = this.options.validate(this.forms, form);
-      if (result === false) {
+    return this.update(() => {
+      this._hasValidationResult = true;
+      this._errors = [];
+      if (this.isRequired(form) && this._forms.length === 0) {
         this._errors.push(
-          this.options.messages?.validate ?? "\u041E\u0448\u0438\u0431\u043A\u0430 \u0432\u0430\u043B\u0438\u0434\u0430\u0446\u0438\u0438"
+          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"
         );
         return false;
       }
-      if (typeof result === "string") {
-        this._errors.push(result);
+      if (this.options.minForms != null && this._forms.length < this.options.minForms) {
+        this._errors.push(
+          this.options.messages?.minForms ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u043C\u0435\u043D\u044C\u0448\u0435 ${this.options.minForms}`
+        );
         return false;
       }
-    }
-    return valid && this._errors.length === 0;
+      if (this.options.maxForms != null && this._forms.length > this.options.maxForms) {
+        this._errors.push(
+          this.options.messages?.maxForms ?? `\u0417\u043D\u0430\u0447\u0435\u043D\u0438\u0439 \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043D\u0435 \u0431\u043E\u043B\u044C\u0448\u0435 ${this.options.maxForms}`
+        );
+        return false;
+      }
+      let valid = true;
+      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);
+        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"
+          );
+          return false;
+        }
+        if (typeof result === "string") {
+          this._errors.push(result);
+          return false;
+        }
+      }
+      return valid && this._errors.length === 0;
+    });
   }
   checkAndSetValid(form) {
     return this.checkValid(form);
   }
   get isValid() {
+    if (!this._hasValidationResult) return false;
     if (this._errors.length > 0) return false;
-    return this._forms.every((i) => i.checkValid() === true);
+    return this._forms.every((form) => form.isValid);
   }
   get errors() {
     return this._errors;
@@ -379,11 +877,15 @@ var ArrayFormField = class {
     return this._errors[0] ?? "";
   }
   set error(message) {
-    if (message) {
-      this._errors = [message];
-    } else {
-      this._errors = [];
-    }
+    this.update(() => {
+      if (message) {
+        this._errors = [message];
+        this._hasValidationResult = true;
+      } else {
+        this._errors = [];
+        this._hasValidationResult = false;
+      }
+    });
   }
 };
 
@@ -395,19 +897,19 @@ var ErrorsSchema = class _ErrorsSchema {
     this._valueTransformers = [];
   }
   /**
-   * Добавляет статическое правило - точное соответствие ключа ошибки
-   * @param errorKey - точный ключ ошибки из ответа сервера
-   * @param fieldName - имя поля в форме или функция для динамического определения
+   * 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;
   }
   /**
-   * Добавляет динамическое правило с регулярным выражением
-   * @param pattern - регулярное выражение для сопоставления ключа ошибки
-   * @param mapping - имя поля или функция для извлечения имени поля из совпадения
-   * @param options - дополнительные опции (приоритет и т.д.)
+   * 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({
@@ -419,22 +921,22 @@ var ErrorsSchema = class _ErrorsSchema {
     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();
@@ -444,24 +946,35 @@ var ErrorsSchema = class _ErrorsSchema {
     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(`^${arrayFieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\[(\\d+)\\]\\.(.+)$`),
-      (match) => {
-        const index = match[1];
-        const fieldName = match[2];
-        return `${arrayFieldName}.${index}.${fieldName}`;
+      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 = {};
@@ -489,17 +1002,12 @@ var ErrorsSchema = class _ErrorsSchema {
         } else {
           result[mapping] = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
         }
-      } else if (this._fallbackHandler) {
-        const fieldName = this._fallbackHandler(fullKey, transformedValue);
-        if (fieldName) {
-          result[fieldName] = typeof transformedValue === "string" ? transformedValue : JSON.stringify(transformedValue);
-        }
       }
     }
     return result;
   }
   /**
-   * Парсит ошибки сервера и возвращает расширенную информацию
+   * Parse server errors and return detailed metadata.
    */
   parseErrorsDetailed(errors, prefix = "") {
     const result = {};
@@ -531,7 +1039,7 @@ var ErrorsSchema = class _ErrorsSchema {
     return result;
   }
   /**
-   * Создает схему для вложенной формы
+   * Create a schema for a nested form.
    */
   nest(prefix) {
     const nestedSchema = new _ErrorsSchema();
@@ -556,7 +1064,7 @@ var ErrorsSchema = class _ErrorsSchema {
     return nestedSchema;
   }
   /**
-   * Клонирует текущую схему
+   * Clone the current schema.
    */
   clone() {
     const cloned = new _ErrorsSchema();
@@ -571,7 +1079,7 @@ var ErrorsSchema = class _ErrorsSchema {
     return cloned;
   }
   /**
-   * Объединяет текущую схему с другой
+   * Merge the current schema with another schema.
    */
   merge(other) {
     const merged = this.clone();
@@ -598,7 +1106,7 @@ var ErrorsSchema = class _ErrorsSchema {
     for (const rule of this._dynamicRules) {
       const match = key.match(rule.pattern);
       if (match) {
-        const fieldName = typeof rule.mapping === "function" ? rule.mapping(match) : rule.mapping;
+        const fieldName = typeof rule.mapping === "function" ? rule.mapping(match, value) : rule.mapping;
         return fieldName ? { fieldName, matchedBy: "dynamic" } : null;
       }
     }
@@ -616,7 +1124,7 @@ var ErrorsSchema = class _ErrorsSchema {
       const match = key.match(rule.pattern);
       if (match) {
         if (typeof rule.mapping === "function") {
-          const fieldName = rule.mapping(match);
+          const fieldName = rule.mapping(match, value);
           return fieldName;
         }
         return rule.mapping;
@@ -632,11 +1140,29 @@ var ErrorsSchema = class _ErrorsSchema {
 var DefaultErrorsSchema = new ErrorsSchema().fallback((key) => key);
 
 // src/core/Form.ts
-var Form = class {
+var Form = class extends ObservableNode {
   constructor() {
+    super(...arguments);
     this._globalErrors = {};
     this.errorsShema = DefaultErrorsSchema;
   }
+  captureState() {
+    return {
+      fieldsValue: snapshotValue(this.fieldsValue),
+      allErrors: this.allErrors,
+      globalErrors: this.globalErrors,
+      fields: Object.fromEntries(Object.entries(this._fields).map(([key, field]) => [key, field.getSnapshot()])),
+      isValid: this.isValid,
+      isTouched: this.isTouched,
+      isDirty: this.isDirty
+    };
+  }
+  stateChildren() {
+    return Object.values(this._fields);
+  }
+  batch(callback) {
+    return this.batchUpdate(callback, () => this.checkValid());
+  }
   get _fields() {
     const fields = {};
     for (const key of Object.keys(this)) {
@@ -648,15 +1174,17 @@ var Form = class {
     return fields;
   }
   checkValid(form) {
-    let isFormValid = true;
-    const fields = this._fields;
-    for (const key of Object.keys(fields)) {
-      const field = fields[key];
-      if (!field.checkAndSetValid(form ?? this)) {
-        isFormValid = false;
+    return this.update(() => {
+      let isFormValid = true;
+      const fields = this._fields;
+      for (const key of Object.keys(fields)) {
+        const field = fields[key];
+        if (!field.checkAndSetValid(form ?? this)) {
+          isFormValid = false;
+        }
       }
-    }
-    return isFormValid;
+      return isFormValid && Object.keys(this._globalErrors).length === 0;
+    });
   }
   get fieldsValue() {
     const data = {};
@@ -673,16 +1201,22 @@ var Form = class {
     return data;
   }
   set fields(data) {
-    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];
-        else if (field instanceof ArrayField) field.itemsValue = data[key];
-        else if (field instanceof ArrayFormField) field.forms = data[key];
-        else console.error(`Invalid field "${key}" type`);
+    this.setFields(data);
+  }
+  setFields(data, validate = true) {
+    return this.update(() => {
+      const fields = this._fields;
+      for (const key of Object.keys(data)) {
+        const field = fields[key];
+        if (field) {
+          if (field instanceof Field) field.setRawValue(data[key], false);
+          else if (field instanceof ArrayField) field.setItemsValue(data[key], false);
+          else if (field instanceof ArrayFormField) field.setForms(data[key], false);
+          else console.error(`Invalid field "${key}" type`);
+        }
       }
-    }
+      if (validate) this.validateAfterMutation(() => this.checkValid());
+    });
   }
   get allErrors() {
     const errors = {};
@@ -697,7 +1231,7 @@ var Form = class {
       } else {
         const fieldErrors = field.errors;
         if (fieldErrors.length > 0) {
-          errors[key] = fieldErrors;
+          errors[key] = [...fieldErrors];
         }
       }
     }
@@ -710,7 +1244,7 @@ var Form = class {
     return errors;
   }
   /**
-   * Рекурсивно собирает все ошибки из ArrayFormField
+   * Recursively collect all errors from an ArrayFormField.
    */
   collectArrayFormErrors(arrayField) {
     const allErrors = [];
@@ -730,19 +1264,34 @@ var Form = class {
     return { ...this._globalErrors };
   }
   set errors(errors) {
-    const fields = this._fields;
-    this._globalErrors = {};
-    for (const key of Object.keys(fields)) {
-      fields[key].error = null;
-    }
-    const parsedErrors = this.errorsShema.parseErrors(errors);
-    for (const [fieldName, errorMessage] of Object.entries(parsedErrors)) {
-      this.applyErrorToField(fieldName, errorMessage, fields, this);
-    }
+    this.update(() => {
+      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.update(() => {
+      this._globalErrors = {};
+      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) {
@@ -790,17 +1339,31 @@ var Form = class {
     }
   }
   setGlobalError(key, message) {
-    this._globalErrors[key] = message;
+    return this.update(() => {
+      this._globalErrors[key] = message;
+    });
   }
   clearGlobalErrors() {
-    this._globalErrors = {};
+    return this.update(() => {
+      this._globalErrors = {};
+    });
   }
   reset() {
-    const fields = this._fields;
-    for (const key of Object.keys(fields)) {
-      fields[key].reset();
-    }
-    this._globalErrors = {};
+    return this.update(() => {
+      const fields = this._fields;
+      for (const key of Object.keys(fields)) {
+        fields[key].reset();
+      }
+      this._globalErrors = {};
+    });
+  }
+  get isDirty() {
+    return Object.values(this._fields).some((field) => field.isDirty);
+  }
+  commitBaseline() {
+    return this.update(() => {
+      for (const field of Object.values(this._fields)) field.commitBaseline();
+    });
   }
   get isTouched() {
     const fields = this._fields;
@@ -809,7 +1372,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)) {
@@ -817,32 +1380,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
@@ -862,13 +1443,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() {
@@ -1067,8 +1648,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;
   }
@@ -1081,15 +1666,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");
     }
@@ -1134,7 +1725,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;
@@ -1150,27 +1741,19 @@ 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;
     const parts = normalizedValue.split(".");
     const intPart = parts[0];
     const decPart = parts.length > 1 ? parts[1] : "";
-    if (normalizedValue.endsWith(".")) {
-      if (intPart.length > maxIntDigits) {
-        errors.push(
-          this.options.messages?.maxDigits ?? `\u041C\u0430\u043A\u0441\u0438\u043C\u0430\u043B\u044C\u043D\u043E\u0435 \u043A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0437\u043D\u0430\u043A\u043E\u0432 \u043F\u0435\u0440\u0435\u0434 \u0437\u0430\u043F\u044F\u0442\u043E\u0439 ${maxIntDigits}`
-        );
-      }
-      return errors;
-    }
     if (intPart.length === 0) {
       errors.push(this.options.messages?.invalid ?? "\u041F\u0440\u0438\u043C\u0435\u0440: 1.00");
       return errors;
@@ -1230,10 +1813,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";
   }
@@ -1310,7 +1889,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") {
@@ -1339,6 +1918,8 @@ exports.BasePlugin = BasePlugin;
 exports.BooleanType = BooleanType;
 exports.DateType = DateType;
 exports.DecimalType = DecimalType;
+exports.DefaultErrorsSchema = DefaultErrorsSchema;
+exports.ErrorsSchema = ErrorsSchema;
 exports.Field = Field;
 exports.FieldType = FieldType;
 exports.Form = Form;