@webiny/app-admin 0.0.0-unstable.e6f0dc8ca7 → 0.0.0-unstable.eb81deee7e

package/features/formModel/FormModel.js

@@ -1,461 +1,458 @@
-import { makeAutoObservable, computed, toJS, runInAction, observable } from "mobx";
+import { computed, makeAutoObservable, observable, runInAction, toJS } from "mobx";
 import { Field } from "./Field.js";
 import { ObjectField, isObjectField } from "./ObjectField.js";
 import { LayoutBuilderFactory } from "./LayoutBuilderFactory.js";
 import { LayoutMutator } from "./LayoutMutator.js";
 import { LayoutResolver } from "./LayoutResolver.js";
 import { FocusManager } from "./FocusManager.js";
-export class FormModel {
-  _fields = new Map();
-  _builders = new Map();
-  _layout = [];
-  _baseline = new Map();
-  _submitted = false;
-  _submitCount = 0;
-  _validateOnChange = false;
-  _isValid = null;
-  _formRuleErrors = [];
-  _activeTabs = observable.map();
-  _ruleEvaluators = [];
-  _warnedRuleTypes = new Set();
-  _formRules = [];
-  _lastFocusedField = null;
-  _layoutMutator = new LayoutMutator();
-  _layoutResolver = null;
-  _focusManager = null;
-  constructor(config, registry) {
-    this._registry = registry;
-    this._ruleEvaluators = config.ruleEvaluators ?? [];
-    const builders = config.fields(registry);
-    for (const [name, builder] of Object.entries(builders)) {
-      this._builders.set(name, builder);
-      const fieldConfig = builder.build(name);
-      const field = this._createField(fieldConfig);
-      field.setForm(this);
-      this._fields.set(name, field);
-    }
-    if (config.layout) {
-      this._layout = LayoutBuilderFactory.buildNodes(config.layout(LayoutBuilderFactory.create()));
-      this._warnOrphanFields();
-    } else {
-      this._layout = this._generateDefaultLayout();
-    }
-    this._registerObjectNodeLayouts(this._layout);
-    this._propagateAncestorRules();
-    this._validateOnChange = config.validateOnSubmit === false;
-    this._snapshotBaseline();
-    makeAutoObservable(this, {
-      vm: computed,
-      _layoutMutator: false,
-      _layoutResolver: false,
-      _focusManager: false
-    }, {
-      autoBind: true
-    });
-    this._layoutResolver = new LayoutResolver(this._fields, this._activeTabs, this.evaluateRules.bind(this));
-    this._focusManager = new FocusManager(this._fields);
-  }
-  evaluateRules(rules) {
-    let visible = true;
-    let disabled = false;
-    if (!rules || rules.length === 0) {
-      return {
-        visible,
-        disabled
-      };
-    }
-    for (const rule of rules) {
-      const evaluator = this._ruleEvaluators.find(e => e.canEvaluate(rule));
-      if (!evaluator) {
-        if (process.env.NODE_ENV === "development" && !this._warnedRuleTypes.has(rule.type)) {
-          this._warnedRuleTypes.add(rule.type);
-          console.warn(`[FormModel] No evaluator registered for rule type "${rule.type}". Rule is ignored.`);
+class FormModel {
+    constructor(config, registry){
+        this._fields = new Map();
+        this._builders = new Map();
+        this._layout = [];
+        this._baseline = new Map();
+        this._submitted = false;
+        this._submitCount = 0;
+        this._validateOnChange = false;
+        this._isValid = null;
+        this._formRuleErrors = [];
+        this._externalErrorFields = new Set();
+        this._activeTabs = observable.map();
+        this._ruleEvaluators = [];
+        this._warnedRuleTypes = new Set();
+        this._formRules = [];
+        this._lastFocusedField = null;
+        this._layoutMutator = new LayoutMutator();
+        this._layoutResolver = null;
+        this._focusManager = null;
+        this._registry = registry;
+        this._ruleEvaluators = config.ruleEvaluators ?? [];
+        const builders = config.fields(registry);
+        for (const [name, builder] of Object.entries(builders)){
+            this._builders.set(name, builder);
+            const fieldConfig = builder.build(name);
+            const field = this._createField(fieldConfig);
+            field.setForm(this);
+            this._fields.set(name, field);
         }
-        continue;
-      }
-      const matched = evaluator.evaluate(rule, this);
-      if (!matched) {
-        continue;
-      }
-      if (rule.action === "hide") {
-        visible = false;
-      } else if (rule.action === "disable") {
-        disabled = true;
-      }
-    }
-    return {
-      visible,
-      disabled
-    };
-  }
-  field(name) {
-    const field = this._fields.get(name);
-    if (field) {
-      return field;
-    }
-    const parts = name.split(".");
-    if (parts.length > 1) {
-      let current = this._fields.get(parts[0]);
-      for (let i = 1; i < parts.length && current; i++) {
-        if (isObjectField(current)) {
-          if (current.isList) {
-            const index = parseInt(parts[i], 10);
-            if (!isNaN(index)) {
-              const item = current.items[index];
-              if (item && i + 1 < parts.length) {
-                current = item.children.get(parts[i + 1]);
-                i++;
-              } else {
-                current = undefined;
-              }
-              continue;
+        if (config.layout) {
+            this._layout = LayoutBuilderFactory.buildNodes(config.layout(LayoutBuilderFactory.create()));
+            this._warnOrphanFields();
+        } else this._layout = this._generateDefaultLayout();
+        this._registerObjectNodeLayouts(this._layout);
+        this._propagateAncestorRules();
+        this._validateOnChange = false === config.validateOnSubmit;
+        this._snapshotBaseline();
+        makeAutoObservable(this, {
+            vm: computed,
+            _builders: false,
+            _layoutMutator: false,
+            _layoutResolver: false,
+            _focusManager: false
+        }, {
+            autoBind: true
+        });
+        this._layoutResolver = new LayoutResolver(this._fields, this._activeTabs, this.evaluateRules.bind(this));
+        this._focusManager = new FocusManager(this._fields);
+    }
+    evaluateRules(rules) {
+        let visible = true;
+        let disabled = false;
+        if (!rules || 0 === rules.length) return {
+            visible,
+            disabled
+        };
+        for (const rule of rules){
+            const evaluator = this._ruleEvaluators.find((e)=>e.canEvaluate(rule));
+            if (!evaluator) {
+                if ("development" === process.env.NODE_ENV && !this._warnedRuleTypes.has(rule.type)) {
+                    this._warnedRuleTypes.add(rule.type);
+                    console.warn(`[FormModel] No evaluator registered for rule type "${rule.type}". Rule is ignored.`);
+                }
+                continue;
+            }
+            const matched = evaluator.evaluate(rule, this);
+            if (matched) {
+                if ("hide" === rule.action) visible = false;
+                else if ("disable" === rule.action) disabled = true;
             }
-          }
-          current = current.getChild(parts[i]);
-        } else {
-          current = undefined;
         }
-      }
-      if (current) {
-        return current;
-      }
-    }
-    throw new Error(`Field "${name}" not found.`);
-  }
-  focusField(name) {
-    if (this._lastFocusedField) {
-      this._lastFocusedField.clearFocusRequest();
-      this._lastFocusedField = null;
-    }
-    const activations = this._focusManager.buildFocusPath(name, this._layout);
-    let field;
-    try {
-      field = this.field(name);
-    } catch {
-      // Field not found — no-op.
-    }
-    runInAction(() => {
-      if (activations) {
-        for (const act of activations) {
-          this._activeTabs.set(act.tabKey, act.tabId);
+        return {
+            visible,
+            disabled
+        };
+    }
+    field(name) {
+        const field = this._fields.get(name);
+        if (field) return field;
+        const parts = name.split(".");
+        if (parts.length > 1) {
+            let current = this._fields.get(parts[0]);
+            for(let i = 1; i < parts.length && current; i++)if (isObjectField(current)) {
+                if (current.isList) {
+                    const index = parseInt(parts[i], 10);
+                    if (!isNaN(index)) {
+                        const item = current.items[index];
+                        if (item && i + 1 < parts.length) {
+                            current = item.children.get(parts[i + 1]);
+                            i++;
+                        } else current = void 0;
+                        continue;
+                    }
+                }
+                current = current.getChild(parts[i]);
+            } else current = void 0;
+            if (current) return current;
         }
-      }
-      if (field) {
-        field.requestFocus();
-        this._lastFocusedField = field;
-      }
-    });
-  }
-  fields(factory) {
-    const builders = factory(this._registry);
-    for (const [name, builder] of Object.entries(builders)) {
-      if (builder === undefined) {
-        this._builders.delete(name);
-        this.removeField(name);
-        continue;
-      }
-      this._builders.set(name, builder);
-      const fieldConfig = builder.build(name);
-      const field = this._createField(fieldConfig);
-      field.setForm(this);
-      this._fields.set(name, field);
-    }
-    this._snapshotBaseline();
-    this._propagateAncestorRules();
-  }
-  layout(factoryOrNodeId) {
-    if (typeof factoryOrNodeId === "string") {
-      return this._layoutMutator.accessNode(this._layout, factoryOrNodeId);
-    }
-    this._layout = this._layoutMutator.applyModifications(this._layout, factoryOrNodeId);
-    this._registerObjectNodeLayouts(this._layout);
-    this._propagateAncestorRules();
-  }
-  removeField(name) {
-    this._fields.delete(name);
-    this._baseline.delete(name);
-    this._layout = this._layoutMutator.removeFromLayout(this._layout, name);
-  }
-  getData() {
-    const data = {};
-    for (const [name, field] of this._fields) {
-      if (isObjectField(field)) {
-        data[name] = toJS(field.getData());
-      } else {
-        data[name] = toJS(field.getValue());
-      }
-    }
-    return data;
-  }
-  setData(data) {
-    for (const [name, value] of Object.entries(data)) {
-      const field = this._fields.get(name);
-      if (field) {
-        field.setValueSilent(value);
-      }
-    }
-    this._snapshotBaseline();
-    this._resetAllValidation();
-    this._submitted = false;
-    this._submitCount = 0;
-    this._isValid = null;
-    this._formRuleErrors = [];
-  }
-  reset() {
-    for (const [name, field] of this._fields) {
-      const baselineValue = this._baseline.get(name);
-      field.setValueSilent(baselineValue ?? field.config.defaultValue ?? null);
-    }
-    this._resetAllValidation();
-    this._submitted = false;
-    this._submitCount = 0;
-    this._isValid = null;
-    this._formRuleErrors = [];
-  }
-  get isDirty() {
-    for (const [name, field] of this._fields) {
-      const baseline = this._baseline.get(name);
-      const current = isObjectField(field) ? field.getData() : field.getValue();
-      if (JSON.stringify(toJS(current)) !== JSON.stringify(toJS(baseline))) {
-        return true;
-      }
-    }
-    return false;
-  }
-  get isValid() {
-    return this._isValid;
-  }
-  get submitted() {
-    return this._submitted;
-  }
-  get submitCount() {
-    return this._submitCount;
-  }
-  get errors() {
-    if (!this._submitted) {
-      return [];
-    }
-    const ruleErrorPaths = new Set(this._formRuleErrors.filter(e => e.path).map(e => e.path));
-    const errors = [];
-    const collectErrors = (fields, pathPrefix, trail) => {
-      for (const [, field] of fields) {
-        const path = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
-        const segment = field.config.label || field.name;
-        if (isObjectField(field)) {
-          if (field.vm.validation.isValid === false && !ruleErrorPaths.has(path)) {
-            errors.push({
-              path,
-              label: field.config.label,
-              breadcrumb: [...trail, segment],
-              message: field.vm.validation.message || "Invalid value."
-            });
-          }
-          if (field.config.isList) {
-            for (const [index, item] of field.items.entries()) {
-              collectErrors(item.children, `${path}.${index}`, [...trail, `${segment} [${index + 1}]`]);
+        throw new Error(`Field "${name}" not found.`);
+    }
+    focusField(name) {
+        if (this._lastFocusedField) {
+            this._lastFocusedField.clearFocusRequest();
+            this._lastFocusedField = null;
+        }
+        const activations = this._focusManager.buildFocusPath(name, this._layout);
+        let field;
+        try {
+            field = this.field(name);
+        } catch  {}
+        runInAction(()=>{
+            if (activations) for (const act of activations)this._activeTabs.set(act.tabKey, act.tabId);
+            if (field) {
+                field.requestFocus();
+                this._lastFocusedField = field;
             }
-          } else {
-            collectErrors(field.children, path, [...trail, segment]);
-          }
-        } else if (field.vm.validation.isValid === false && !ruleErrorPaths.has(path)) {
-          errors.push({
-            path,
-            label: field.config.label,
-            breadcrumb: [...trail, segment],
-            message: field.vm.validation.message || "Invalid value."
-          });
+        });
+    }
+    fields(factory) {
+        const builders = factory(this._registry);
+        for (const [name, builder] of Object.entries(builders)){
+            if (void 0 === builder) {
+                this._builders.delete(name);
+                this.removeField(name);
+                continue;
+            }
+            this._builders.set(name, builder);
+            const fieldConfig = builder.build(name);
+            const field = this._createField(fieldConfig);
+            field.setForm(this);
+            this._fields.set(name, field);
+        }
+        this._snapshotBaseline();
+        this._propagateAncestorRules();
+    }
+    layout(factoryOrNodeId) {
+        if ("string" == typeof factoryOrNodeId) return this._layoutMutator.accessNode(this._layout, factoryOrNodeId);
+        this._layout = this._layoutMutator.applyModifications(this._layout, factoryOrNodeId);
+        this._registerObjectNodeLayouts(this._layout);
+        this._propagateAncestorRules();
+    }
+    removeField(name) {
+        this._fields.delete(name);
+        this._baseline.delete(name);
+        this._layout = this._layoutMutator.removeFromLayout(this._layout, name);
+    }
+    getData() {
+        const data = {};
+        for (const [name, field] of this._fields)if (isObjectField(field)) data[name] = toJS(field.getData());
+        else data[name] = toJS(field.getValue());
+        return data;
+    }
+    setData(data, options) {
+        for (const [name, value] of Object.entries(data)){
+            const field = this._fields.get(name);
+            if (field) field.setValueSilent(value);
+        }
+        if (!options?.dirty) this._snapshotBaseline();
+        this._resetAllValidation();
+        this._submitted = false;
+        this._submitCount = 0;
+        this._isValid = null;
+        this._formRuleErrors = [];
+        this._externalErrorFields.clear();
+    }
+    reset() {
+        for (const [name, field] of this._fields){
+            const baselineValue = this._baseline.get(name);
+            field.setValueSilent(baselineValue ?? field.config.defaultValue ?? null);
         }
-      }
-    };
-    collectErrors(this._fields, "", []);
-    return [...errors, ...this._formRuleErrors];
-  }
-  addRule(rule) {
-    this._formRules.push(rule);
-  }
-  setLayout(factory) {
-    this._layout = LayoutBuilderFactory.buildNodes(factory(LayoutBuilderFactory.create()));
-    this._warnOrphanFields();
-    this._registerObjectNodeLayouts(this._layout);
-    this._propagateAncestorRules();
-  }
-  async validate() {
-    let allFieldsValid = true;
-    for (const [, field] of this._fields) {
-      const valid = await field.validate({
-        force: true
-      });
-      if (!valid) {
-        allFieldsValid = false;
-      }
-    }
-    const ruleErrors = [];
-    for (const rule of this._formRules) {
-      const errors = await this._runFormRule(rule);
-      for (const err of errors) {
-        ruleErrors.push(err);
-        if (err.path) {
-          const target = this._tryGetField(err.path);
-          if (target) {
-            target.setValidation({
-              isValid: false,
-              message: err.message
+        this._resetAllValidation();
+        this._submitted = false;
+        this._submitCount = 0;
+        this._isValid = null;
+        this._formRuleErrors = [];
+        this._externalErrorFields.clear();
+    }
+    get isDirty() {
+        for (const [name, field] of this._fields){
+            const baseline = this._baseline.get(name);
+            const current = isObjectField(field) ? field.getData() : field.getValue();
+            if (JSON.stringify(toJS(current)) !== JSON.stringify(toJS(baseline))) return true;
+        }
+        return false;
+    }
+    get isValid() {
+        return this._isValid;
+    }
+    get submitted() {
+        return this._submitted;
+    }
+    get submitCount() {
+        return this._submitCount;
+    }
+    get errors() {
+        if (!this._submitted) return [];
+        const ruleErrorPaths = new Set(this._formRuleErrors.filter((e)=>e.path).map((e)=>e.path));
+        const errors = [];
+        const collectErrors = (fields, pathPrefix, trail)=>{
+            for (const [, field] of fields){
+                const path = pathPrefix ? `${pathPrefix}.${field.name}` : field.name;
+                const segment = field.config.label || field.name;
+                if (isObjectField(field)) {
+                    if (!field.visible) continue;
+                    if (false === field.vm.validation.isValid && field.vm.validation.message && !ruleErrorPaths.has(path)) errors.push({
+                        path,
+                        label: field.config.label,
+                        breadcrumb: [
+                            ...trail,
+                            segment
+                        ],
+                        message: field.vm.validation.message
+                    });
+                    const skipBreadcrumb = "passthrough" === field.config.renderer && !field.config.label;
+                    const childTrail = skipBreadcrumb ? trail : [
+                        ...trail,
+                        segment
+                    ];
+                    if (field.config.isList) for (const [index, item] of field.items.entries())collectErrors(item.children, `${path}.${index}`, [
+                        ...childTrail
+                    ]);
+                    else collectErrors(field.children, path, childTrail);
+                } else if (field.visible && false === field.vm.validation.isValid && !ruleErrorPaths.has(path)) errors.push({
+                    path,
+                    label: field.config.label,
+                    breadcrumb: [
+                        ...trail,
+                        segment
+                    ],
+                    message: field.vm.validation.message || "Invalid value."
+                });
+            }
+        };
+        collectErrors(this._fields, "", []);
+        return [
+            ...errors,
+            ...this._formRuleErrors
+        ];
+    }
+    addRule(rule) {
+        this._formRules.push(rule);
+    }
+    setLayout(factory) {
+        this._layout = LayoutBuilderFactory.buildNodes(factory(LayoutBuilderFactory.create()));
+        this._warnOrphanFields();
+        this._registerObjectNodeLayouts(this._layout);
+        this._propagateAncestorRules();
+    }
+    async validate() {
+        this._externalErrorFields.clear();
+        let allFieldsValid = true;
+        for (const [, field] of this._fields){
+            const valid = await field.validate({
+                force: true
             });
-          }
+            if (!valid) allFieldsValid = false;
+        }
+        const ruleErrors = [];
+        for (const rule of this._formRules){
+            const errors = await this._runFormRule(rule);
+            for (const err of errors){
+                ruleErrors.push(err);
+                if (err.path) {
+                    const target = this._tryGetField(err.path);
+                    if (target) target.setValidation({
+                        isValid: false,
+                        message: err.message
+                    });
+                }
+            }
         }
-      }
-    }
-    const isValid = allFieldsValid && ruleErrors.length === 0;
-    runInAction(() => {
-      this._formRuleErrors = ruleErrors;
-      this._isValid = isValid;
-      this._submitted = true;
-      this._submitCount++;
-    });
-    return isValid;
-  }
-  async submit() {
-    const valid = await this.validate();
-    if (!valid) {
-      return false;
-    }
-    return this.getData();
-  }
-  get vm() {
-    return {
-      layout: this._layoutResolver.resolve(this._layout),
-      errors: this.errors,
-      isDirty: this.isDirty,
-      isValid: this._isValid,
-      submitCount: this._submitCount,
-      focusField: path => this.focusField(path),
-      getData: () => this.getData(),
-      setData: data => this.setData(data)
-    };
-  }
-  get registry() {
-    return this._registry;
-  }
-  resolveChildLayout(layout, children) {
-    return this._layoutResolver.resolveChildLayout(layout, children);
-  }
-  getField(name) {
-    return this._fields.get(name);
-  }
-  getFields() {
-    return this._fields;
-  }
-  getFieldBuilders(predicate) {
-    const pred = predicate ?? (() => true);
-    const result = [];
-    LayoutBuilderFactory.collectBuilders(this._fields, this._builders, pred, result);
-    return result;
-  }
-  async _runFormRule(rule) {
-    if (typeof rule === "function") {
-      const fn = rule;
-      const result = await fn(this);
-      return Array.isArray(result) ? result : [];
-    }
-    const data = this.getData();
-    const result = await rule.safeParseAsync(data);
-    if (result.success) {
-      return [];
-    }
-    return result.error.issues.map(issue => {
-      const path = issue.path.map(String).join(".");
-      const field = path ? this._tryGetField(path) : undefined;
-      return {
-        path,
-        label: field?.config.label,
-        message: issue.message || "Invalid value."
-      };
-    });
-  }
-  _tryGetField(path) {
-    try {
-      return this.field(path);
-    } catch {
-      return undefined;
-    }
-  }
-  _registerObjectNodeLayouts(layout) {
-    for (const node of layout) {
-      if (node.type === "object") {
-        const field = this._fields.get(node.fieldName);
-        if (field && isObjectField(field)) {
-          field.setInnerLayout(node.inner);
+        const isValid = allFieldsValid && 0 === ruleErrors.length;
+        runInAction(()=>{
+            this._formRuleErrors = ruleErrors;
+            this._isValid = isValid;
+            this._submitted = true;
+            this._submitCount++;
+        });
+        return isValid;
+    }
+    setErrors(errors) {
+        const formErrors = [];
+        runInAction(()=>{
+            for (const field of this._externalErrorFields)field.resetValidation();
+            this._externalErrorFields.clear();
+            for (const error of errors){
+                const field = error.path ? this._tryGetField(error.path) : void 0;
+                if (field?.visible) {
+                    field.setValidation({
+                        isValid: false,
+                        message: error.message
+                    });
+                    this._externalErrorFields.add(field);
+                } else formErrors.push(error);
+            }
+            this._formRuleErrors = formErrors;
+            this._isValid = 0 === errors.length;
+            this._submitted = true;
+            this._submitCount++;
+        });
+    }
+    async submit(options) {
+        if (options?.skipValidation) return this.getData();
+        const valid = await this.validate();
+        if (!valid) return false;
+        return this.getData();
+    }
+    get vm() {
+        return {
+            layout: this._layoutResolver.resolve(this._layout),
+            errors: this.errors,
+            hasErrors: this.errors.length > 0,
+            isDirty: this.isDirty,
+            isValid: this._isValid,
+            submitCount: this._submitCount,
+            focusField: (path)=>this.focusField(path),
+            getData: ()=>this.getData(),
+            setData: (data, options)=>this.setData(data, options)
+        };
+    }
+    get registry() {
+        return this._registry;
+    }
+    resolveChildLayout(layout, children) {
+        return this._layoutResolver.resolveChildLayout(layout, children);
+    }
+    getField(name) {
+        return this._fields.get(name);
+    }
+    getFields() {
+        return this._fields;
+    }
+    getFieldBuilders(predicate) {
+        const pred = predicate ?? (()=>true);
+        const result = [];
+        LayoutBuilderFactory.collectBuilders(this._fields, this._builders, pred, result);
+        return result;
+    }
+    traverse(callback) {
+        this._traverseBuilders(this._fields, this._builders, callback);
+    }
+    _traverseBuilders(fields, builders, callback) {
+        const entries = builders instanceof Map ? builders.entries() : Object.entries(builders);
+        for (const [name, builder] of entries){
+            if (!builder || "object" != typeof builder) continue;
+            callback(builder);
+            const field = fields.get(name);
+            if (field && isObjectField(field)) {
+                this._traverseBuilders(field.children, field.config.childBuilders, callback);
+                const templates = field.config.templates;
+                if (templates) {
+                    for (const tpl of templates)for (const tplBuilder of Object.values(tpl.childBuilders))if (tplBuilder && "object" == typeof tplBuilder) callback(tplBuilder);
+                }
+            }
         }
-      } else if (node.type === "tabs") {
-        for (const tab of node.tabs) {
-          this._registerObjectNodeLayouts(tab.layout);
+    }
+    async _runFormRule(rule) {
+        if ("function" == typeof rule) {
+            const fn = rule;
+            const result = await fn(this);
+            return Array.isArray(result) ? result : [];
         }
-      }
-    }
-  }
-  _propagateAncestorRules() {
-    const ancestry = new Map();
-    const walk = (nodes, rules) => {
-      for (const node of nodes) {
-        if (node.type === "row") {
-          for (const id of node.fieldIds) {
-            const existing = ancestry.get(id) ?? [];
-            ancestry.set(id, [...existing, ...rules]);
-          }
-        } else if (node.type === "tabs") {
-          const containerRules = [...rules, ...(node.rules ?? [])];
-          for (const tab of node.tabs) {
-            const tabRules = [...containerRules, ...(tab.rules ?? [])];
-            walk(tab.layout, tabRules);
-          }
-        } else if (node.type === "object") {
-          const existing = ancestry.get(node.fieldName) ?? [];
-          ancestry.set(node.fieldName, [...existing, ...rules]);
+        const data = this.getData();
+        const result = await rule.safeParseAsync(data);
+        if (result.success) return [];
+        return result.error.issues.map((issue)=>{
+            const path = issue.path.map(String).join(".");
+            const field = path ? this._tryGetField(path) : void 0;
+            return {
+                path,
+                label: field?.config.label,
+                message: issue.message || "Invalid value."
+            };
+        });
+    }
+    _tryGetField(path) {
+        try {
+            return this.field(path);
+        } catch  {
+            return;
         }
-      }
-    };
-    walk(this._layout, []);
-    for (const [, field] of this._fields) {
-      field.setAncestorRules(ancestry.get(field.name) ?? []);
-    }
-  }
-  _generateDefaultLayout() {
-    const layout = [];
-    for (const [name, field] of this._fields) {
-      if (field.visible) {
-        layout.push({
-          type: "row",
-          fieldIds: [name]
+    }
+    _registerObjectNodeLayouts(layout) {
+        for (const node of layout)if ("object" === node.type) {
+            const field = this._fields.get(node.fieldName);
+            if (field && isObjectField(field)) field.setInnerLayout(node.inner);
+        } else if ("tabs" === node.type) for (const tab of node.tabs)this._registerObjectNodeLayouts(tab.layout);
+    }
+    _propagateAncestorRules() {
+        const ancestry = new Map();
+        const walk = (nodes, rules)=>{
+            for (const node of nodes)if ("row" === node.type) for (const id of node.fieldIds){
+                const existing = ancestry.get(id) ?? [];
+                ancestry.set(id, [
+                    ...existing,
+                    ...rules
+                ]);
+            }
+            else if ("tabs" === node.type) {
+                const containerRules = [
+                    ...rules,
+                    ...node.rules ?? []
+                ];
+                for (const tab of node.tabs){
+                    const tabRules = [
+                        ...containerRules,
+                        ...tab.rules ?? []
+                    ];
+                    walk(tab.layout, tabRules);
+                }
+            } else if ("object" === node.type) {
+                const existing = ancestry.get(node.fieldName) ?? [];
+                ancestry.set(node.fieldName, [
+                    ...existing,
+                    ...rules
+                ]);
+            }
+        };
+        walk(this._layout, []);
+        for (const [, field] of this._fields)field.setAncestorRules(ancestry.get(field.name) ?? []);
+    }
+    _generateDefaultLayout() {
+        const layout = [];
+        for (const [name, field] of this._fields)if (field.visible) layout.push({
+            type: "row",
+            fieldIds: [
+                name
+            ]
         });
-      }
-    }
-    return layout;
-  }
-  _warnOrphanFields() {
-    const layoutFieldIds = new Set(LayoutBuilderFactory.collectFieldIds(this._layout));
-    for (const [name, field] of this._fields) {
-      if (field.visible && !layoutFieldIds.has(name)) {
-        console.warn(`[FormModel] Field "${name}" is not in the layout and not marked as .hidden(). ` + `Add it to the layout or mark it as .hidden() to suppress this warning.`);
-      }
-    }
-  }
-  _snapshotBaseline() {
-    this._baseline.clear();
-    for (const [name, field] of this._fields) {
-      this._baseline.set(name, toJS(field.getValue()));
-    }
-  }
-  _resetAllValidation() {
-    for (const [, field] of this._fields) {
-      field.resetValidation();
-    }
-  }
-  _createField(config) {
-    if (config.childBuilders) {
-      return new ObjectField(config);
-    }
-    return new Field(config);
-  }
+        return layout;
+    }
+    _warnOrphanFields() {
+        const layoutFieldIds = new Set(LayoutBuilderFactory.collectFieldIds(this._layout));
+        for (const [name, field] of this._fields)if (field.visible && !layoutFieldIds.has(name)) console.warn(`[FormModel] Field "${name}" is not in the layout and not marked as .hidden(). Add it to the layout or mark it as .hidden() to suppress this warning.`);
+    }
+    _snapshotBaseline() {
+        this._baseline.clear();
+        for (const [name, field] of this._fields)this._baseline.set(name, toJS(field.getValue()));
+    }
+    _resetAllValidation() {
+        for (const [, field] of this._fields)field.resetValidation();
+    }
+    _createField(config) {
+        if (config.childBuilders) return new ObjectField(config);
+        return new Field(config);
+    }
 }
+export { FormModel };
 
 //# sourceMappingURL=FormModel.js.map