@strictly/react-form 0.0.10 → 0.0.12

package/core/mobx/{form_presenter.ts → form_model.ts}

@@ -102,7 +102,7 @@ export type ValuePathsToAdaptersOf<
   }
   : never
 
-export abstract class FormPresenter<
+export class FormModel<
   T extends Type,
   ValueToTypePaths extends Readonly<Record<string, string>>,
   TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<
@@ -114,10 +114,173 @@ export abstract class FormPresenter<
     ValueToTypePaths
   >,
 > {
+  @observable.ref
+  accessor value: MobxValueOfType<T>
+  @observable.shallow
+  accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>
+  @observable.shallow
+  accessor errors: FlattenedErrors<ValuePathsToAdapters> = {}
+
+  private readonly flattenedTypeDefs: Readonly<Record<string, Type>>
+
   constructor(
     readonly type: T,
+    value: ValueOfType<ReadonlyTypeOfType<T>>,
     protected readonly adapters: TypePathsToAdapters,
   ) {
+    this.value = mobxCopy(type, value)
+    this.flattenedTypeDefs = flattenTypesOfType(type)
+    // pre-populate field overrides for consistent behavior when default information is overwritten
+    // then returned to
+    const conversions = flattenValueTo(
+      type,
+      this.value,
+      () => {},
+      (
+        _t: StrictTypeDef,
+        value: AnyValueType,
+        _setter,
+        typePath,
+        valuePath,
+      ): AnnotatedFieldConversion<FieldOverride> | undefined => {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const adapter = this.adapters[typePath as keyof TypePathsToAdapters]
+        if (adapter == null) {
+          return
+        }
+        const {
+          convert,
+          revert,
+        } = adapter
+        if (revert == null) {
+          // no need to store a temporary value if the value cannot be written back
+          return
+        }
+        return convert(value, valuePath, this.value)
+      },
+    )
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    this.fieldOverrides = map(conversions, function (_k, v) {
+      return v && [v.value]
+    }) as FlattenedFieldOverrides<ValuePathsToAdapters>
+  }
+
+  @computed
+  get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>> {
+    return new Proxy<SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>>(
+      this.knownFields,
+      {
+        get: (target, prop) => {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
+          const field = (target as any)[prop]
+          if (field != null) {
+            return field
+          }
+          if (typeof prop === 'string') {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return this.maybeSynthesizeFieldByValuePath(prop as keyof ValuePathsToAdapters)
+          }
+        },
+      },
+    )
+  }
+
+  @computed
+  private get knownFields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>> {
+    return flattenValueTo(
+      this.type,
+      this.value,
+      () => {},
+      // TODO swap these to valuePath, typePath in flatten
+      (_t: StrictTypeDef, _v: AnyValueType, _setter, typePath, valuePath): Field | undefined => {
+        return this.synthesizeFieldByPaths(
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          valuePath as keyof ValuePathsToAdapters,
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          typePath as keyof TypePathsToAdapters,
+        )
+      },
+    )
+  }
+
+  private maybeSynthesizeFieldByValuePath(valuePath: keyof ValuePathsToAdapters): Field | undefined {
+    let typePath: keyof TypePathsToAdapters
+    try {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      typePath = valuePathToTypePath<ValueToTypePaths, keyof ValueToTypePaths>(
+        this.type,
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        valuePath as keyof ValueToTypePaths,
+        true,
+      ) as keyof TypePathsToAdapters
+    } catch (e) {
+      // TODO make jsonValuePathToTypePath return null in the event of an invalid
+      // value path instead of throwing an exception
+      // assume that the path was invalid
+      return
+    }
+    return this.synthesizeFieldByPaths(valuePath, typePath)
+  }
+
+  private synthesizeFieldByPaths(valuePath: keyof ValuePathsToAdapters, typePath: keyof TypePathsToAdapters) {
+    const adapter = this.adapters[typePath]
+    if (adapter == null) {
+      // invalid path, which can happen
+      return
+    }
+    const {
+      convert,
+      create,
+    } = adapter
+
+    const fieldOverride = this.fieldOverrides[valuePath]
+    const accessor = this.getAccessorForValuePath(valuePath)
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const fieldTypeDef = this.flattenedTypeDefs[typePath as string]
+    const {
+      value,
+      required,
+      readonly,
+    } = convert(
+      accessor != null
+        ? accessor.value
+        : fieldTypeDef != null
+        ? mobxCopy(
+          fieldTypeDef,
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          create(valuePath as string, this.value),
+        )
+        // fake values can't be copied
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        : create(valuePath as string, this.value),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      valuePath as string,
+      this.value,
+    )
+    const error = this.errors[valuePath]
+    return {
+      value: fieldOverride != null ? fieldOverride[0] : value,
+      error,
+      readonly,
+      required,
+    }
+  }
+
+  getAccessorForValuePath(valuePath: keyof ValuePathsToAdapters): Accessor | undefined {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return this.accessors[valuePath as string]
+  }
+
+  @computed
+  // should only be referenced internally, so loosely typed
+  get accessors(): Readonly<Record<string, Accessor>> {
+    return flattenAccessorsOfType<T, Readonly<Record<string, Accessor>>>(
+      this.type,
+      this.value,
+      (value: ValueOfType<T>): void => {
+        this.value = mobxCopy(this.type, value)
+      },
+    )
   }
 
   private maybeGetAdapterForValuePath(valuePath: keyof ValuePathsToAdapters) {
@@ -140,23 +303,20 @@ export abstract class FormPresenter<
   }
 
   setFieldValueAndValidate<K extends keyof ValuePathsToAdapters>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
     value: ToOfFieldAdapter<ValuePathsToAdapters[K]>,
   ): boolean {
-    return this.internalSetFieldValue(model, valuePath, value, true)
+    return this.internalSetFieldValue(valuePath, value, true)
   }
 
   setFieldValue<K extends keyof ValuePathsToAdapters>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
     value: ToOfFieldAdapter<ValuePathsToAdapters[K]>,
   ): boolean {
-    return this.internalSetFieldValue(model, valuePath, value, false)
+    return this.internalSetFieldValue(valuePath, value, false)
   }
 
   addListItem<K extends keyof FlattenedListTypesOfType<T>>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
     // TODO can this type be simplified?
     elementValue: Maybe<ElementOfArray<FlattenedValuesOfType<T>[K]>> = null,
