@strictly/react-form 0.0.25 → 0.0.27

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: es6
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 61.91 KB
-CJS ⚡️ Build success in 125ms
-ESM dist/index.js 57.87 KB
-ESM ⚡️ Build success in 146ms
+CJS dist/index.cjs 63.79 KB
+CJS ⚡️ Build success in 126ms
+ESM dist/index.js 59.70 KB
+ESM ⚡️ Build success in 132ms
 DTS Build start
-DTS ⚡️ Build success in 31902ms
-DTS dist/index.d.cts 37.37 KB
-DTS dist/index.d.ts  37.37 KB
-Done in 33.10s.
+DTS ⚡️ Build success in 32334ms
+DTS dist/index.d.cts 38.14 KB
+DTS dist/index.d.ts  38.14 KB
+Done in 33.47s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc -b
-Done in 0.35s.
+Done in 0.40s.

package/core/mobx/form_model.ts

@@ -12,6 +12,7 @@ import {
 import {
   type Accessor,
   type AnyValueType,
+  equals,
   flattenAccessorsOfType,
   type FlattenedValuesOfType,
   flattenTypesOfType,
@@ -88,6 +89,12 @@ type FlattenedFieldOverrides<
   >
 }
 
+type FlattenedErrorOverrides<
+  ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>,
+> = {
+  -readonly [K in keyof ValuePathsToAdapters]?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>
+}
+
 export enum Validation {
   None = 0,
   Changed = 1,
@@ -144,6 +151,8 @@ export abstract class FormModel<
   @observable.shallow
   accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>
   @observable.shallow
+  accessor errorOverrides: FlattenedErrorOverrides<ValuePathsToAdapters> = {}
+  @observable.shallow
   accessor validation: FlattenedValidation<ValuePathsToAdapters> = {}
 
   private readonly flattenedTypeDefs: Readonly<Record<string, Type>>
@@ -341,39 +350,42 @@ export abstract class FormModel<
       defaultValue,
     } = field
     const validation = this.validation[valuePath] ?? Validation.None
-    let error: unknown
-    switch (validation) {
-      case Validation.None:
-        // skip validation
-        break
-      case Validation.Changed:
-        if (revert != null) {
-          const originalValue = valuePath in this.originalValues
+    let error: unknown = this.errorOverrides[valuePath]
+    if (error == null) {
+      switch (validation) {
+        case Validation.None:
+          // skip validation
+          break
+        case Validation.Changed:
+          if (revert != null) {
+            const originalValue = valuePath in this.originalValues
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              ? this.originalValues[valuePath as string]
+              : defaultValue
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            ? this.originalValues[valuePath as string]
-            : defaultValue
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          const { value: originalDisplayedValue } = convert(originalValue, valuePath as string, context)
-          // TODO better comparisons, displayed values can still be complex
-          if (displayedValue !== originalDisplayedValue) {
-            const revertResult = revert(displayedValue, valuePath, context)
+            const { value: originalDisplayedValue } = convert(originalValue, valuePath as string, context)
+            // TODO better comparisons, displayed values can still be complex
+            if (displayedValue !== originalDisplayedValue) {
+              const revertResult = revert(displayedValue, valuePath, context)
+              if (revertResult?.type === UnreliableFieldConversionType.Failure) {
+                ;({ error } = revertResult)
+              }
+            }
+          }
+          break
+        case Validation.Always:
+          {
+            const revertResult = revert?.(displayedValue, valuePath, context)
             if (revertResult?.type === UnreliableFieldConversionType.Failure) {
               ;({ error } = revertResult)
             }
           }
-        }
-        break
-      case Validation.Always:
-        {
-          const revertResult = revert?.(displayedValue, valuePath, context)
-          if (revertResult?.type === UnreliableFieldConversionType.Failure) {
-            ;({ error } = revertResult)
-          }
-        }
-        break
-      default:
-        throw new UnreachableError(validation)
+          break
+        default:
+          throw new UnreachableError(validation)
+      }
     }
+
     return {
       value: displayedValue,
       error,
@@ -414,6 +426,14 @@ export abstract class FormModel<
     )
   }
 
+  @computed
+  get dirty() {
+    return Object.keys(this.accessors).some((valuePath) => {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return this.isFieldDirty(valuePath as keyof ValuePathsToAdapters)
+    })
+  }
+
   typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K] {
     return valuePathToTypePath<ValueToTypePaths, K>(this.type, valuePath, true)
   }
@@ -579,6 +599,8 @@ export abstract class FormModel<
           const validation = this.validation[fromJsonPath]
           delete this.validation[fromJsonPath]
           this.validation[toJsonPath] = validation
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+          this.moveListItem(fromJsonPath as any, toJsonPath as any)
         })
         accessor.set(newList)
         // delete any value overrides so the new list isn't shadowed
