@strictly/react-form 0.0.1 → 0.0.2

package/core/mobx/field_adapter_builder.ts

@@ -1,25 +1,22 @@
 import {
-  chainFieldConverter,
-  chainSafeFieldConverter,
+  chainAnnotatedFieldConverter,
+  chainUnreliableFieldConverter,
 } from 'field_converters/chain_field_converter'
 import {
-  identityConverter,
-  safeIdentityConverter,
+  annotatedIdentityConverter,
+  unreliableIdentityConverter,
 } from 'field_converters/identity_converter'
 import { listConverter } from 'field_converters/list_converter'
 import { MaybeIdentityConverter } from 'field_converters/maybe_identity_converter'
-import {
-  validatingConverter,
-} from 'field_converters/validating_converter'
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory'
 import {
-  type FieldConverter,
+  type AnnotatedFieldConverter,
   type FieldValueFactory,
-  type SafeFieldConverter,
   type TwoWayFieldConverter,
   type TwoWayFieldConverterWithValueFactory,
+  type UnreliableFieldConverter,
 } from 'types/field_converters'
-import { type FieldValidator } from 'types/field_validator'
+import { type FieldAdapter } from './field_adapter'
 
 class FieldAdapterBuilder<
   From,
@@ -29,66 +26,18 @@ class FieldAdapterBuilder<
   Context,
 > {
   constructor(
-    readonly convert: SafeFieldConverter<From, To, ValuePath, Context>,
+    readonly convert: AnnotatedFieldConverter<From, To, ValuePath, Context>,
     readonly create: FieldValueFactory<From, ValuePath, Context>,
-    readonly revert?: FieldConverter<To, From, E, ValuePath, Context>,
+    readonly revert?: UnreliableFieldConverter<To, From, E, ValuePath, Context>,
   ) {
   }
 
-  validateFrom<
-    E2,
-  >(...validators: readonly FieldValidator<
-    From,
-    E2,
-    ValuePath,
-    Context
-  >[]): FieldAdapterBuilder<
-    From,
-    To,
-    E | E2,
-    ValuePath,
-    Context
-  > {
-    return new FieldAdapterBuilder(
-      this.convert,
-      this.create,
-      this.revert && chainFieldConverter(
-        this.revert,
-        validatingConverter(validators),
-      ),
-    )
-  }
-
-  validateTo<
-    E2,
-  >(...validators: readonly FieldValidator<
-    To,
-    E2,
-    ValuePath,
-    Context
-  >[]): FieldAdapterBuilder<
-    From,
-    To,
-    E | E2,
-    ValuePath,
-    Context
-  > {
-    return new FieldAdapterBuilder(
-      this.convert,
-      this.create,
-      this.revert && chainFieldConverter(
-        validatingConverter(validators),
-        this.revert,
-      ),
-    )
-  }
-
   chain<To2, E2 = E>(
-    converter: SafeFieldConverter<To, To2, ValuePath, Context>,
-    reverter?: FieldConverter<To2, To, E2, ValuePath, Context>,
+    converter: AnnotatedFieldConverter<To, To2, ValuePath, Context>,
+    reverter?: UnreliableFieldConverter<To2, To, E2, ValuePath, Context>,
   ): FieldAdapterBuilder<From, To2, E | E2, ValuePath, Context> {
     return new FieldAdapterBuilder(
-      chainSafeFieldConverter<
+      chainAnnotatedFieldConverter<
         From,
         To,
         To2,
@@ -99,7 +48,7 @@ class FieldAdapterBuilder<
         converter,
       ),
       this.create,
-      this.revert && reverter && chainFieldConverter<
+      this.revert && reverter && chainUnreliableFieldConverter<
         To2,
         To,
         From,
@@ -114,7 +63,7 @@ class FieldAdapterBuilder<
     )
   }
 
-  withReverter(reverter: FieldConverter<
+  withReverter(reverter: UnreliableFieldConverter<
     To,
     From,
     E,
@@ -152,6 +101,10 @@ class FieldAdapterBuilder<
       this.revert && identityConverter.revert.bind(identityConverter),
     )
   }
+
+  get narrow(): FieldAdapter<From, To, E, ValuePath, Context> {
+    return this
+  }
 }
 
 export function adapter<
@@ -160,7 +113,7 @@ export function adapter<
   ValuePath extends string,
   Context,
 >(
-  converter: SafeFieldConverter<From, To, ValuePath, Context>,
+  converter: AnnotatedFieldConverter<From, To, ValuePath, Context>,
   valueFactory: FieldValueFactory<From, ValuePath, Context>,
 ): FieldAdapterBuilder<From, To, never, ValuePath, Context>
 export function adapter<
@@ -170,9 +123,9 @@ export function adapter<
   ValuePath extends string,
   Context,
 >(
-  converter: SafeFieldConverter<From, To, ValuePath, Context>,
+  converter: AnnotatedFieldConverter<From, To, ValuePath, Context>,
   valueFactory: FieldValueFactory<From, ValuePath, Context>,
-  reverter: FieldConverter<To, From, E, ValuePath, Context>,
+  reverter: UnreliableFieldConverter<To, From, E, ValuePath, Context>,
 ): FieldAdapterBuilder<From, To, E, ValuePath, Context>
 export function adapter<
   From,
