@strictly/react-form 0.0.10 → 0.0.12

package/dist/index.js

@@ -1,3 +1,73 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => {
+  var _a;
+  return [, , , __create((_a = base == null ? void 0 : base[__knownSymbol("metadata")]) != null ? _a : null)];
+};
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
 // field_converters/chain_field_converter.ts
 import {
   UnreachableError
@@ -232,7 +302,7 @@ function listAdapter() {
   );
 }
 
-// core/mobx/form_presenter.ts
+// core/mobx/form_model.ts
 import {
   assertExists,
   assertExistsAndReturn,
@@ -256,10 +326,136 @@ import {
   observable,
   runInAction
 } from "mobx";
-var FormPresenter = class {
-  constructor(type, adapters) {
+var _accessors_dec, _knownFields_dec, _fields_dec, _errors_dec, _fieldOverrides_dec, _value_dec, _init, _value, _fieldOverrides, _errors;
+_value_dec = [observable.ref], _fieldOverrides_dec = [observable.shallow], _errors_dec = [observable.shallow], _fields_dec = [computed], _knownFields_dec = [computed], _accessors_dec = [computed];
+var FormModel = class {
+  constructor(type, value, adapters) {
     this.type = type;
     this.adapters = adapters;
+    __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, _errors, __runInitializers(_init, 16, this, {})), __runInitializers(_init, 19, this);
+    __publicField(this, "flattenedTypeDefs");
+    this.value = mobxCopy(type, value);
+    this.flattenedTypeDefs = flattenTypesOfType(type);
+    const conversions = flattenValueTo(
+      type,
+      this.value,
+      () => {
+      },
+      (_t, value2, _setter, typePath, valuePath) => {
+        const adapter2 = this.adapters[typePath];
+        if (adapter2 == null) {
+          return;
+        }
+        const {
+          convert,
+          revert
+        } = adapter2;
+        if (revert == null) {
+          return;
+        }
+        return convert(value2, valuePath, this.value);
+      }
+    );
+    this.fieldOverrides = map(conversions, function(_k, v) {
+      return v && [v.value];
+    });
+  }
+  get fields() {
+    return new Proxy(
+      this.knownFields,
+      {
+        get: (target, prop) => {
+          const field = target[prop];
+          if (field != null) {
+            return field;
+          }
+          if (typeof prop === "string") {
+            return this.maybeSynthesizeFieldByValuePath(prop);
+          }
+        }
+      }
+    );
+  }
+  get knownFields() {
+    return flattenValueTo(
+      this.type,
+      this.value,
+      () => {
+      },
+      // TODO swap these to valuePath, typePath in flatten
+      (_t, _v, _setter, typePath, valuePath) => {
+        return this.synthesizeFieldByPaths(
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          valuePath,
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          typePath
+        );
+      }
+    );
+  }
+  maybeSynthesizeFieldByValuePath(valuePath) {
+    let typePath;
+    try {
+      typePath = valuePathToTypePath(
+        this.type,
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        valuePath,
+        true
+      );
+    } catch (e) {
+      return;
+    }
+    return this.synthesizeFieldByPaths(valuePath, typePath);
+  }
+  synthesizeFieldByPaths(valuePath, typePath) {
+    const adapter2 = this.adapters[typePath];
+    if (adapter2 == null) {
+      return;
+    }
+    const {
+      convert,
+      create
+    } = adapter2;
+    const fieldOverride = this.fieldOverrides[valuePath];
+    const accessor = this.getAccessorForValuePath(valuePath);
+    const fieldTypeDef = this.flattenedTypeDefs[typePath];
+    const {
+      value,
+      required,
+      readonly
+    } = convert(
+      accessor != null ? accessor.value : fieldTypeDef != null ? mobxCopy(
+        fieldTypeDef,
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        create(valuePath, this.value)
+      ) : create(valuePath, this.value),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      valuePath,
+      this.value
+    );
+    const error = this.errors[valuePath];
+    return {
+      value: fieldOverride != null ? fieldOverride[0] : value,
+      error,
+      readonly,
+      required
+    };
+  }
+  getAccessorForValuePath(valuePath) {
+    return this.accessors[valuePath];
+  }
+  // should only be referenced internally, so loosely typed
+  get accessors() {
+    return flattenAccessorsOfType(
+      this.type,
+      this.value,
+      (value) => {
+        this.value = mobxCopy(this.type, value);
+      }
+    );
   }
   maybeGetAdapterForValuePath(valuePath) {
     const typePath = valuePathToTypePath(this.type, valuePath, true);
@@ -275,17 +471,17 @@ var FormPresenter = class {
   typePath(valuePath) {
     return valuePathToTypePath(this.type, valuePath, true);
   }
-  setFieldValueAndValidate(model, valuePath, value) {
-    return this.internalSetFieldValue(model, valuePath, value, true);
+  setFieldValueAndValidate(valuePath, value) {
+    return this.internalSetFieldValue(valuePath, value, true);
   }
-  setFieldValue(model, valuePath, value) {
-    return this.internalSetFieldValue(model, valuePath, value, false);
+  setFieldValue(valuePath, value) {
+    return this.internalSetFieldValue(valuePath, value, false);
   }
-  addListItem(model, valuePath, elementValue = null, index) {
+  addListItem(valuePath, elementValue = null, index) {
     const listValuePath = valuePath;
-    const accessor = model.accessors[valuePath];
+    const accessor = this.accessors[valuePath];
     const listTypePath = this.typePath(valuePath);
-    const definedIndex = index ?? accessor.value.length;
+    const definedIndex = index != null ? index : accessor.value.length;
     const elementTypePath = `${listTypePath}.*`;
     const elementAdapter = assertExistsAndReturn(
       this.adapters[elementTypePath],
@@ -296,7 +492,7 @@ var FormPresenter = class {
     const element = elementValue != null ? elementValue[0] : elementAdapter.create(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       elementTypePath,
-      model.value
+      this.value
     );
     const originalList = accessor.value;
     const newList = [
@@ -304,7 +500,7 @@ var FormPresenter = class {
       element,
       ...originalList.slice(definedIndex)
     ];
-    const targetPaths = Object.keys(model.fieldOverrides).filter(function(v) {
+    const targetPaths = Object.keys(this.fieldOverrides).filter(function(v) {
       return v.startsWith(`${listValuePath}.`);
     }).map(function(v) {
       const parts = v.substring(listValuePath.length + 1).split(".");
@@ -318,11 +514,11 @@ var FormPresenter = class {
     }).sort(function([a], [b]) {
       return b - a;
     });
-    runInAction(function() {
-      targetPaths.forEach(function([
+    runInAction(() => {
+      targetPaths.forEach(([
         index2,
         postfix
-      ]) {
+      ]) => {
         const fromJsonPath = [
           listValuePath,
           `${index2}`,
@@ -333,115 +529,118 @@ var FormPresenter = class {
           `${index2 + 1}`,
           ...postfix
         ].join(".");
-        const fieldOverride = model.fieldOverrides[fromJsonPath];
-        delete model.fieldOverrides[fromJsonPath];
-        model.fieldOverrides[toJsonPath] = fieldOverride;
-        const error = model.errors[fromJsonPath];
-        delete model.errors[fromJsonPath];
-        model.errors[toJsonPath] = error;
+        const fieldOverride = this.fieldOverrides[fromJsonPath];
+        delete this.fieldOverrides[fromJsonPath];
+        this.fieldOverrides[toJsonPath] = fieldOverride;
+        const error = this.errors[fromJsonPath];
+        delete this.errors[fromJsonPath];
+        this.errors[toJsonPath] = error;
       });
       accessor.set(newList);
-      delete model.fieldOverrides[listValuePath];
+      delete this.fieldOverrides[listValuePath];
     });
   }
-  removeListItem(model, elementValuePath) {
-    const [
-      listValuePath,
-      elementIndexString
-    ] = assertExistsAndReturn(
-      jsonPathPop(elementValuePath),
-      "expected a path with two or more segments {}",
-      elementValuePath
-    );
-    const accessor = model.accessors[listValuePath];
-    const elementIndex = checkValidNumber(
-      parseInt(elementIndexString),
-      "unexpected index {} ({})",
-      elementIndexString,
-      elementValuePath
-    );
-    const newList = [...accessor.value];
-    assertState(
-      elementIndex >= 0 && elementIndex < newList.length,
-      "invalid index from path {} ({})",
-      elementIndex,
-      elementValuePath
-    );
-    newList.splice(elementIndex, 1);
-    const targetPaths = Object.keys(model.fieldOverrides).filter(function(v) {
-      return v.startsWith(`${listValuePath}.`);
-    }).map(function(v) {
-      const parts = v.substring(listValuePath.length + 1).split(".");
-      const index = parseInt(parts[0]);
-      return [
-        index,
-        parts.slice(1)
-      ];
-    }).filter(function([index]) {
-      return index > elementIndex;
-    }).sort(function([a], [b]) {
-      return a - b;
-    });
-    runInAction(function() {
-      targetPaths.forEach(function([
-        index,
-        postfix
-      ]) {
-        const fromJsonPath = [
-          listValuePath,
-          `${index}`,
-          ...postfix
-        ].join(".");
-        const toJsonPath = [
+  removeListItem(...elementValuePaths) {
+    const orderedElementValuePaths = elementValuePaths.toSorted().reverse();
+    runInAction(() => {
+      orderedElementValuePaths.forEach((elementValuePath) => {
+        const [
           listValuePath,
-          `${index - 1}`,
-          ...postfix
-        ].join(".");
-        const fieldOverride = model.fieldOverrides[fromJsonPath];
-        delete model.fieldOverrides[fromJsonPath];
-        model.fieldOverrides[toJsonPath] = fieldOverride;
-        const error = model.errors[fromJsonPath];
-        delete model.errors[fromJsonPath];
-        model.errors[toJsonPath] = error;
+          elementIndexString
+        ] = assertExistsAndReturn(
+          jsonPathPop(elementValuePath),
+          "expected a path with two or more segments {}",
+          elementValuePath
+        );
+        const accessor = this.accessors[listValuePath];
+        const elementIndex = checkValidNumber(
+          parseInt(elementIndexString),
+          "unexpected index {} ({})",
+          elementIndexString,
+          elementValuePath
+        );
+        const newList = [...accessor.value];
+        assertState(
+          elementIndex >= 0 && elementIndex < newList.length,
+          "invalid index from path {} ({})",
+          elementIndex,
+          elementValuePath
+        );
+        newList.splice(elementIndex, 1);
+        const targetPaths = Object.keys(this.fieldOverrides).filter(function(v) {
+          return v.startsWith(`${listValuePath}.`);
+        }).map(function(v) {
+          const parts = v.substring(listValuePath.length + 1).split(".");
+          const index = parseInt(parts[0]);
+          return [
+            index,
+            parts.slice(1)
+          ];
+        }).filter(function([index]) {
+          return index > elementIndex;
+        }).sort(function([a], [b]) {
+          return a - b;
+        });
+        targetPaths.forEach(([
+          index,
+          postfix
+        ]) => {
+          const fromJsonPath = [
+            listValuePath,
+            `${index}`,
+            ...postfix
+          ].join(".");
+          const toJsonPath = [
+            listValuePath,
+            `${index - 1}`,
+            ...postfix
+          ].join(".");
+          const fieldOverride = this.fieldOverrides[fromJsonPath];
+          delete this.fieldOverrides[fromJsonPath];
+          this.fieldOverrides[toJsonPath] = fieldOverride;
+          const error = this.errors[fromJsonPath];
+          delete this.errors[fromJsonPath];
+          this.errors[toJsonPath] = error;
+        });
+        accessor.set(newList);
+        delete this.fieldOverrides[listValuePath];
       });
-      accessor.set(newList);
-      delete model.fieldOverrides[listValuePath];
     });
   }
-  internalSetFieldValue(model, valuePath, value, displayValidation) {
+  internalSetFieldValue(valuePath, value, displayValidation) {
     const { revert } = this.getAdapterForValuePath(valuePath);
     assertExists(revert, "setting value not supported {}", valuePath);
-    const conversion = revert(value, valuePath, model.value);
-    const accessor = model.getAccessorForValuePath(valuePath);
+    const conversion = revert(value, valuePath, this.value);
+    const accessor = this.getAccessorForValuePath(valuePath);
     return runInAction(() => {
-      model.fieldOverrides[valuePath] = [value];
+      this.fieldOverrides[valuePath] = [value];
       switch (conversion.type) {
         case 1 /* Failure */:
           if (displayValidation) {
-            model.errors[valuePath] = conversion.error;
+            this.errors[valuePath] = conversion.error;
           }
           if (conversion.value != null && accessor != null) {
             accessor.set(conversion.value[0]);
           }
           return false;
         case 0 /* Success */:
-          delete model.errors[valuePath];
-          accessor?.set(conversion.value);
+          delete this.errors[valuePath];
+          accessor == null ? void 0 : accessor.set(conversion.value);
           return true;
         default:
           throw new UnreachableError2(conversion);
       }
     });
   }
-  clearFieldError(model, valuePath) {
-    const fieldOverride = model.fieldOverrides[valuePath];
+  clearFieldError(valuePath) {
+    const fieldOverride = this.fieldOverrides[valuePath];
     if (fieldOverride != null) {
-      runInAction(function() {
-        delete model.errors[valuePath];
+      runInAction(() => {
+        delete this.errors[valuePath];
       });
     }
   }
-  clearFieldValue(model, valuePath) {
+  clearFieldValue(valuePath) {
     const typePath = this.typePath(valuePath);
     const adapter2 = this.adapters[typePath];
     if (adapter2 == null) {
@@ -451,452 +650,160 @@ var FormPresenter = class {
       convert,
       create
     } = adapter2;
-    const value = create(valuePath, model.value);
+    const value = create(valuePath, this.value);
     const {
       value: displayValue
-    } = convert(value, valuePath, model.value);
+    } = convert(value, valuePath, this.value);
     const key = valuePath;
-    runInAction(function() {
-      model.fieldOverrides[key] = [displayValue];
+    runInAction(() => {
+      this.fieldOverrides[key] = [displayValue];
     });
   }
-  clearAll(model, value) {
+  clearAll(value) {
     runInAction(() => {
-      model.errors = {};
-      model.fieldOverrides = {};
-      model.value = mobxCopy(this.type, value);
+      this.errors = {};
+      this.fieldOverrides = {};
+      this.value = mobxCopy(this.type, value);
     });
   }
-  isValuePathActive(model, valuePath) {
-    const values = flattenValuesOfType(this.type, model.value);
+  isValuePathActive(valuePath) {
+    const values = flattenValuesOfType(this.type, this.value);
     const keys = new Set(Object.keys(values));
     return keys.has(valuePath);
   }
-  validateField(model, valuePath, ignoreDefaultValue = false) {
+  validateField(valuePath, ignoreDefaultValue = false) {
     const {
       convert,
       revert,
       create
     } = this.getAdapterForValuePath(valuePath);
-    const fieldOverride = model.fieldOverrides[valuePath];
-    const accessor = model.getAccessorForValuePath(valuePath);
+    const fieldOverride = this.fieldOverrides[valuePath];
+    const accessor = this.getAccessorForValuePath(valuePath);
     const {
       value: storedValue
     } = convert(
-      accessor != null ? accessor.value : create(valuePath, model.value),
+      accessor != null ? accessor.value : create(valuePath, this.value),
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       valuePath,
-      model.value
+      this.value
     );
     const value = fieldOverride != null ? fieldOverride[0] : storedValue;
     const dirty = storedValue !== value;
     assertExists(revert, "changing field directly not supported {}", valuePath);
     if (ignoreDefaultValue) {
       const {
-        value: defaultDisplayValue
-      } = convert(create(valuePath, model.value), valuePath, model.value);
-      if (defaultDisplayValue === value) {
-        return true;
-      }
-    }
-    const conversion = revert(value, valuePath, model.value);
-    return runInAction(function() {
-      switch (conversion.type) {
-        case 1 /* Failure */:
-          model.errors[valuePath] = conversion.error;
-          if (conversion.value != null && accessor != null && dirty) {
-            accessor.set(conversion.value[0]);
-          }
-          return false;
-        case 0 /* Success */:
-          delete model.errors[valuePath];
-          if (accessor != null && dirty) {
-            accessor.set(conversion.value);
-          }
-          return true;
-        default:
-          throw new UnreachableError2(conversion);
-      }
-    });
-  }
-  validateAll(model) {
-    const accessors = toArray(model.accessors).toSorted(function([a], [b]) {
-      return a.length - b.length;
-    });
-    return runInAction(() => {
-      return accessors.reduce(
-        (success, [
-          valuePath,
-          accessor
-        ]) => {
-          const adapterPath = valuePath;
-          const adapter2 = this.maybeGetAdapterForValuePath(adapterPath);
-          if (adapter2 == null) {
-            return success;
-          }
-          const {
-            convert,
-            revert
-          } = adapter2;
-          if (revert == null) {
-            return success;
-          }
-          const fieldOverride = model.fieldOverrides[adapterPath];
-          const {
-            value: storedValue
-          } = convert(accessor.value, valuePath, model.value);
-          const value = fieldOverride != null ? fieldOverride[0] : storedValue;
-          const dirty = fieldOverride != null && fieldOverride[0] !== storedValue;
-          const conversion = revert(value, valuePath, model.value);
-          switch (conversion.type) {
-            case 1 /* Failure */:
-              model.errors[adapterPath] = conversion.error;
-              if (conversion.value != null && dirty) {
-                accessor.set(conversion.value[0]);
-              }
-              return false;
-            case 0 /* Success */:
-              if (dirty) {
-                accessor.set(conversion.value);
-              }
-              delete model.errors[adapterPath];
-              return success;
-            default:
-              throw new UnreachableError2(conversion);
-          }
-        },
-        true
-      );
-    });
-  }
-};
-var FormModel = class {
-  constructor(type, value, adapters) {
-    this.type = type;
-    this.adapters = adapters;
-    this.value = mobxCopy(type, value);
-    this.flattenedTypeDefs = flattenTypesOfType(type);
-    const conversions = flattenValueTo(
-      type,
-      this.value,
-      () => {
-      },
-      (_t, value2, _setter, typePath, valuePath) => {
-        const adapter2 = this.adapters[typePath];
-        if (adapter2 == null) {
-          return;
-        }
-        const {
-          convert,
-          revert
-        } = adapter2;
-        if (revert == null) {
-          return;
-        }
-        return convert(value2, valuePath, this.value);
-      }
-    );
-    this.fieldOverrides = map(conversions, function(_k, v) {
-      return v && [v.value];
-    });
-  }
-  @observable.ref
-  accessor value;
-  @observable.shallow
-  accessor fieldOverrides;
-  @observable.shallow
-  accessor errors = {};
-  flattenedTypeDefs;
-  @computed
-  get fields() {
-    return new Proxy(
-      this.knownFields,
-      {
-        get: (target, prop) => {
-          const field = target[prop];
-          if (field != null) {
-            return field;
-          }
-          if (typeof prop === "string") {
-            return this.maybeSynthesizeFieldByValuePath(prop);
-          }
-        }
-      }
-    );
-  }
-  @computed
-  get knownFields() {
-    return flattenValueTo(
-      this.type,
-      this.value,
-      () => {
-      },
-      // TODO swap these to valuePath, typePath in flatten
-      (_t, _v, _setter, typePath, valuePath) => {
-        return this.synthesizeFieldByPaths(
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          valuePath,
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          typePath
-        );
-      }
-    );
-  }
-  maybeSynthesizeFieldByValuePath(valuePath) {
-    let typePath;
-    try {
-      typePath = valuePathToTypePath(
-        this.type,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        valuePath,
-        true
-      );
-    } catch (e) {
-      return;
-    }
-    return this.synthesizeFieldByPaths(valuePath, typePath);
-  }
-  synthesizeFieldByPaths(valuePath, typePath) {
-    const adapter2 = this.adapters[typePath];
-    if (adapter2 == null) {
-      return;
-    }
-    const {
-      convert,
-      create
-    } = adapter2;
-    const fieldOverride = this.fieldOverrides[valuePath];
-    const accessor = this.getAccessorForValuePath(valuePath);
-    const fieldTypeDef = this.flattenedTypeDefs[typePath];
-    const {
-      value,
-      required,
-      readonly
-    } = convert(
-      accessor != null ? accessor.value : fieldTypeDef != null ? mobxCopy(
-        fieldTypeDef,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        create(valuePath, this.value)
-      ) : create(valuePath, this.value),
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      valuePath,
-      this.value
-    );
-    const error = this.errors[valuePath];
-    return {
-      value: fieldOverride != null ? fieldOverride[0] : value,
-      error,
-      readonly,
-      required
-    };
-  }
-  getAccessorForValuePath(valuePath) {
-    return this.accessors[valuePath];
-  }
-  @computed
-  // should only be referenced internally, so loosely typed
-  get accessors() {
-    return flattenAccessorsOfType(
-      this.type,
-      this.value,
-      (value) => {
-        this.value = mobxCopy(this.type, value);
-      }
-    );
-  }
-};
-
-// core/mobx/hooks.tsx
-import {
-  useCallback,
-  useMemo as useMemo2
-} from "react";
-
-// util/partial.tsx
-import { observer } from "mobx-react";
-import {
-  forwardRef,
-  useMemo
-} from "react";
-import { jsx } from "react/jsx-runtime";
-function createSimplePartialComponent(Component, curriedProps) {
-  return forwardRef(
-    function(exposedProps, ref) {
-      const C = Component;
-      return /* @__PURE__ */ jsx(
-        C,
-        {
-          ref,
-          ...curriedProps,
-          ...exposedProps
-        }
-      );
-    }
-  );
-}
-function createPartialComponent(Component, curriedPropsSource, additionalPropKeys = []) {
-  return forwardRef(
-    function(props, ref) {
-      const C = Component;
-      const [
-        additionalProps,
-        exposedProps
-      ] = additionalPropKeys.reduce(
-        function([
-          additionalProps2,
-          exposedProps2
-        ], key) {
-          const value = props[
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            key
-          ];
-          delete exposedProps2[key];
-          additionalProps2[key] = value;
-          return [
-            additionalProps2,
-            exposedProps2
-          ];
-        },
-        [
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          {},
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          { ...props }
-        ]
-      );
-      const curriedProps = curriedPropsSource(additionalProps);
-      return /* @__PURE__ */ jsx(
-        C,
-        {
-          ref,
-          ...curriedProps,
-          ...exposedProps
-        }
-      );
-    }
-  );
-}
-function usePartialComponent(curriedPropsSource, deps, Component, additionalPropKeys = []) {
-  return useMemo(
-    function() {
-      return createPartialComponent(
-        Component,
-        curriedPropsSource,
-        additionalPropKeys
-      );
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      ...deps,
-      Component,
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      ...additionalPropKeys
-    ]
-  );
-}
-function createPartialObserverComponent(Component, curriedPropsSource, additionalPropKeys = []) {
-  return createUnsafePartialObserverComponent(
-    Component,
-    curriedPropsSource,
-    additionalPropKeys
-  );
-}
-function createUnsafePartialObserverComponent(Component, curriedPropsSource, additionalPropKeys = []) {
-  return observer(
-    forwardRef(
-      function(props, ref) {
-        const C = Component;
-        const [
-          additionalProps,
-          exposedProps
-        ] = additionalPropKeys.reduce(
-          function([
-            additionalProps2,
-            exposedProps2
-          ], key) {
-            const value = props[
-              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-              key
-            ];
-            delete exposedProps2[key];
-            additionalProps2[key] = value;
-            return [
-              additionalProps2,
-              exposedProps2
-            ];
-          },
-          [
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            {},
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            { ...props }
-          ]
-        );
-        const curriedProps = curriedPropsSource(additionalProps);
-        return /* @__PURE__ */ jsx(
-          C,
-          {
-            ref,
-            ...curriedProps,
-            ...exposedProps
+        value: defaultDisplayValue
+      } = convert(create(valuePath, this.value), valuePath, this.value);
+      if (defaultDisplayValue === value) {
+        return true;
+      }
+    }
+    const conversion = revert(value, valuePath, this.value);
+    return runInAction(() => {
+      switch (conversion.type) {
+        case 1 /* Failure */:
+          this.errors[valuePath] = conversion.error;
+          if (conversion.value != null && accessor != null && dirty) {
+            accessor.set(conversion.value[0]);
           }
-        );
+          return false;
+        case 0 /* Success */:
+          delete this.errors[valuePath];
+          if (accessor != null && dirty) {
+            accessor.set(conversion.value);
+          }
+          return true;
+        default:
+          throw new UnreachableError2(conversion);
       }
-    )
-  );
-}
-function usePartialObserverComponent(curriedPropsSource, deps, Component, additionalPropKeys = []) {
-  return useMemo(
-    function() {
-      return createPartialObserverComponent(
-        Component,
-        curriedPropsSource,
-        additionalPropKeys
+    });
+  }
+  validateAll() {
+    const accessors = toArray(this.accessors).toSorted(function([a], [b]) {
+      return a.length - b.length;
+    });
+    return runInAction(() => {
+      return accessors.reduce(
+        (success, [
+          valuePath,
+          accessor
+        ]) => {
+          const adapterPath = valuePath;
+          const adapter2 = this.maybeGetAdapterForValuePath(adapterPath);
+          if (adapter2 == null) {
+            return success;
+          }
+          const {
+            convert,
+            revert
+          } = adapter2;
+          if (revert == null) {
+            return success;
+          }
+          const fieldOverride = this.fieldOverrides[adapterPath];
+          const {
+            value: storedValue
+          } = convert(accessor.value, valuePath, this.value);
+          const value = fieldOverride != null ? fieldOverride[0] : storedValue;
+          const dirty = fieldOverride != null && fieldOverride[0] !== storedValue;
+          const conversion = revert(value, valuePath, this.value);
+          switch (conversion.type) {
+            case 1 /* Failure */:
+              this.errors[adapterPath] = conversion.error;
+              if (conversion.value != null && dirty) {
+                accessor.set(conversion.value[0]);
+              }
+              return false;
+            case 0 /* Success */:
+              if (dirty) {
+                accessor.set(conversion.value);
+              }
+              delete this.errors[adapterPath];
+              return success;
+            default:
+              throw new UnreachableError2(conversion);
+          }
+        },
+        true
       );
-    },
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      ...deps,
-      Component,
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      ...additionalPropKeys
-    ]
-  );
-}
+    });
+  }
+};
+_init = __decoratorStart(null);
+_value = new WeakMap();
+_fieldOverrides = new WeakMap();
+_errors = new WeakMap();
+__decorateElement(_init, 4, "value", _value_dec, FormModel, _value);
+__decorateElement(_init, 4, "fieldOverrides", _fieldOverrides_dec, FormModel, _fieldOverrides);
+__decorateElement(_init, 4, "errors", _errors_dec, FormModel, _errors);
+__decorateElement(_init, 2, "fields", _fields_dec, FormModel);
+__decorateElement(_init, 2, "knownFields", _knownFields_dec, FormModel);
+__decorateElement(_init, 2, "accessors", _accessors_dec, FormModel);
+__decoratorMetadata(_init, FormModel);
 
 // core/mobx/hooks.tsx
-function useDefaultMobxFormHooks(presenter, value, {
+import {
+  useCallback
+} from "react";
+function useDefaultMobxFormHooks(model, {
   onValidFieldSubmit,
-  onValidFormSubmit,
-  FormFieldsView
+  onValidFormSubmit
 } = {}) {
-  const model = useMemo2(function() {
-    return presenter.createModel(value);
-  }, [
-    presenter,
-    value
-  ]);
   const onFieldValueChange = useCallback(
-    function(path, value2) {
-      presenter.clearFieldError(model, path);
-      presenter.setFieldValue(model, path, value2);
+    function(path, value) {
+      model.clearFieldError(path);
+      model.setFieldValue(path, value);
     },
-    [
-      presenter,
-      model
-    ]
+    [model]
   );
   const onFieldSubmit = useCallback(
     function(valuePath) {
-      if (presenter.validateField(model, valuePath)) {
-        onValidFieldSubmit?.(model, valuePath);
+      if (model.validateField(valuePath)) {
+        onValidFieldSubmit == null ? void 0 : onValidFieldSubmit(valuePath);
       }
       return false;
     },
     [
-      presenter,
       model,
       onValidFieldSubmit
     ]
@@ -904,55 +811,29 @@ function useDefaultMobxFormHooks(presenter, value, {
   const onFieldBlur = useCallback(
     function(path) {
       setTimeout(function() {
-        if (presenter.isValuePathActive(model, path)) {
-          presenter.validateField(model, path, true);
+        if (model.isValuePathActive(path)) {
+          model.validateField(path, true);
         }
       }, 100);
     },
-    [
-      presenter,
-      model
-    ]
+    [model]
   );
   const onFormSubmit = useCallback(
     function() {
-      if (presenter.validateAll(model)) {
-        onValidFormSubmit?.(model, model.value);
+      if (model.validateAll()) {
+        onValidFormSubmit == null ? void 0 : onValidFormSubmit(model.value);
       }
     },
     [
-      presenter,
       model,
       onValidFormSubmit
     ]
   );
-  const FormFields = useMemo2(() => {
-    if (FormFieldsView == null) {
-      return void 0;
-    }
-    return createUnsafePartialObserverComponent(FormFieldsView, () => {
-      return {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        fields: model.fields,
-        onFieldBlur,
-        onFieldSubmit,
-        onFieldValueChange
-      };
-    });
-  }, [
-    model,
-    FormFieldsView,
-    onFieldBlur,
-    onFieldSubmit,
-    onFieldValueChange
-  ]);
   return {
-    model,
     onFieldValueChange,
     onFieldSubmit,
     onFieldBlur,
-    onFormSubmit,
-    FormFields
+    onFormSubmit
   };
 }
 
@@ -1023,11 +904,10 @@ function mergeAdaptersWithValidators(adapters, validators) {
           readonly: readonly1 || readonly2
         };
       }
-      acc[key] = {
-        ...adapter2,
+      acc[key] = __spreadProps(__spreadValues({}, adapter2), {
         convert,
         revert: adapter2.revert && revert
-      };
+      });
       return acc;
     },
     {}
@@ -1110,9 +990,9 @@ var NullableToBooleanConverter = class {
     this.typeDef = typeDef;
     this.prototype = prototype;
     this.nullType = nullType;
+    __publicField(this, "defaultValue");
     this.defaultValue = defaultToNull ? this.nullType : prototype;
   }
-  defaultValue;
   convert(from) {
     return {
       value: from !== this.nullType,
@@ -1288,24 +1168,176 @@ import {
 } from "mobx";
 import {
   useEffect,
-  useMemo as useMemo3
+  useMemo as useMemo2
+} from "react";
+
+// util/partial.tsx
+import { observer } from "mobx-react";
+import {
+  forwardRef,
+  useMemo
 } from "react";
+import { jsx } from "react/jsx-runtime";
+function createSimplePartialComponent(Component, curriedProps) {
+  return forwardRef(
+    function(exposedProps, ref) {
+      const C = Component;
+      return /* @__PURE__ */ jsx(
+        C,
+        __spreadValues(__spreadValues({
+          ref
+        }, curriedProps), exposedProps)
+      );
+    }
+  );
+}
+function createPartialComponent(Component, curriedPropsSource, additionalPropKeys = []) {
+  return forwardRef(
+    function(props, ref) {
+      const C = Component;
+      const [
+        additionalProps,
+        exposedProps
+      ] = additionalPropKeys.reduce(
+        function([
+          additionalProps2,
+          exposedProps2
+        ], key) {
+          const value = props[
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            key
+          ];
+          delete exposedProps2[key];
+          additionalProps2[key] = value;
+          return [
+            additionalProps2,
+            exposedProps2
+          ];
+        },
+        [
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          {},
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          __spreadValues({}, props)
+        ]
+      );
+      const curriedProps = curriedPropsSource(additionalProps);
+      return /* @__PURE__ */ jsx(
+        C,
+        __spreadValues(__spreadValues({
+          ref
+        }, curriedProps), exposedProps)
+      );
+    }
+  );
+}
+function usePartialComponent(curriedPropsSource, deps, Component, additionalPropKeys = []) {
+  return useMemo(
+    function() {
+      return createPartialComponent(
+        Component,
+        curriedPropsSource,
+        additionalPropKeys
+      );
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      ...deps,
+      Component,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      ...additionalPropKeys
+    ]
+  );
+}
+function createPartialObserverComponent(Component, curriedPropsSource, additionalPropKeys = []) {
+  return createUnsafePartialObserverComponent(
+    Component,
+    curriedPropsSource,
+    additionalPropKeys
+  );
+}
+function createUnsafePartialObserverComponent(Component, curriedPropsSource, additionalPropKeys = []) {
+  return observer(
+    forwardRef(
+      function(props, ref) {
+        const C = Component;
+        const [
+          additionalProps,
+          exposedProps
+        ] = additionalPropKeys.reduce(
+          function([
+            additionalProps2,
+            exposedProps2
+          ], key) {
+            const value = props[
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              key
+            ];
+            delete exposedProps2[key];
+            additionalProps2[key] = value;
+            return [
+              additionalProps2,
+              exposedProps2
+            ];
+          },
+          [
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            {},
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            __spreadValues({}, props)
+          ]
+        );
+        const curriedProps = curriedPropsSource(additionalProps);
+        return /* @__PURE__ */ jsx(
+          C,
+          __spreadValues(__spreadValues({
+            ref
+          }, curriedProps), exposedProps)
+        );
+      }
+    )
+  );
+}
+function usePartialObserverComponent(curriedPropsSource, deps, Component, additionalPropKeys = []) {
+  return useMemo(
+    function() {
+      return createPartialObserverComponent(
+        Component,
+        curriedPropsSource,
+        additionalPropKeys
+      );
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      ...deps,
+      Component,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      ...additionalPropKeys
+    ]
+  );
+}
 
 // mantine/create_checkbox.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
 function createCheckbox(valuePath, Checkbox) {
   const onChange = (e) => {
-    this.onFieldValueChange?.(valuePath, e.target.checked);
+    var _a;
+    (_a = this.onFieldValueChange) == null ? void 0 : _a.call(this, valuePath, e.target.checked);
   };
   const onFocus = () => {
-    this.onFieldFocus?.(valuePath);
+    var _a;
+    (_a = this.onFieldFocus) == null ? void 0 : _a.call(this, valuePath);
   };
   const onBlur = () => {
-    this.onFieldBlur?.(valuePath);
+    var _a;
+    (_a = this.onFieldBlur) == null ? void 0 : _a.call(this, valuePath);
   };
   const onKeyUp = (e) => {
+    var _a;
     if (e.key === "Enter") {
-      if (this.onFieldSubmit?.(valuePath)) {
+      if ((_a = this.onFieldSubmit) == null ? void 0 : _a.call(this, valuePath)) {
         e.preventDefault();
       }
     }
@@ -1353,13 +1385,16 @@ function createFieldsView(valuePath, FieldsView, observableProps) {
     observableProps.onFieldValueChange(toKey(subKey), value);
   }
   function onFieldBlur(subKey) {
-    observableProps.onFieldBlur?.(toKey(subKey));
+    var _a;
+    (_a = observableProps.onFieldBlur) == null ? void 0 : _a.call(observableProps, toKey(subKey));
   }
   function onFieldFocus(subKey) {
-    observableProps.onFieldFocus?.(toKey(subKey));
+    var _a;
+    (_a = observableProps.onFieldFocus) == null ? void 0 : _a.call(observableProps, toKey(subKey));
   }
   function onFieldSubmit(subKey) {
-    observableProps.onFieldSubmit?.(toKey(subKey));
+    var _a;
+    (_a = observableProps.onFieldSubmit) == null ? void 0 : _a.call(observableProps, toKey(subKey));
   }
   const Component = observer2(
     function(props) {
@@ -1378,16 +1413,13 @@ function createFieldsView(valuePath, FieldsView, observableProps) {
       );
       return /* @__PURE__ */ jsx3(
         FieldsView,
-        {
-          // maybe we can do this in a more type safe way
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
-          ...props,
+        __spreadProps(__spreadValues({}, props), {
           fields: subFields,
           onFieldBlur,
           onFieldFocus,
           onFieldSubmit,
           onFieldValueChange
-        }
+        })
       );
     }
   );
@@ -1417,13 +1449,10 @@ function createForm(valuePath, Form, observableProps) {
     }, []);
     return /* @__PURE__ */ jsx4(
       Form,
-      {
-        // maybe we can do this in a more type safe way
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
-        ...props,
+      __spreadProps(__spreadValues({}, props), {
         onValueChange,
         value
-      }
+      })
     );
   });
 }
@@ -1487,17 +1516,21 @@ function createRadio(valuePath, value, Radio) {
 import { jsx as jsx6 } from "react/jsx-runtime";
 function createRadioGroup(valuePath, RadioGroup) {
   const onChange = (value) => {
-    this.onFieldValueChange?.(valuePath, value);
+    var _a;
+    (_a = this.onFieldValueChange) == null ? void 0 : _a.call(this, valuePath, value);
   };
   const onFocus = () => {
-    this.onFieldFocus?.(valuePath);
+    var _a;
+    (_a = this.onFieldFocus) == null ? void 0 : _a.call(this, valuePath);
   };
   const onBlur = () => {
-    this.onFieldBlur?.(valuePath);
+    var _a;
+    (_a = this.onFieldBlur) == null ? void 0 : _a.call(this, valuePath);
   };
   const onKeyUp = (e) => {
+    var _a;
     if (e.key === "Enter") {
-      if (this.onFieldSubmit?.(valuePath)) {
+      if ((_a = this.onFieldSubmit) == null ? void 0 : _a.call(this, valuePath)) {
         e.preventDefault();
       }
     }
@@ -1526,17 +1559,21 @@ function createRadioGroup(valuePath, RadioGroup) {
 import { jsx as jsx7 } from "react/jsx-runtime";
 function createTextInput(valuePath, TextInput) {
   const onChange = (e) => {
-    this.onFieldValueChange?.(valuePath, e.target.value);
+    var _a;
+    (_a = this.onFieldValueChange) == null ? void 0 : _a.call(this, valuePath, e.target.value);
   };
   const onFocus = () => {
-    this.onFieldFocus?.(valuePath);
+    var _a;
+    (_a = this.onFieldFocus) == null ? void 0 : _a.call(this, valuePath);
   };
   const onBlur = () => {
-    this.onFieldBlur?.(valuePath);
+    var _a;
+    (_a = this.onFieldBlur) == null ? void 0 : _a.call(this, valuePath);
   };
   const onKeyUp = (e) => {
+    var _a;
     if (e.key === "Enter") {
-      if (this.onFieldSubmit?.(valuePath)) {
+      if ((_a = this.onFieldSubmit) == null ? void 0 : _a.call(this, valuePath)) {
         e.preventDefault();
       }
     }
@@ -1578,17 +1615,21 @@ function createTextInput(valuePath, TextInput) {
 import { jsx as jsx8 } from "react/jsx-runtime";
 function createValueInput(valuePath, ValueInput) {
   const onChange = (value) => {
-    this.onFieldValueChange?.(valuePath, value);
+    var _a;
+    (_a = this.onFieldValueChange) == null ? void 0 : _a.call(this, valuePath, value);
   };
   const onFocus = () => {
-    this.onFieldFocus?.(valuePath);
+    var _a;
+    (_a = this.onFieldFocus) == null ? void 0 : _a.call(this, valuePath);
   };
   const onBlur = () => {
-    this.onFieldBlur?.(valuePath);
+    var _a;
+    (_a = this.onFieldBlur) == null ? void 0 : _a.call(this, valuePath);
   };
   const onKeyUp = (e) => {
+    var _a;
     if (e.key === "Enter") {
-      if (this.onFieldSubmit?.(valuePath)) {
+      if ((_a = this.onFieldSubmit) == null ? void 0 : _a.call(this, valuePath)) {
         e.preventDefault();
       }
     }
@@ -1626,7 +1667,7 @@ function createValueInput(valuePath, ValueInput) {
 // mantine/hooks.tsx
 import { jsx as jsx9 } from "react/jsx-runtime";
 function SimpleSelect(props) {
-  return /* @__PURE__ */ jsx9(Select, { ...props });
+  return /* @__PURE__ */ jsx9(Select, __spreadValues({}, props));
 }
 function useMantineFormFields({
   onFieldValueChange,
@@ -1635,7 +1676,7 @@ function useMantineFormFields({
   onFieldSubmit,
   fields
 }) {
-  const form = useMemo3(
+  const form = useMemo2(
     function() {
       return new MantineFormImpl(fields);
     },
@@ -1677,39 +1718,40 @@ function useMantineFormFields({
   ]);
   return form;
 }
+var _fields_dec2, _init2, _fields;
+_fields_dec2 = [observable2.ref];
 var MantineFormImpl = class {
-  textInputCache = new Cache(
-    createTextInput.bind(this)
-  );
-  valueInputCache = new Cache(
-    createValueInput.bind(this)
-  );
-  checkboxCache = new Cache(
-    createCheckbox.bind(this)
-  );
-  radioGroupCache = new Cache(
-    createRadioGroup.bind(this)
-  );
-  radioCache = new Cache(
-    createRadio.bind(this)
-  );
-  pillCache = new Cache(
-    createPill.bind(this)
-  );
-  listCache = new Cache(
-    createList.bind(this)
-  );
-  fieldsViewCache = new Cache(
-    createFieldsView.bind(this)
-  );
-  formCache = new Cache(createForm.bind(this));
-  @observable2.ref
-  accessor fields;
-  onFieldValueChange;
-  onFieldFocus;
-  onFieldBlur;
-  onFieldSubmit;
   constructor(fields) {
+    __publicField(this, "textInputCache", new Cache(
+      createTextInput.bind(this)
+    ));
+    __publicField(this, "valueInputCache", new Cache(
+      createValueInput.bind(this)
+    ));
+    __publicField(this, "checkboxCache", new Cache(
+      createCheckbox.bind(this)
+    ));
+    __publicField(this, "radioGroupCache", new Cache(
+      createRadioGroup.bind(this)
+    ));
+    __publicField(this, "radioCache", new Cache(
+      createRadio.bind(this)
+    ));
+    __publicField(this, "pillCache", new Cache(
+      createPill.bind(this)
+    ));
+    __publicField(this, "listCache", new Cache(
+      createList.bind(this)
+    ));
+    __publicField(this, "fieldsViewCache", new Cache(
+      createFieldsView.bind(this)
+    ));
+    __publicField(this, "formCache", new Cache(createForm.bind(this)));
+    __privateAdd(this, _fields, __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this);
+    __publicField(this, "onFieldValueChange");
+    __publicField(this, "onFieldFocus");
+    __publicField(this, "onFieldBlur");
+    __publicField(this, "onFieldSubmit");
     this.fields = fields;
   }
   textInput(valuePath, TextInput = TextInputImpl) {
@@ -1786,7 +1828,12 @@ var MantineFormImpl = class {
       this
     );
   }
+  // TODO have an option to bind to a Text/(value: T) => JSX.Element for viewing form fields
 };
+_init2 = __decoratorStart(null);
+_fields = new WeakMap();
+__decorateElement(_init2, 4, "fields", _fields_dec2, MantineFormImpl, _fields);
+__decoratorMetadata(_init2, MantineFormImpl);
 
 // types/merge_validators.ts
 import {
@@ -1794,10 +1841,7 @@ import {
   validate as validate3
 } from "@strictly/define";
 function mergeValidators(validators1, validators2) {
-  const validators = {
-    ...validators1,
-    ...validators2
-  };
+  const validators = __spreadValues(__spreadValues({}, validators1), validators2);
   const keys1 = new Set(Object.keys(validators1));
   const keys2 = new Set(Object.keys(validators2));
   return Array.from(keys1.intersection(keys2)).reduce(
@@ -1833,7 +1877,6 @@ export {
   AbstractSelectValueTypeConverter,
   DefaultErrorRenderer,
   FormModel,
-  FormPresenter,
   IntegerToStringConverter,
   NullableToBooleanConverter,
   SelectDiscriminatedUnionConverter,