@@ -588,6 +610,13 @@ export abstract class FormModel<
     })
   }
 
+  protected moveListItem<K extends keyof FlattenedListTypesOfType<T>>(fromValuePath: K, toValuePath: K) {
+    // do nothing, this is for subclasses to override
+    // put in some nonsense so TS doesn't complain about the parameters not being used
+    fromValuePath satisfies K
+    toValuePath satisfies K
+  }
+
   private internalSetFieldValue<K extends keyof ValuePathsToAdapters>(
     valuePath: K,
     value: ToOfFieldAdapter<ValuePathsToAdapters[K]>,
@@ -602,6 +631,7 @@ export abstract class FormModel<
     const accessor = this.getAccessorForValuePath(valuePath)
     return runInAction(() => {
       this.fieldOverrides[valuePath] = [value]
+      delete this.errorOverrides[valuePath]
       if (validation != null) {
         this.validation[valuePath] = validation
       }
@@ -620,11 +650,30 @@ export abstract class FormModel<
     })
   }
 
+  /**
+   * Forces an error onto a field. Error will be removed if the field value changes
+   * @param valuePath the field to display an error for
+   * @param error the error to display
+   */
+  overrideFieldError<K extends keyof ValuePathsToAdapters>(
+    valuePath: K,
+    error?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>,
+  ) {
+    runInAction(() => {
+      if (error) {
+        this.errorOverrides[valuePath] = error
+      } else {
+        delete this.errorOverrides[valuePath]
+      }
+    })
+  }
+
   clearFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K) {
     const fieldOverride = this.fieldOverrides[valuePath]
     if (fieldOverride != null) {
       runInAction(() => {
         delete this.validation[valuePath]
+        delete this.errorOverrides[valuePath]
       })
     }
   }
@@ -651,6 +700,7 @@ export abstract class FormModel<
     runInAction(() => {
       this.fieldOverrides[key] = [displayValue]
       delete this.validation[key]
+      delete this.errorOverrides[key]
     })
   }
 
@@ -659,6 +709,7 @@ export abstract class FormModel<
       this.validation = {}
       // TODO this isn't correct, should reload from value
       this.fieldOverrides = {}
+      this.errorOverrides = {}
       this.value = mobxCopy(this.type, value)
     })
   }
@@ -674,7 +725,7 @@ export abstract class FormModel<
     return this.validation[valuePath] ?? Validation.None
   }
 
-  isDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean {
+  isFieldDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const typePath = valuePathToTypePath<ValueToTypePaths, keyof ValueToTypePaths>(
       this.type,
@@ -691,18 +742,33 @@ export abstract class FormModel<
     const {
       displayedValue,
       convert,
+      revert,
       context,
       defaultValue,
     } = field
 
+    // if either the display value, or the stored value, match the original, then assume it's not dirty
     const originalValue = valuePath in this.originalValues
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       ? this.originalValues[valuePath as string]
       : defaultValue
+    if (revert != null) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const typeDef = this.flattenedTypeDefs[typePath as string]
+      const {
+        value,
+        type,
+      } = revert(displayedValue, valuePath, context)
+      if (type === UnreliableFieldConversionType.Success) {
+        if (equals(typeDef, originalValue, value)) {
+          return false
+        }
+      }
+    }
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const { value: originalDisplayedValue } = convert(originalValue, valuePath as string, context)
-    // TODO better comparisons, displayed values can still be complex
-    return (displayedValue !== originalDisplayedValue)
+    // try to compare the displayed values directly if we can't revert the displayed value
+    return displayedValue !== originalDisplayedValue
   }
 
   validateField<K extends keyof ValuePathsToAdapters>(
@@ -711,6 +777,7 @@ export abstract class FormModel<
   ): boolean {
     runInAction(() => {
       this.validation[valuePath] = validation
+      delete this.errorOverrides[valuePath]
     })
     return this.fields[valuePath].error == null
   }