@@ -181,9 +134,9 @@ export function adapter<
   ValuePath extends string,
   Context,
 >(
-  converter: SafeFieldConverter<From, To, ValuePath, Context>,
+  converter: AnnotatedFieldConverter<From, To, ValuePath, Context>,
   valueFactory: FieldValueFactory<From, ValuePath, Context>,
-  reverter?: FieldConverter<To, From, E, ValuePath, Context>,
+  reverter?: UnreliableFieldConverter<To, From, E, ValuePath, Context>,
 ): FieldAdapterBuilder<From, To, E, ValuePath, Context> {
   return new FieldAdapterBuilder(converter, valueFactory, reverter)
 }
@@ -259,7 +212,7 @@ export function adapterFromPrototype<
   ValuePath extends string,
   Context,
 >(
-  converter: SafeFieldConverter<From, To, ValuePath, Context>,
+  converter: AnnotatedFieldConverter<From, To, ValuePath, Context>,
   prototype: From,
 ): FieldAdapterBuilder<From, To, never, ValuePath, Context>
 export function adapterFromPrototype<
@@ -279,7 +232,18 @@ export function adapterFromPrototype<
   ValuePath extends string,
   Context,
 >(
-  converter: SafeFieldConverter<From, To, ValuePath, Context> | TwoWayFieldConverter<From, To, E, ValuePath, Context>,
+  converter: AnnotatedFieldConverter<
+    From,
+    To,
+    ValuePath,
+    Context
+  > | TwoWayFieldConverter<
+    From,
+    To,
+    E,
+    ValuePath,
+    Context
+  >,
   prototype: From,
 ): FieldAdapterBuilder<From, To, E, ValuePath, Context> {
   const factory = prototypingFieldValueFactory<From, ValuePath, Context>(prototype)
@@ -292,11 +256,11 @@ export function identityAdapter<
   V,
   ValuePath extends string,
   Context,
->(prototype: V) {
+>(prototype: V, required?: boolean) {
   return new FieldAdapterBuilder(
-    safeIdentityConverter<V, ValuePath, Context>(),
+    annotatedIdentityConverter<V, ValuePath, Context>(required),
     prototypingFieldValueFactory(prototype),
-    identityConverter<V, ValuePath, Context>(),
+    unreliableIdentityConverter<V, ValuePath, Context>(),
   )
 }
 

package/core/mobx/field_adapters_of_values.ts

@@ -0,0 +1,17 @@
+import { type FieldAdapter } from './field_adapter'
+
+export type FieldAdaptersOfValues<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  FlattenedValues extends Readonly<Record<string, any>>,
+  TypePathsToValuePaths extends Readonly<Record<keyof FlattenedValues, string>> = Readonly<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Record<keyof FlattenedValues, any>
+  >,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
+> = {
+  readonly [
+    K in keyof FlattenedValues
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ]: FieldAdapter<FlattenedValues[K], any, any, TypePathsToValuePaths[K], Context>
+}

package/core/mobx/flattened_adapters_of_fields.ts

@@ -1,7 +1,7 @@
 import {
-  type ReadonlyTypeDefOf,
+  type ReadonlyTypeOfType,
   type Type,
-  type ValueTypeOf,
+  type ValueOfType,
 } from '@strictly/define'
 import { type FieldAdapter } from 'core/mobx/field_adapter'
 import {
@@ -30,6 +30,6 @@ type AdapterOfField<
   ValuePath extends string | number | symbol,
 > = ValuePath extends string
   ? F extends Field<infer V, infer E> ? undefined extends T ? FieldAdapter<V, V, E, ValuePath>
-    : FieldAdapter<ValueTypeOf<ReadonlyTypeDefOf<NonNullable<T>>>, V, E, ValuePath>
+    : FieldAdapter<ValueOfType<ReadonlyTypeOfType<NonNullable<T>>>, V, E, ValuePath>
   : never
   : never

package/core/mobx/flattened_list_types_of_type.ts

@@ -0,0 +1,17 @@
+import {
+  type FlattenedTypesOfType,
+  type ListTypeDef,
+  type Type,
+} from '@strictly/define'
+import { type SimplifyDeep } from 'type-fest'
+
+export type ListValuePathsOfType<T extends Type> = keyof FlattenedListTypesOfType<T>
+
+export type FlattenedListTypesOfType<T extends Type> = FlattenedListTypesOfTypes<
+  // SimplifyDeep is necessary here otherwise FlattenedListTypeDefsOfFlattened will complain about infinite depth
+  SimplifyDeep<FlattenedTypesOfType<T, null>>
+>
+
+type FlattenedListTypesOfTypes<T extends Readonly<Record<string, Type>>> = {
+  [K in keyof T as T[K]['definition'] extends ListTypeDef ? K : never]: T[K]
+}

package/core/mobx/form_fields_of_field_adapters.ts

@@ -0,0 +1,16 @@
+import { type ValueOf } from 'type-fest'
+import { type Field } from 'types/field'
+import { type FieldAdapter } from './field_adapter'
+
+export type FormFieldsOfFieldAdapters<
+  ValuePathsToTypePaths extends Readonly<Record<string, string>>,
+  FieldAdapters extends Partial<Readonly<Record<ValueOf<ValuePathsToTypePaths>, FieldAdapter>>>,
+> = {
+  [
+    K in keyof ValuePathsToTypePaths as undefined extends FieldAdapters[ValuePathsToTypePaths[K]] ? never : K
+  ]: FormFieldOfFieldAdapter<FieldAdapters[ValuePathsToTypePaths[K]]>
+}
+
+type FormFieldOfFieldAdapter<
+  F extends FieldAdapter | undefined,
+> = F extends FieldAdapter<infer _From, infer To, infer E> ? Field<To, E> : never