adaptform 2.1.0 → 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 ?? []) {
@@ -21,6 +342,33 @@ var Field = class {
       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() {
@@ -32,8 +380,10 @@ var Field = class {
     return this.fieldType.options;
   }
   set options(options) {
-    const currentOptions = this.fieldType.options;
-    this.fieldType.options = Object.assign(currentOptions, options);
+    this.update(() => {
+      const currentOptions = this.fieldType.options;
+      this.fieldType.options = Object.assign(currentOptions, options);
+    });
   }
   get rawValue() {
     return this._rawValue;
@@ -42,14 +392,16 @@ var Field = class {
     this.setRawValue(input);
   }
   setRawValue(input, validate = true) {
-    this.assignRawValue(input);
-    this._errors = [];
-    this.isTouched = true;
-    if (validate) {
-      this.checkAndSetValid();
-    } else {
-      this.isValid = null;
-    }
+    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;
@@ -74,16 +426,26 @@ 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;
@@ -95,41 +457,45 @@ 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;
@@ -140,15 +506,17 @@ var Field = class {
   }
   // ========== Helper methods ==========
   reset() {
-    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.isTouched = false;
+    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.isTouched = false;
+    });
   }
 };
 
@@ -158,28 +526,67 @@ function isValidArrayIndex(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._baseline = [];
     this._hasValidationResult = false;
-    this.isTouched = false;
+    this._isTouched = false;
     this.options = {
       isRequired: true,
       messages: {},
       ...options
     };
     this._items = initial.map((value) => this.factory(value));
-    this.checkValid();
+    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 item of items) {
-      this.add(item, 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((item) => item.valueClear);
@@ -189,20 +596,26 @@ var ArrayField = class {
   }
   // ===== actions =====
   add(value, force_check = true) {
-    const field = this.factory(value);
-    this.isTouched = true;
-    this._items.push(field);
-    if (force_check) this.checkValid();
-    return field;
+    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) {
-    if (!isValidArrayIndex(index, this._items.length)) return;
-    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) {
@@ -215,46 +628,48 @@ var ArrayField = class {
     return isRequired;
   }
   checkValid(form) {
-    this._hasValidationResult = true;
-    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((item) => item.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);
@@ -268,51 +683,90 @@ var ArrayField = class {
     return this._errors[0] ?? "";
   }
   set error(message) {
-    if (message) {
-      this._errors = [message];
-      this._hasValidationResult = true;
-    } else {
-      this._errors = [];
-      this._hasValidationResult = false;
-    }
+    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((item) => item.reset());
-    this._errors = [];
-    this._hasValidationResult = false;
-    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._baseline = [];
     this._hasValidationResult = false;
-    this.isTouched = false;
+    this._isTouched = false;
     this._forms = initial.map((data) => {
       const form = new this.FormConstructor();
       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.setForms(forms);
   }
   setForms(forms, validate = true) {
-    this._forms = [];
-    for (const formData of forms) {
-      this.add(formData, false);
-    }
-    if (validate) this.checkValid();
+    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;
@@ -322,29 +776,38 @@ var ArrayFormField = class {
   }
   // ===== actions =====
   add(data, force_check = true) {
-    const form = new this.FormConstructor();
-    if (data !== void 0 && data !== null) {
-      form.setFields(data, false);
-    }
-    this.isTouched = true;
-    this._forms.push(form);
-    if (force_check) this.checkValid();
-    return form;
+    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) {
-    if (!isValidArrayIndex(index, this._forms.length)) return;
-    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((form) => form.reset());
-    this._errors = [];
-    this._hasValidationResult = false;
-    this.isTouched = false;
+    return this.update(() => {
+      this._forms.forEach((form) => form.reset());
+      this._errors = [];
+      this._hasValidationResult = false;
+      this.isTouched = false;
+    });
   }
   // ===== validation =====
   isRequired(form) {
@@ -357,45 +820,47 @@ var ArrayFormField = class {
     return isRequired;
   }
   checkValid(form) {
-    this._hasValidationResult = true;
-    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 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) {
+    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);
@@ -412,13 +877,15 @@ var ArrayFormField = class {
     return this._errors[0] ?? "";
   }
   set error(message) {
-    if (message) {
-      this._errors = [message];
-      this._hasValidationResult = true;
-    } else {
-      this._errors = [];
-      this._hasValidationResult = false;
-    }
+    this.update(() => {
+      if (message) {
+        this._errors = [message];
+        this._hasValidationResult = true;
+      } else {
+        this._errors = [];
+        this._hasValidationResult = false;
+      }
+    });
   }
 };
 
@@ -673,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)) {
@@ -689,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 && Object.keys(this._globalErrors).length === 0;
+      return isFormValid && Object.keys(this._globalErrors).length === 0;
+    });
   }
   get fieldsValue() {
     const data = {};
@@ -717,17 +1204,19 @@ var Form = class {
     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.setRawValue(data[key], false);
-        else if (field instanceof ArrayField) field.itemsValue = data[key];
-        else if (field instanceof ArrayFormField) field.setForms(data[key], false);
-        else console.error(`Invalid field "${key}" type`);
+    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.checkValid();
+      if (validate) this.validateAfterMutation(() => this.checkValid());
+    });
   }
   get allErrors() {
     const errors = {};
@@ -742,7 +1231,7 @@ var Form = class {
       } else {
         const fieldErrors = field.errors;
         if (fieldErrors.length > 0) {
-          errors[key] = fieldErrors;
+          errors[key] = [...fieldErrors];
         }
       }
     }
@@ -775,26 +1264,30 @@ var Form = class {
     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);
-    }
+    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._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();
+    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.
@@ -846,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;
@@ -1247,14 +1754,6 @@ var DecimalType = class extends FieldType {
     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;