@@ -164,7 +324,7 @@ export abstract class FormPresenter<
   ) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const listValuePath = valuePath as string
-    const accessor = model.accessors[valuePath]
+    const accessor = this.accessors[valuePath]
     const listTypePath = this.typePath(valuePath)
     const definedIndex = index ?? accessor.value.length
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -181,7 +341,7 @@ export abstract class FormPresenter<
       : elementAdapter.create(
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         elementTypePath as string,
-        model.value,
+        this.value,
       )
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const originalList: any[] = accessor.value
@@ -192,7 +352,7 @@ export abstract class FormPresenter<
     ]
     // shuffle the overrides around to account for new indices
     // to so this we need to sort the array indices in descending order
-    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('.')
@@ -207,11 +367,11 @@ export abstract class FormPresenter<
       // descending
       return b - a
     })
-    runInAction(function () {
-      targetPaths.forEach(function ([
+    runInAction(() => {
+      targetPaths.forEach(([
         index,
         postfix,
-      ]) {
+      ]) => {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const fromJsonPath = [
           listValuePath,
@@ -224,99 +384,99 @@ export abstract class FormPresenter<
           `${index + 1}`,
           ...postfix,
         ].join('.') as keyof ValuePathsToAdapters
-        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 any value overrides so the new list isn't shadowed
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      delete model.fieldOverrides[listValuePath as keyof ValuePathsToAdapters]
+      delete this.fieldOverrides[listValuePath as keyof ValuePathsToAdapters]
     })
   }
 
-  removeListItem<K extends keyof FlattenedListTypesOfType<T>>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
-    elementValuePath: `${K}.${number}`,
-  ) {
-    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)
-
-    // shuffle the overrides around to account for new indices
-    // to so this we need to sort the array indices in descending order
-    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),
-      ] as const
-    }).filter(function ([index]) {
-      return index > elementIndex
-    }).sort(function ([a], [b]) {
-      // ascending
-      return a - b
-    })
-
-    runInAction(function () {
-      targetPaths.forEach(function ([
-        index,
-        postfix,
-      ]) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const fromJsonPath = [
+  removeListItem<K extends keyof FlattenedListTypesOfType<T>>(...elementValuePaths: readonly `${K}.${number}`[]) {
+    // sort and reverse so we delete last to first so indices of sequential deletions are preserved
+    const orderedElementValuePaths = elementValuePaths.toSorted().reverse()
+    runInAction(() => {
+      orderedElementValuePaths.forEach(elementValuePath => {
+        const [
           listValuePath,
-          `${index}`,
-          ...postfix,
-        ].join('.') as keyof ValuePathsToAdapters
+          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)
+
+        // shuffle the overrides around to account for new indices
+        // to so this we need to sort the array indices in descending order
+        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),
+          ] as const
+        }).filter(function ([index]) {
+          return index > elementIndex
+        }).sort(function ([a], [b]) {
+          // descending
+          return a - b
+        })
+
+        targetPaths.forEach(([
+          index,
+          postfix,
+        ]) => {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          const fromJsonPath = [
+            listValuePath,
+            `${index}`,
+            ...postfix,
+          ].join('.') as keyof ValuePathsToAdapters
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          const toJsonPath = [
+            listValuePath,
+            `${index - 1}`,
+            ...postfix,
+          ].join('.') as keyof ValuePathsToAdapters
+          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 any value overrides so the new list isn't shadowed
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const toJsonPath = [
-          listValuePath,
-          `${index - 1}`,
-          ...postfix,
-        ].join('.') as keyof ValuePathsToAdapters
-        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
+        delete this.fieldOverrides[listValuePath as keyof ValuePathsToAdapters]
       })
-      accessor.set(newList)
-      // delete any value overrides so the new list isn't shadowed
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      delete model.fieldOverrides[listValuePath as keyof ValuePathsToAdapters]
     })
   }
 
   private internalSetFieldValue<K extends keyof ValuePathsToAdapters>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
     value: ToOfFieldAdapter<ValuePathsToAdapters[K]>,
     displayValidation: boolean,
@@ -326,21 +486,21 @@ export abstract class FormPresenter<
     assertExists(revert, 'setting value not supported {}', valuePath)
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
-    const conversion = revert(value, valuePath as any, model.value)
-    const accessor = model.getAccessorForValuePath(valuePath)
+    const conversion = revert(value, valuePath as any, this.value)
+    const accessor = this.getAccessorForValuePath(valuePath)
     return runInAction(() => {
-      model.fieldOverrides[valuePath] = [value]
+      this.fieldOverrides[valuePath] = [value]
       switch (conversion.type) {
         case UnreliableFieldConversionType.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 UnreliableFieldConversionType.Success:
-          delete model.errors[valuePath]
+          delete this.errors[valuePath]
           accessor?.set(conversion.value)
           return true
         default:
@@ -349,22 +509,16 @@ export abstract class FormPresenter<
     })
   }
 
-  clearFieldError<K extends keyof ValuePathsToAdapters>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
-    valuePath: K,
-  ) {
-    const fieldOverride = model.fieldOverrides[valuePath]
+  clearFieldError<K extends keyof ValuePathsToAdapters>(valuePath: K) {
+    const fieldOverride = this.fieldOverrides[valuePath]
     if (fieldOverride != null) {
-      runInAction(function () {
-        delete model.errors[valuePath]
+      runInAction(() => {
+        delete this.errors[valuePath]
       })
     }
   }
 
-  clearFieldValue<K extends StringKeyOf<ValueToTypePaths>>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
-    valuePath: K,
-  ) {
+  clearFieldValue<K extends StringKeyOf<ValueToTypePaths>>(valuePath: K) {
     const typePath = this.typePath(valuePath)
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const adapter = this.adapters[typePath as keyof TypePathsToAdapters]
@@ -375,41 +529,34 @@ export abstract class FormPresenter<
       convert,
       create,
     } = adapter
-    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)
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const key = valuePath as unknown as keyof ValuePathsToAdapters
-    runInAction(function () {
-      model.fieldOverrides[key] = [displayValue]
+    runInAction(() => {
+      this.fieldOverrides[key] = [displayValue]
     })
   }
 
-  clearAll(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
-    value: ValueOfType<T>,
-  ): void {
+  clearAll(value: ValueOfType<T>): void {
     runInAction(() => {
-      model.errors = {}
+      this.errors = {}
       // TODO this isn't correct, should reload from value
-      model.fieldOverrides = {}
-      model.value = mobxCopy(this.type, value)
+      this.fieldOverrides = {}
+      this.value = mobxCopy(this.type, value)
     })
   }
 
-  isValuePathActive<K extends keyof ValuePathsToAdapters>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
-    valuePath: K,
-  ): boolean {
-    const values = flattenValuesOfType(this.type, model.value)
+  isValuePathActive<K extends keyof ValuePathsToAdapters>(valuePath: K): boolean {
+    const values = flattenValuesOfType(this.type, this.value)
     const keys = new Set(Object.keys(values))
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return keys.has(valuePath as string)
   }
 
   validateField<K extends keyof ValuePathsToAdapters>(
-    model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>,
     valuePath: K,
     ignoreDefaultValue = false,
   ): boolean {
@@ -418,18 +565,18 @@ export abstract class FormPresenter<
       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
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        : create(valuePath as string, model.value),
+        : create(valuePath as string, this.value),
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       valuePath as string,
-      model.value,
+      this.value,
     )
     const value = fieldOverride != null
       ? fieldOverride[0]
@@ -439,23 +586,23 @@ export abstract class FormPresenter<
     if (ignoreDefaultValue) {
       const {
         value: defaultDisplayValue,
-      } = convert(create(valuePath, model.value), valuePath, model.value)
+      } = convert(create(valuePath, this.value), valuePath, this.value)
       if (defaultDisplayValue === value) {
         return true
       }
     }
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const conversion = revert(value, valuePath as string, model.value)
-    return runInAction(function () {
+    const conversion = revert(value, valuePath as string, this.value)
+    return runInAction(() => {
       switch (conversion.type) {
         case UnreliableFieldConversionType.Failure:
-          model.errors[valuePath] = conversion.error
+          this.errors[valuePath] = conversion.error
           if (conversion.value != null && accessor != null && dirty) {
             accessor.set(conversion.value[0])
           }
           return false
         case UnreliableFieldConversionType.Success:
-          delete model.errors[valuePath]
+          delete this.errors[valuePath]
           if (accessor != null && dirty) {
             accessor.set(conversion.value)
           }
@@ -466,9 +613,9 @@ export abstract class FormPresenter<
     })
   }
 
-  validateAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>): boolean {
+  validateAll(): boolean {
     // sort keys shortest to longest so parent changes don't overwrite child changes
-    const accessors = toArray(model.accessors).toSorted(function ([a], [b]) {
+    const accessors = toArray(this.accessors).toSorted(function ([a], [b]) {
       return a.length - b.length
     })
     return runInAction(() => {
@@ -495,20 +642,20 @@ export abstract class FormPresenter<
             // no convert method means this field is immutable
             return success
           }
-          const fieldOverride = model.fieldOverrides[adapterPath]
+          const fieldOverride = this.fieldOverrides[adapterPath]
           const {
             value: storedValue,
-          } = convert(accessor.value, valuePath, model.value)
+          } = convert(accessor.value, valuePath, this.value)
           const value = fieldOverride != null
             ? fieldOverride[0]
             : storedValue
           // TODO more nuanced comparison
           const dirty = fieldOverride != null && fieldOverride[0] !== storedValue
 
-          const conversion = revert(value, valuePath, model.value)
+          const conversion = revert(value, valuePath, this.value)
           switch (conversion.type) {
             case UnreliableFieldConversionType.Failure:
-              model.errors[adapterPath] = conversion.error
+              this.errors[adapterPath] = conversion.error
               if (conversion.value != null && dirty) {
                 accessor.set(conversion.value[0])
               }
@@ -517,7 +664,7 @@ export abstract class FormPresenter<
               if (dirty) {
                 accessor.set(conversion.value)
               }
-              delete model.errors[adapterPath]
+              delete this.errors[adapterPath]
               return success
             default:
               throw new UnreachableError(conversion)
@@ -527,193 +674,4 @@ export abstract class FormPresenter<
       )
     })
   }
-
-  abstract createModel(value: ValueOfType<ReadonlyTypeOfType<T>>): FormModel<
-    T,
-    ValueToTypePaths,
-    TypePathsToAdapters,
-    ValuePathsToAdapters
-  >
-}
-
-export class FormModel<
-  T extends Type,
-  ValueToTypePaths extends Readonly<Record<string, string>>,
-  TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<
-    FlattenedValuesOfType<T, '*'>,
-    ValueOfType<ReadonlyTypeOfType<T>>
-  >,
-  ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<
-    TypePathsToAdapters,
-    ValueToTypePaths
-  >,
-> {
-  @observable.ref
-  accessor value: MobxValueOfType<T>
-  @observable.shallow
-  accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>
-  @observable.shallow
-  accessor errors: FlattenedErrors<ValuePathsToAdapters> = {}
-
-  private readonly flattenedTypeDefs: Readonly<Record<string, Type>>
-
-  constructor(
-    private readonly type: T,
-    value: ValueOfType<ReadonlyTypeOfType<T>>,
-    private readonly adapters: TypePathsToAdapters,
-  ) {
-    this.value = mobxCopy(type, value)
-    this.flattenedTypeDefs = flattenTypesOfType(type)
-    // pre-populate field overrides for consistent behavior when default information is overwritten
-    // then returned to
-    const conversions = flattenValueTo(
-      type,
-      this.value,
-      () => {},
-      (
-        _t: StrictTypeDef,
-        value: AnyValueType,
-        _setter,
-        typePath,
-        valuePath,
-      ): AnnotatedFieldConversion<FieldOverride> | undefined => {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const adapter = this.adapters[typePath as keyof TypePathsToAdapters]
-        if (adapter == null) {
-          return
-        }
-        const {
-          convert,
-          revert,
-        } = adapter
-        if (revert == null) {
-          // no need to store a temporary value if the value cannot be written back
-          return
-        }
-        return convert(value, valuePath, this.value)
-      },
-    )
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    this.fieldOverrides = map(conversions, function (_k, v) {
-      return v && [v.value]
-    }) as FlattenedFieldOverrides<ValuePathsToAdapters>
-  }
-
-  @computed
-  get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>> {
-    return new Proxy<SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>>(
-      this.knownFields,
-      {
-        get: (target, prop) => {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
-          const field = (target as any)[prop]
-          if (field != null) {
-            return field
-          }
-          if (typeof prop === 'string') {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            return this.maybeSynthesizeFieldByValuePath(prop as keyof ValuePathsToAdapters)
-          }
-        },
-      },
-    )
-  }
-
-  @computed
-  private get knownFields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>> {
-    return flattenValueTo(
-      this.type,
-      this.value,
-      () => {},
-      // TODO swap these to valuePath, typePath in flatten
-      (_t: StrictTypeDef, _v: AnyValueType, _setter, typePath, valuePath): Field | undefined => {
-        return this.synthesizeFieldByPaths(
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          valuePath as keyof ValuePathsToAdapters,
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          typePath as keyof TypePathsToAdapters,
-        )
-      },
-    )
-  }
-
-  private maybeSynthesizeFieldByValuePath(valuePath: keyof ValuePathsToAdapters): Field | undefined {
-    let typePath: keyof TypePathsToAdapters
-    try {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      typePath = valuePathToTypePath<ValueToTypePaths, keyof ValueToTypePaths>(
-        this.type,
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        valuePath as keyof ValueToTypePaths,
-        true,
-      ) as keyof TypePathsToAdapters
-    } catch (e) {
-      // TODO make jsonValuePathToTypePath return null in the event of an invalid
-      // value path instead of throwing an exception
-      // assume that the path was invalid
-      return
-    }
-    return this.synthesizeFieldByPaths(valuePath, typePath)
-  }
-
-  private synthesizeFieldByPaths(valuePath: keyof ValuePathsToAdapters, typePath: keyof TypePathsToAdapters) {
-    const adapter = this.adapters[typePath]
-    if (adapter == null) {
-      // invalid path, which can happen
-      return
-    }
-    const {
-      convert,
-      create,
-    } = adapter
-
-    const fieldOverride = this.fieldOverrides[valuePath]
-    const accessor = this.getAccessorForValuePath(valuePath)
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const fieldTypeDef = this.flattenedTypeDefs[typePath as string]
-    const {
-      value,
-      required,
-      readonly,
-    } = convert(
-      accessor != null
-        ? accessor.value
-        : fieldTypeDef != null
-        ? mobxCopy(
-          fieldTypeDef,
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          create(valuePath as string, this.value),
-        )
-        // fake values can't be copied
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        : create(valuePath as string, this.value),
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      valuePath as string,
-      this.value,
-    )
-    const error = this.errors[valuePath]
-    return {
-      value: fieldOverride != null ? fieldOverride[0] : value,
-      error,
-      readonly,
-      required,
-    }
-  }
-
-  getAccessorForValuePath(valuePath: keyof ValuePathsToAdapters): Accessor | undefined {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return this.accessors[valuePath as string]
-  }
-
-  @computed
-  // should only be referenced internally, so loosely typed
-  get accessors(): Readonly<Record<string, Accessor>> {
-    return flattenAccessorsOfType<T, Readonly<Record<string, Accessor>>>(
-      this.type,
-      this.value,
-      (value: ValueOfType<T>): void => {
-        this.value = mobxCopy(this.type, value)
-      },
-    )
-  }
 }