@strictly/react-form 0.0.1 → 0.0.3

package/field_converters/chain_field_converter.ts

@@ -2,13 +2,14 @@ import {
   UnreachableError,
 } from '@strictly/base'
 import {
-  type FieldConversion,
-  FieldConversionResult,
-  type FieldConverter,
-  type SafeFieldConverter,
+  type AnnotatedFieldConversion,
+  type AnnotatedFieldConverter,
+  type UnreliableFieldConversion,
+  UnreliableFieldConversionType,
+  type UnreliableFieldConverter,
 } from 'types/field_converters'
 
-export function chainFieldConverter<
+export function chainUnreliableFieldConverter<
   From,
   Intermediate,
   To,
@@ -17,27 +18,27 @@ export function chainFieldConverter<
   ValuePath extends string,
   Context,
 >(
-  from: FieldConverter<From, Intermediate, E1, ValuePath, Context>,
-  to: FieldConverter<Intermediate, To, E2, ValuePath, Context>,
-): FieldConverter<From, To, E1 | E2, ValuePath, Context> {
-  return function (value: From, valuePath: ValuePath, context: Context): FieldConversion<To, E1 | E2> {
+  from: UnreliableFieldConverter<From, Intermediate, E1, ValuePath, Context>,
+  to: UnreliableFieldConverter<Intermediate, To, E2, ValuePath, Context>,
+): UnreliableFieldConverter<From, To, E1 | E2, ValuePath, Context> {
+  return function (value: From, valuePath: ValuePath, context: Context): UnreliableFieldConversion<To, E1 | E2> {
     const fromConversion = from(value, valuePath, context)
     switch (fromConversion.type) {
-      case FieldConversionResult.Success:
+      case UnreliableFieldConversionType.Success:
         return to(fromConversion.value, valuePath, context)
-      case FieldConversionResult.Failure:
+      case UnreliableFieldConversionType.Failure:
         if (fromConversion.value != null) {
           const toConversion = to(fromConversion.value[0], valuePath, context)
           switch (toConversion.type) {
-            case FieldConversionResult.Success:
+            case UnreliableFieldConversionType.Success:
               return {
-                type: FieldConversionResult.Failure,
+                type: UnreliableFieldConversionType.Failure,
                 error: fromConversion.error,
                 value: [toConversion.value],
               }
-            case FieldConversionResult.Failure:
+            case UnreliableFieldConversionType.Failure:
               return {
-                type: FieldConversionResult.Failure,
+                type: UnreliableFieldConversionType.Failure,
                 error: fromConversion.error,
                 value: toConversion.value,
               }
@@ -46,7 +47,7 @@ export function chainFieldConverter<
           }
         } else {
           return {
-            type: FieldConversionResult.Failure,
+            type: UnreliableFieldConversionType.Failure,
             error: fromConversion.error,
             value: null,
           }
@@ -57,18 +58,31 @@ export function chainFieldConverter<
   }
 }
 
-export function chainSafeFieldConverter<
+export function chainAnnotatedFieldConverter<
   From,
   Intermediate,
   To,
   ValuePath extends string,
   Context,
 >(
-  from: SafeFieldConverter<From, Intermediate, ValuePath, Context>,
-  to: SafeFieldConverter<Intermediate, To, ValuePath, Context>,
-): SafeFieldConverter<From, To, ValuePath, Context> {
-  return function (value: From, valuePath: ValuePath, context: Context): To {
-    const intermediate = from(value, valuePath, context)
-    return to(intermediate, valuePath, context)
+  from: AnnotatedFieldConverter<From, Intermediate, ValuePath, Context>,
+  to: AnnotatedFieldConverter<Intermediate, To, ValuePath, Context>,
+): AnnotatedFieldConverter<From, To, ValuePath, Context> {
+  return function (value: From, valuePath: ValuePath, context: Context): AnnotatedFieldConversion {
+    const {
+      required: intermediateRequired,
+      readonly: intermediateDisabled,
+      value: intermediateValue,
+    } = from(value, valuePath, context)
+    const {
+      required: finalRequired,
+      readonly: finalDisabled,
+      value: finalValue,
+    } = to(intermediateValue, valuePath, context)
+    return {
+      value: finalValue,
+      required: intermediateRequired || finalRequired,
+      readonly: intermediateDisabled || finalDisabled,
+    }
   }
 }

package/field_converters/identity_converter.ts

@@ -1,29 +1,33 @@
 import {
-  FieldConversionResult,
-  type FieldConverter,
-  type SafeFieldConverter,
+  type AnnotatedFieldConverter,
+  UnreliableFieldConversionType,
+  type UnreliableFieldConverter,
 } from 'types/field_converters'
 
-export function safeIdentityConverter<
+export function annotatedIdentityConverter<
   V,
   ValuePath extends string,
   Context,
->(): SafeFieldConverter<
+>(required: boolean = false): AnnotatedFieldConverter<
   V,
   V,
   ValuePath,
   Context
 > {
-  return function (v: V) {
-    return v
+  return function (value: V) {
+    return {
+      value,
+      required,
+      readonly: false,
+    }
   }
 }
 
-export function identityConverter<
+export function unreliableIdentityConverter<
   V,
   ValuePath extends string,
   Context,
->(): FieldConverter<
+>(): UnreliableFieldConverter<
   V,
   V,
   never,
@@ -32,7 +36,7 @@ export function identityConverter<
 > {
   return function (value: V) {
     return {
-      type: FieldConversionResult.Success,
+      type: UnreliableFieldConversionType.Success,
       value,
     }
   }

package/field_converters/integer_to_string_converter.ts

@@ -1,30 +1,36 @@
 import {
-  type FieldConversion,
-  FieldConversionResult,
+  type AnnotatedFieldConversion,
   type TwoWayFieldConverter,
+  type UnreliableFieldConversion,
+  UnreliableFieldConversionType,
 } from 'types/field_converters'
 
 export class IntegerToStringConverter<E, ValuePath extends string, Context>
   implements TwoWayFieldConverter<number, string, E, ValuePath, Context>
 {
-  constructor(private readonly isNanError: E) {
+  constructor(private readonly isNanError: E, private readonly base = 10) {
   }
 
-  convert(from: number): string {
-    return Math.floor(from).toString()
+  convert(from: number): AnnotatedFieldConversion<string> {
+    const value = Math.floor(from).toString()
+    return {
+      value,
+      required: false,
+      readonly: false,
+    }
   }
 
-  revert(from: string): FieldConversion<number, E> {
-    const value = parseInt(from, 10)
+  revert(from: string): UnreliableFieldConversion<number, E> {
+    const value = parseInt(from, this.base)
     if (Number.isNaN(value)) {
       return {
-        type: FieldConversionResult.Failure,
+        type: UnreliableFieldConversionType.Failure,
         error: this.isNanError,
         value: null,
       }
     } else {
       return {
-        type: FieldConversionResult.Success,
+        type: UnreliableFieldConversionType.Success,
         value,
       }
     }

package/field_converters/list_converter.ts

@@ -1,15 +1,20 @@
-import { type SafeFieldConverter } from 'types/field_converters'
+import { type AnnotatedFieldConverter } from 'types/field_converters'
 
 export function listConverter<
   E,
   K extends string,
   ValuePath extends string,
   Context,
->(): SafeFieldConverter<readonly E[], K[], ValuePath, Context> {
+>(): AnnotatedFieldConverter<readonly E[], K[], ValuePath, Context> {
   return function (from: readonly E[], valuePath: ValuePath) {
-    return from.map(function (_v, i) {
+    const value = from.map(function (_v, i) {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return `${valuePath as string}.${i}` as K
     })
+    return {
+      value,
+      required: false,
+      readonly: false,
+    }
   }
 }

package/field_converters/maybe_identity_converter.ts

@@ -1,6 +1,7 @@
 import {
-  type FieldConversion,
+  type AnnotatedFieldConversion,
   type TwoWayFieldConverter,
+  type UnreliableFieldConversion,
 } from 'types/field_converters'
 
 export class MaybeIdentityConverter<From, To, E, ValuePath extends string, Context>
@@ -12,12 +13,14 @@ export class MaybeIdentityConverter<From, To, E, ValuePath extends string, Conte
   ) {
   }
 
-  convert(from: From, valuePath: ValuePath, context: Context): To | From {
+  convert(from: From, valuePath: ValuePath, context: Context): AnnotatedFieldConversion<To | From> {
     return this.converter.convert(from, valuePath, context)
   }
 
-  revert(from: To | From, valuePath: ValuePath, context: Context): FieldConversion<From, E> {
-    const value = this.isFrom(from) ? this.converter.convert(from, valuePath, context) : from
+  revert(from: To | From, valuePath: ValuePath, context: Context): UnreliableFieldConversion<From, E> {
+    const value = this.isFrom(from)
+      ? this.converter.convert(from, valuePath, context).value
+      : from
     return this.converter.revert(value, valuePath, context)
   }
 }

package/field_converters/nullable_to_boolean_converter.ts

@@ -1,13 +1,14 @@
 import {
   copy,
-  type ReadonlyTypeDefOf,
+  type ReadonlyTypeOfType,
   type Type,
-  type ValueTypeOf,
+  type ValueOfType,
 } from '@strictly/define'
 import {
-  type FieldConversion,
-  FieldConversionResult,
+  type AnnotatedFieldConversion,
   type TwoWayFieldConverterWithValueFactory,
+  type UnreliableFieldConversion,
+  UnreliableFieldConversionType,
 } from 'types/field_converters'
 
 export class NullableToBooleanConverter<
@@ -15,42 +16,48 @@ export class NullableToBooleanConverter<
   E,
   ValuePath extends string,
   Context,
+  NullType extends null | undefined,
 > implements TwoWayFieldConverterWithValueFactory<
-  ValueTypeOf<ReadonlyTypeDefOf<T>> | null,
+  ValueOfType<ReadonlyTypeOfType<T>> | NullType,
   boolean,
   E,
   ValuePath,
   Context
 > {
-  readonly defaultValue: ValueTypeOf<ReadonlyTypeDefOf<T>> | null
+  readonly defaultValue: ValueOfType<ReadonlyTypeOfType<T>> | NullType
 
   constructor(
     private readonly typeDef: T,
-    private readonly prototype: ValueTypeOf<ReadonlyTypeDefOf<T>>,
+    private readonly prototype: ValueOfType<ReadonlyTypeOfType<T>>,
+    private readonly nullType: NullType,
     defaultToNull = true,
   ) {
-    this.defaultValue = defaultToNull ? null : prototype
+    this.defaultValue = defaultToNull ? this.nullType : prototype
   }
 
-  convert(from: ValueTypeOf<ReadonlyTypeDefOf<T>> | null): boolean {
-    return from != null
+  convert(from: ValueOfType<ReadonlyTypeOfType<T>> | NullType): AnnotatedFieldConversion<boolean> {
+    return {
+      value: from !== this.nullType,
+      required: false,
+      readonly: false,
+    }
   }
 
-  revert(from: boolean): FieldConversion<ValueTypeOf<ReadonlyTypeDefOf<T>> | null, E> {
+  revert(from: boolean): UnreliableFieldConversion<ValueOfType<ReadonlyTypeOfType<T>> | NullType, E> {
     if (from) {
-      const value: ValueTypeOf<T> = copy(this.typeDef, this.prototype)
+      const value: ValueOfType<T> = copy(this.typeDef, this.prototype)
       return {
-        type: FieldConversionResult.Success,
+        type: UnreliableFieldConversionType.Success,
         value,
       }
     }
     return {
-      type: FieldConversionResult.Success,
-      value: null,
+      type: UnreliableFieldConversionType.Success,
+      value: this.nullType,
     }
   }
 
-  create(): ValueTypeOf<ReadonlyTypeDefOf<T>> | null {
+  create(): ValueOfType<ReadonlyTypeOfType<T>> | NullType {
     return this.defaultValue
   }
 }

package/field_converters/select_value_type_converter.ts

@@ -1,31 +1,35 @@
 import {
+  type ExhaustiveArrayOfUnion,
   reverse,
   type StringKeyOf,
 } from '@strictly/base'
 import {
   copy,
   type LiteralTypeDef,
+  type ReadonlyTypeOfType,
   type Type,
   type UnionTypeDef,
-  type ValueTypeOf,
+  type ValueOfType,
   type ValueTypesOfDiscriminatedUnion,
 } from '@strictly/define'
 import {
-  type FieldConversion,
-  FieldConversionResult,
+  type AnnotatedFieldConversion,
   type TwoWayFieldConverterWithValueFactory,
+  type UnreliableFieldConversion,
+  UnreliableFieldConversionType,
 } from 'types/field_converters'
 
 export abstract class AbstractSelectValueTypeConverter<
   T extends Type,
+  From extends ValueOfType<T> | undefined,
   To extends string | null,
-  Values extends Readonly<Record<NonNullable<To>, ValueTypeOf<T>>>,
+  Values extends Readonly<Record<NonNullable<To>, From>>,
   NoSuchValueError,
   ValuePath extends string,
   Context,
 > implements TwoWayFieldConverterWithValueFactory<
-  ValueTypeOf<T>,
-  keyof Values | null,
+  From,
+  To,
   NoSuchValueError,
   ValuePath,
   Context
@@ -33,50 +37,56 @@ export abstract class AbstractSelectValueTypeConverter<
   constructor(
     protected readonly typeDef: T,
     protected readonly values: Values,
-    private readonly defaultValueKey: keyof Values | null,
+    private readonly defaultValueKey: keyof Values | null | undefined,
     private readonly noSuchValueError: NoSuchValueError | null,
+    private readonly required: boolean,
   ) {
   }
 
-  revert(from: keyof Values | null): FieldConversion<ValueTypeOf<T>, NoSuchValueError> {
-    const prototype: ValueTypeOf<T> | null = from == null ? null : this.values[from]
+  revert(from: To): UnreliableFieldConversion<From, NoSuchValueError> {
+    const prototype: From = from == null ? null! : this.values[from]
     if (prototype == null && this.noSuchValueError != null) {
       return {
-        type: FieldConversionResult.Failure,
+        type: UnreliableFieldConversionType.Failure,
         error: this.noSuchValueError,
         value: null,
       }
     }
-    const value = prototype == null ? null : copy(this.typeDef, prototype)
+    const value = prototype == null ? prototype : copy(this.typeDef, prototype)
     // TODO given we are dealing with strings, maybe we should have a check to make sure value is in the record
     // of values?
     return {
-      type: FieldConversionResult.Success,
+      type: UnreliableFieldConversionType.Success,
       value: value!,
     }
   }
 
-  convert(from: ValueTypeOf<T>): To {
-    if (from == null) {
-      return null!
+  convert(from: From): AnnotatedFieldConversion<To> {
+    const value = from == null ? from! : this.doConvert(from)
+    return {
+      value,
+      required: this.required,
+      readonly: false,
     }
-    return this.doConvert(from)
   }
 
-  protected abstract doConvert(from: ValueTypeOf<T>): To
+  protected abstract doConvert(from: NonNullable<ValueOfType<T>>): To
 
-  create(): ValueTypeOf<T> {
+  create(): From {
     return this.defaultValueKey != null ? this.values[this.defaultValueKey] : null!
   }
 }
 
 export class SelectDiscriminatedUnionConverter<
   U extends UnionTypeDef,
+  From extends ValueOfType<ReadonlyTypeOfType<Type<U>>> | (Required extends true ? never : undefined),
   To extends StringKeyOf<U['unions']> | null,
   ValuePath extends string,
   Context,
+  Required extends boolean,
 > extends AbstractSelectValueTypeConverter<
   Type<U>,
+  From,
   To,
   ValueTypesOfDiscriminatedUnion<U>,
   never,
@@ -84,19 +94,21 @@ export class SelectDiscriminatedUnionConverter<
   Context
 > {
   constructor(
-    typeDef: Type<U>,
+    type: Type<U>,
     values: ValueTypesOfDiscriminatedUnion<U>,
     defaultValueKey: keyof U['unions'],
+    required: Required,
   ) {
     super(
-      typeDef,
+      type,
       values,
       defaultValueKey,
       null,
+      required,
     )
   }
 
-  protected override doConvert(from: ValueTypeOf<Type<U>>) {
+  protected override doConvert(from: NonNullable<ValueOfType<Type<U>>>) {
     const {
       definition: {
         discriminator,
@@ -108,15 +120,18 @@ export class SelectDiscriminatedUnionConverter<
 
 export class SelectLiteralConverter<
   L extends string | number | null,
+  From extends L | (Required extends true ? never : undefined),
   To extends string | null,
-  Values extends Record<NonNullable<L>, NonNullable<To>>,
+  Values extends Record<NonNullable<From>, NonNullable<To>>,
   NoSuchValueError,
   ValuePath extends string,
   Context,
+  Required extends boolean,
 > extends AbstractSelectValueTypeConverter<
   Type<LiteralTypeDef<L>>,
+  From,
   To,
-  Record<NonNullable<To>, L>,
+  Record<NonNullable<To>, NonNullable<From>>,
   NoSuchValueError,
   ValuePath,
   Context
@@ -124,18 +139,63 @@ export class SelectLiteralConverter<
   constructor(
     typeDef: Type<LiteralTypeDef<L>>,
     private readonly valuesToStrings: Values,
-    defaultValue: L | null,
+    defaultValue: From,
     noSuchValueError: NoSuchValueError | null,
+    required: Required,
   ) {
     super(
       typeDef,
       reverse(valuesToStrings),
       defaultValue && valuesToStrings[defaultValue],
       noSuchValueError,
+      required,
+    )
+  }
+
+  protected override doConvert(from: NonNullable<From>) {
+    return this.valuesToStrings[from]
+  }
+}
+
+export class SelectStringConverter<
+  L extends string | null,
+  From extends L | undefined,
+  A extends readonly NonNullable<From>[],
+  NoSuchValueError,
+  ValuePath extends string,
+  Context,
+> extends AbstractSelectValueTypeConverter<
+  Type<LiteralTypeDef<L>>,
+  From,
+  string | null,
+  Record<string, From>,
+  NoSuchValueError,
+  ValuePath,
+  Context
+> {
+  constructor(
+    typeDef: Type<LiteralTypeDef<L>>,
+    allowedValues: ExhaustiveArrayOfUnion<NonNullable<From>, A>,
+    defaultValue: L | undefined,
+    noSuchValueError: NoSuchValueError | null,
+    required = false,
+  ) {
+    super(
+      typeDef,
+      allowedValues.reduce<Record<string, From>>(
+        function (acc, value) {
+          acc[value] = value
+          return acc
+        },
+        {},
+      ),
+      defaultValue,
+      noSuchValueError,
+      required,
     )
   }
 
-  protected override doConvert(from: L) {
-    return from && this.valuesToStrings[from]
+  protected override doConvert(from: NonNullable<L>) {
+    return from
   }
 }