@@ -732,4 +799,8 @@ export abstract class FormModel<
       },
     )
   }
+
+  validateSubmit() {
+    return this.validateAll()
+  }
 }

package/core/mobx/hooks.tsx

@@ -66,8 +66,8 @@ export function useDefaultMobxFormHooks<
       // (e.g. changing a discriminator)
       // TODO debounce?
       setTimeout(function () {
-        // only start validation if the user has changed the field
-        if (model.isValuePathActive(path) && model.isDirty(path)) {
+        // only start validation if the user has changed the field and there isn't already an error visible
+        if (model.isValuePathActive(path) && model.isFieldDirty(path) && model.fields[path].error == null) {
           // further workaround to make sure we don't downgrade the existing validation
           model.validateField(path, Math.max(Validation.Changed, model.getValidation(path)))
         }
@@ -78,7 +78,7 @@ export function useDefaultMobxFormHooks<
 
   const onFormSubmit = useCallback(
     function () {
-      if (model.validateAll()) {
+      if (model.validateSubmit()) {
         onValidFormSubmit?.(model.value)
       }
     },

package/dist/index.cjs

@@ -363,8 +363,8 @@ var Validation = /* @__PURE__ */ ((Validation2) => {
   Validation2[Validation2["Always"] = 2] = "Always";
   return Validation2;
 })(Validation || {});
-var _accessors_dec, _knownFields_dec, _fields_dec, _validation_dec, _fieldOverrides_dec, _value_dec, _init, _value, _fieldOverrides, _validation;
-_value_dec = [import_mobx.observable.ref], _fieldOverrides_dec = [import_mobx.observable.shallow], _validation_dec = [import_mobx.observable.shallow], _fields_dec = [import_mobx.computed], _knownFields_dec = [import_mobx.computed], _accessors_dec = [import_mobx.computed];
+var _dirty_dec, _accessors_dec, _knownFields_dec, _fields_dec, _validation_dec, _errorOverrides_dec, _fieldOverrides_dec, _value_dec, _init, _value, _fieldOverrides, _errorOverrides, _validation;
+_value_dec = [import_mobx.observable.ref], _fieldOverrides_dec = [import_mobx.observable.shallow], _errorOverrides_dec = [import_mobx.observable.shallow], _validation_dec = [import_mobx.observable.shallow], _fields_dec = [import_mobx.computed], _knownFields_dec = [import_mobx.computed], _accessors_dec = [import_mobx.computed], _dirty_dec = [import_mobx.computed];
 var FormModel = class {
   constructor(type, originalValue, adapters, mode) {
     this.type = type;
@@ -373,7 +373,8 @@ var FormModel = class {
     __runInitializers(_init, 5, this);
     __privateAdd(this, _value, __runInitializers(_init, 8, this)), __runInitializers(_init, 11, this);
     __privateAdd(this, _fieldOverrides, __runInitializers(_init, 12, this)), __runInitializers(_init, 15, this);
-    __privateAdd(this, _validation, __runInitializers(_init, 16, this, {})), __runInitializers(_init, 19, this);
+    __privateAdd(this, _errorOverrides, __runInitializers(_init, 16, this, {})), __runInitializers(_init, 19, this);
+    __privateAdd(this, _validation, __runInitializers(_init, 20, this, {})), __runInitializers(_init, 23, this);
     __publicField(this, "flattenedTypeDefs");
     // cannot be type safe
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -520,34 +521,36 @@ var FormModel = class {
       defaultValue
     } = field;
     const validation = (_a = this.validation[valuePath]) != null ? _a : 0 /* None */;
-    let error;
-    switch (validation) {
-      case 0 /* None */:
-        break;
-      case 1 /* Changed */:
-        if (revert != null) {
-          const originalValue = valuePath in this.originalValues ? this.originalValues[valuePath] : defaultValue;
-          const { value: originalDisplayedValue } = convert(originalValue, valuePath, context);
-          if (displayedValue !== originalDisplayedValue) {
-            const revertResult = revert(displayedValue, valuePath, context);
+    let error = this.errorOverrides[valuePath];
+    if (error == null) {
+      switch (validation) {
+        case 0 /* None */:
+          break;
+        case 1 /* Changed */:
+          if (revert != null) {
+            const originalValue = valuePath in this.originalValues ? this.originalValues[valuePath] : defaultValue;
+            const { value: originalDisplayedValue } = convert(originalValue, valuePath, context);
+            if (displayedValue !== originalDisplayedValue) {
+              const revertResult = revert(displayedValue, valuePath, context);
+              if ((revertResult == null ? void 0 : revertResult.type) === 1 /* Failure */) {
+                ;
+                ({ error } = revertResult);
+              }
+            }
+          }
+          break;
+        case 2 /* Always */:
+          {
+            const revertResult = revert == null ? void 0 : revert(displayedValue, valuePath, context);
             if ((revertResult == null ? void 0 : revertResult.type) === 1 /* Failure */) {
               ;
               ({ error } = revertResult);
             }
           }
-        }
-        break;
-      case 2 /* Always */:
-        {
-          const revertResult = revert == null ? void 0 : revert(displayedValue, valuePath, context);
-          if ((revertResult == null ? void 0 : revertResult.type) === 1 /* Failure */) {
-            ;
-            ({ error } = revertResult);
-          }
-        }
-        break;
-      default:
-        throw new import_base2.UnreachableError(validation);
+          break;
+        default:
+          throw new import_base2.UnreachableError(validation);
+      }
     }
     return {
       value: displayedValue,
@@ -580,6 +583,11 @@ var FormModel = class {
       valuePath
     );
   }
+  get dirty() {
+    return Object.keys(this.accessors).some((valuePath) => {
+      return this.isFieldDirty(valuePath);
+    });
+  }
   typePath(valuePath) {
     return (0, import_define.valuePathToTypePath)(this.type, valuePath, true);
   }
@@ -712,12 +720,17 @@ var FormModel = class {
           const validation = this.validation[fromJsonPath];
           delete this.validation[fromJsonPath];
           this.validation[toJsonPath] = validation;
+          this.moveListItem(fromJsonPath, toJsonPath);
         });
         accessor.set(newList);
         delete this.fieldOverrides[listValuePath];
       });
     });
   }
+  moveListItem(fromValuePath, toValuePath) {
+    fromValuePath;
+    toValuePath;
+  }
   internalSetFieldValue(valuePath, value, validation) {
     const { revert } = this.getAdapterForValuePath(valuePath);
     (0, import_base2.assertExists)(revert, "setting value not supported {}", valuePath);
@@ -725,6 +738,7 @@ var FormModel = class {
     const accessor = this.getAccessorForValuePath(valuePath);
     return (0, import_mobx.runInAction)(() => {
       this.fieldOverrides[valuePath] = [value];
+      delete this.errorOverrides[valuePath];
       if (validation != null) {
         this.validation[valuePath] = validation;
       }
@@ -742,11 +756,26 @@ var FormModel = class {
       }
     });
   }
+  /**
+   * Forces an error onto a field. Error will be removed if the field value changes
+   * @param valuePath the field to display an error for
+   * @param error the error to display
+   */
+  overrideFieldError(valuePath, error) {
+    (0, import_mobx.runInAction)(() => {
+      if (error) {
+        this.errorOverrides[valuePath] = error;
+      } else {
+        delete this.errorOverrides[valuePath];
+      }
+    });
+  }
   clearFieldError(valuePath) {
     const fieldOverride = this.fieldOverrides[valuePath];
     if (fieldOverride != null) {
       (0, import_mobx.runInAction)(() => {
         delete this.validation[valuePath];
+        delete this.errorOverrides[valuePath];
       });
     }
   }
@@ -769,12 +798,14 @@ var FormModel = class {
     (0, import_mobx.runInAction)(() => {
       this.fieldOverrides[key] = [displayValue];
       delete this.validation[key];
+      delete this.errorOverrides[key];
     });
   }
   clearAll(value) {
     (0, import_mobx.runInAction)(() => {
       this.validation = {};
       this.fieldOverrides = {};
+      this.errorOverrides = {};
       this.value = (0, import_define.mobxCopy)(this.type, value);
     });
   }
@@ -787,7 +818,7 @@ var FormModel = class {
     var _a;
     return (_a = this.validation[valuePath]) != null ? _a : 0 /* None */;
   }
-  isDirty(valuePath) {
+  isFieldDirty(valuePath) {
     const typePath = (0, import_define.valuePathToTypePath)(
       this.type,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -801,16 +832,30 @@ var FormModel = class {
     const {
       displayedValue,
       convert,
+      revert,
       context,
       defaultValue
     } = field;
     const originalValue = valuePath in this.originalValues ? this.originalValues[valuePath] : defaultValue;
+    if (revert != null) {
+      const typeDef = this.flattenedTypeDefs[typePath];
+      const {
+        value,
+        type
+      } = revert(displayedValue, valuePath, context);
+      if (type === 0 /* Success */) {
+        if ((0, import_define.equals)(typeDef, originalValue, value)) {
+          return false;
+        }
+      }
+    }
     const { value: originalDisplayedValue } = convert(originalValue, valuePath, context);
     return displayedValue !== originalDisplayedValue;
   }
   validateField(valuePath, validation = 2 /* Always */) {
     (0, import_mobx.runInAction)(() => {
       this.validation[valuePath] = validation;
+      delete this.errorOverrides[valuePath];
     });
     return this.fields[valuePath].error == null;
   }
@@ -828,17 +873,23 @@ var FormModel = class {
       }
     );
   }
+  validateSubmit() {
+    return this.validateAll();
+  }
 };
 _init = __decoratorStart(null);
 _value = new WeakMap();
 _fieldOverrides = new WeakMap();
+_errorOverrides = new WeakMap();
 _validation = new WeakMap();
 __decorateElement(_init, 4, "value", _value_dec, FormModel, _value);
 __decorateElement(_init, 4, "fieldOverrides", _fieldOverrides_dec, FormModel, _fieldOverrides);
+__decorateElement(_init, 4, "errorOverrides", _errorOverrides_dec, FormModel, _errorOverrides);
 __decorateElement(_init, 4, "validation", _validation_dec, FormModel, _validation);
 __decorateElement(_init, 2, "fields", _fields_dec, FormModel);
 __decorateElement(_init, 2, "knownFields", _knownFields_dec, FormModel);
 __decorateElement(_init, 2, "accessors", _accessors_dec, FormModel);
+__decorateElement(_init, 2, "dirty", _dirty_dec, FormModel);
 __decoratorMetadata(_init, FormModel);
 
 // core/mobx/hooks.tsx
@@ -869,7 +920,7 @@ function useDefaultMobxFormHooks(model, {
   const onFieldBlur = (0, import_react.useCallback)(
     function(path) {
       setTimeout(function() {
-        if (model.isValuePathActive(path) && model.isDirty(path)) {
+        if (model.isValuePathActive(path) && model.isFieldDirty(path) && model.fields[path].error == null) {
           model.validateField(path, Math.max(1 /* Changed */, model.getValidation(path)));
         }
       }, 100);
@@ -878,7 +929,7 @@ function useDefaultMobxFormHooks(model, {
   );
   const onFormSubmit = (0, import_react.useCallback)(
     function() {
-      if (model.validateAll()) {
+      if (model.validateSubmit()) {
         onValidFormSubmit == null ? void 0 : onValidFormSubmit(model.value);
       }
     },

package/dist/index.d.cts

@@ -112,6 +112,9 @@ type FieldOverride<V = any> = Maybe<V>;
 type FlattenedFieldOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
     -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<ToOfFieldAdapter<ValuePathsToAdapters[K]>>;
 };
+type FlattenedErrorOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>;
+};
 declare enum Validation {
     None = 0,
     Changed = 1,
@@ -133,6 +136,7 @@ declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readon
     protected readonly mode: FormMode;
     accessor value: MobxValueOfType<T>;
     accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
+    accessor errorOverrides: FlattenedErrorOverrides<ValuePathsToAdapters>;
     accessor validation: FlattenedValidation<ValuePathsToAdapters>;
     private readonly flattenedTypeDefs;
     private readonly originalValues;
@@ -148,19 +152,28 @@ declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readon
     get accessors(): Readonly<Record<string, Accessor>>;
     private maybeGetAdapterForValuePath;
     private getAdapterForValuePath;
+    get dirty(): boolean;
     typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K];
     setFieldValue<K extends keyof ValuePathsToAdapters>(valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>, validation?: Validation): boolean;
     addListItem<K extends keyof FlattenedListTypesOfType<T>>(valuePath: K, elementValue?: Maybe<ElementOfArray<FlattenedValuesOfType<T>[K]>>, index?: number): void;
     removeListItem<K extends keyof FlattenedListTypesOfType<T>>(...elementValuePaths: readonly `${K}.${number}`[]): void;
+    protected moveListItem<K extends keyof FlattenedListTypesOfType<T>>(fromValuePath: K, toValuePath: K): void;
     private internalSetFieldValue;
+    /**
+     * Forces an error onto a field. Error will be removed if the field value changes
+     * @param valuePath the field to display an error for
+     * @param error the error to display
+     */
+    overrideFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K, error?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>): void;
     clearFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K): void;
     clearFieldValue<K extends StringKeyOf<ValuePathsToAdapters>>(valuePath: K): void;
     clearAll(value: ValueOfType<T>): void;
     isValuePathActive<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
     getValidation<K extends keyof ValuePathsToAdapters>(valuePath: K): Validation;
-    isDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
+    isFieldDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
     validateField<K extends keyof ValuePathsToAdapters>(valuePath: K, validation?: Validation): boolean;
     validateAll(validation?: Validation): boolean;
+    validateSubmit(): boolean;
 }
 
 type ValueOfModel<M extends FormModel<any, any, any, any, any>> = M extends FormModel<infer T, any, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;

package/dist/index.d.ts

@@ -112,6 +112,9 @@ type FieldOverride<V = any> = Maybe<V>;
 type FlattenedFieldOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
     -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<ToOfFieldAdapter<ValuePathsToAdapters[K]>>;
 };
+type FlattenedErrorOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>;
+};
 declare enum Validation {
     None = 0,
     Changed = 1,
@@ -133,6 +136,7 @@ declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readon
     protected readonly mode: FormMode;
     accessor value: MobxValueOfType<T>;
     accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
+    accessor errorOverrides: FlattenedErrorOverrides<ValuePathsToAdapters>;
     accessor validation: FlattenedValidation<ValuePathsToAdapters>;
     private readonly flattenedTypeDefs;
     private readonly originalValues;
@@ -148,19 +152,28 @@ declare abstract class FormModel<T extends Type, ValueToTypePaths extends Readon
     get accessors(): Readonly<Record<string, Accessor>>;
     private maybeGetAdapterForValuePath;
     private getAdapterForValuePath;
+    get dirty(): boolean;
     typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K];
     setFieldValue<K extends keyof ValuePathsToAdapters>(valuePath: K, value: ToOfFieldAdapter<ValuePathsToAdapters[K]>, validation?: Validation): boolean;
     addListItem<K extends keyof FlattenedListTypesOfType<T>>(valuePath: K, elementValue?: Maybe<ElementOfArray<FlattenedValuesOfType<T>[K]>>, index?: number): void;
     removeListItem<K extends keyof FlattenedListTypesOfType<T>>(...elementValuePaths: readonly `${K}.${number}`[]): void;
+    protected moveListItem<K extends keyof FlattenedListTypesOfType<T>>(fromValuePath: K, toValuePath: K): void;
     private internalSetFieldValue;
+    /**
+     * Forces an error onto a field. Error will be removed if the field value changes
+     * @param valuePath the field to display an error for
+     * @param error the error to display
+     */
+    overrideFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K, error?: ErrorOfFieldAdapter<ValuePathsToAdapters[K]>): void;
     clearFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K): void;
     clearFieldValue<K extends StringKeyOf<ValuePathsToAdapters>>(valuePath: K): void;
     clearAll(value: ValueOfType<T>): void;
     isValuePathActive<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
     getValidation<K extends keyof ValuePathsToAdapters>(valuePath: K): Validation;
-    isDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
+    isFieldDirty<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean;
     validateField<K extends keyof ValuePathsToAdapters>(valuePath: K, validation?: Validation): boolean;
     validateAll(validation?: Validation): boolean;
+    validateSubmit(): boolean;
 }
 
 type ValueOfModel<M extends FormModel<any, any, any, any, any>> = M extends FormModel<infer T, any, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;