@strictly/react-form 0.0.1 → 0.0.2

package/.out/core/mobx/types.d.ts

@@ -1,4 +1,4 @@
-import { type ToTypeOfFieldAdapter } from './field_adapter';
+import { type ToOfFieldAdapter } from './field_adapter';
 import { type FlattenedConvertedFieldsOf, type FormPresenter } from './form_presenter';
 /**
  * Used to extract the supported value paths from a presenter
@@ -8,7 +8,7 @@ export type ValuePathsOfPresenter<Presenter extends FormPresenter<any, any, any,
  * Used to extract the render type (so the value that is passed to the view) of a given value path
  * from a presenter
  */
-export type ToTypeOfPresenterValuePath<Presenter extends FormPresenter<any, any, any, any>, K extends ValuePathsOfPresenter<Presenter>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? ToTypeOfFieldAdapter<ValuePathsToAdapters[K]> : never;
+export type ToValueOfPresenterValuePath<Presenter extends FormPresenter<any, any, any, any>, K extends ValuePathsOfPresenter<Presenter>> = Presenter extends FormPresenter<infer _1, infer _2, infer _3, infer ValuePathsToAdapters> ? ToOfFieldAdapter<ValuePathsToAdapters[K]> : never;
 /**
  * Extracts the form fields from the presenter. The recommended way is to
  * define the form fields explicitly and use that type to enforce the types

package/.out/field_converters/chain_field_converter.d.ts

@@ -1,3 +1,3 @@
-import { type FieldConverter, type SafeFieldConverter } from 'types/field_converters';
-export declare function chainFieldConverter<From, Intermediate, To, E1, E2, 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>;
-export declare function chainSafeFieldConverter<From, Intermediate, To, ValuePath extends string, Context>(from: SafeFieldConverter<From, Intermediate, ValuePath, Context>, to: SafeFieldConverter<Intermediate, To, ValuePath, Context>): SafeFieldConverter<From, To, ValuePath, Context>;
+import { type AnnotatedFieldConverter, type UnreliableFieldConverter } from 'types/field_converters';
+export declare function chainUnreliableFieldConverter<From, Intermediate, To, E1, E2, ValuePath extends string, Context>(from: UnreliableFieldConverter<From, Intermediate, E1, ValuePath, Context>, to: UnreliableFieldConverter<Intermediate, To, E2, ValuePath, Context>): UnreliableFieldConverter<From, To, E1 | E2, ValuePath, Context>;
+export declare function chainAnnotatedFieldConverter<From, Intermediate, To, ValuePath extends string, Context>(from: AnnotatedFieldConverter<From, Intermediate, ValuePath, Context>, to: AnnotatedFieldConverter<Intermediate, To, ValuePath, Context>): AnnotatedFieldConverter<From, To, ValuePath, Context>;

package/.out/field_converters/chain_field_converter.js

@@ -1,24 +1,24 @@
 import { UnreachableError, } from '@strictly/base';
-import { FieldConversionResult, } from 'types/field_converters';
-export function chainFieldConverter(from, to) {
+import { UnreliableFieldConversionType, } from 'types/field_converters';
+export function chainUnreliableFieldConverter(from, to) {
     return function (value, valuePath, context) {
         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,
                             };
@@ -28,7 +28,7 @@ export function chainFieldConverter(from, to) {
                 }
                 else {
                     return {
-                        type: FieldConversionResult.Failure,
+                        type: UnreliableFieldConversionType.Failure,
                         error: fromConversion.error,
                         value: null,
                     };
@@ -38,9 +38,14 @@ export function chainFieldConverter(from, to) {
         }
     };
 }
-export function chainSafeFieldConverter(from, to) {
+export function chainAnnotatedFieldConverter(from, to) {
     return function (value, valuePath, context) {
-        const intermediate = from(value, valuePath, context);
-        return to(intermediate, valuePath, context);
+        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/.out/field_converters/identity_converter.d.ts

@@ -1,3 +1,3 @@
-import { type FieldConverter, type SafeFieldConverter } from 'types/field_converters';
-export declare function safeIdentityConverter<V, ValuePath extends string, Context>(): SafeFieldConverter<V, V, ValuePath, Context>;
-export declare function identityConverter<V, ValuePath extends string, Context>(): FieldConverter<V, V, never, ValuePath, Context>;
+import { type AnnotatedFieldConverter, type UnreliableFieldConverter } from 'types/field_converters';
+export declare function annotatedIdentityConverter<V, ValuePath extends string, Context>(required?: boolean): AnnotatedFieldConverter<V, V, ValuePath, Context>;
+export declare function unreliableIdentityConverter<V, ValuePath extends string, Context>(): UnreliableFieldConverter<V, V, never, ValuePath, Context>;

package/.out/field_converters/identity_converter.js

@@ -1,13 +1,17 @@
-import { FieldConversionResult, } from 'types/field_converters';
-export function safeIdentityConverter() {
-    return function (v) {
-        return v;
+import { UnreliableFieldConversionType, } from 'types/field_converters';
+export function annotatedIdentityConverter(required = false) {
+    return function (value) {
+        return {
+            value,
+            required,
+            readonly: false,
+        };
     };
 }
-export function identityConverter() {
+export function unreliableIdentityConverter() {
     return function (value) {
         return {
-            type: FieldConversionResult.Success,
+            type: UnreliableFieldConversionType.Success,
             value,
         };
     };

package/.out/field_converters/integer_to_string_converter.d.ts

@@ -1,7 +1,8 @@
-import { type FieldConversion, type TwoWayFieldConverter } from 'types/field_converters';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/field_converters';
 export declare class IntegerToStringConverter<E, ValuePath extends string, Context> implements TwoWayFieldConverter<number, string, E, ValuePath, Context> {
     private readonly isNanError;
-    constructor(isNanError: E);
-    convert(from: number): string;
-    revert(from: string): FieldConversion<number, E>;
+    private readonly base;
+    constructor(isNanError: E, base?: number);
+    convert(from: number): AnnotatedFieldConversion<string>;
+    revert(from: string): UnreliableFieldConversion<number, E>;
 }

package/.out/field_converters/integer_to_string_converter.js

@@ -1,24 +1,31 @@
-import { FieldConversionResult, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class IntegerToStringConverter {
     isNanError;
-    constructor(isNanError) {
+    base;
+    constructor(isNanError, base = 10) {
         this.isNanError = isNanError;
+        this.base = base;
     }
     convert(from) {
-        return Math.floor(from).toString();
+        const value = Math.floor(from).toString();
+        return {
+            value,
+            required: false,
+            readonly: false,
+        };
     }
     revert(from) {
-        const value = parseInt(from, 10);
+        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/.out/field_converters/list_converter.d.ts

@@ -1,2 +1,2 @@
-import { type SafeFieldConverter } from 'types/field_converters';
-export declare function listConverter<E, K extends string, ValuePath extends string, Context>(): SafeFieldConverter<readonly E[], K[], ValuePath, Context>;
+import { type AnnotatedFieldConverter } from 'types/field_converters';
+export declare function listConverter<E, K extends string, ValuePath extends string, Context>(): AnnotatedFieldConverter<readonly E[], K[], ValuePath, Context>;

package/.out/field_converters/list_converter.js

@@ -1,8 +1,13 @@
 export function listConverter() {
     return function (from, 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}.${i}`;
         });
+        return {
+            value,
+            required: false,
+            readonly: false,
+        };
     };
 }

package/.out/field_converters/maybe_identity_converter.d.ts

@@ -1,8 +1,8 @@
-import { type FieldConversion, type TwoWayFieldConverter } from 'types/field_converters';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/field_converters';
 export declare class MaybeIdentityConverter<From, To, E, ValuePath extends string, Context> implements TwoWayFieldConverter<From, From | To, E, ValuePath, Context> {
     private readonly converter;
     private readonly isFrom;
     constructor(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, isFrom: (to: From | To) => to is From);
-    convert(from: From, valuePath: ValuePath, context: Context): To | From;
-    revert(from: To | From, valuePath: ValuePath, context: Context): FieldConversion<From, E>;
+    convert(from: From, valuePath: ValuePath, context: Context): AnnotatedFieldConversion<To | From>;
+    revert(from: To | From, valuePath: ValuePath, context: Context): UnreliableFieldConversion<From, E>;
 }

package/.out/field_converters/maybe_identity_converter.js

@@ -9,7 +9,9 @@ export class MaybeIdentityConverter {
         return this.converter.convert(from, valuePath, context);
     }
     revert(from, valuePath, context) {
-        const value = this.isFrom(from) ? this.converter.convert(from, valuePath, context) : from;
+        const value = this.isFrom(from)
+            ? this.converter.convert(from, valuePath, context).value
+            : from;
         return this.converter.revert(value, valuePath, context);
     }
 }

package/.out/field_converters/nullable_to_boolean_converter.d.ts

@@ -1,11 +1,12 @@
-import { type ReadonlyTypeDefOf, type Type, type ValueTypeOf } from '@strictly/define';
-import { type FieldConversion, type TwoWayFieldConverterWithValueFactory } from 'types/field_converters';
-export declare class NullableToBooleanConverter<T extends Type, E, ValuePath extends string, Context> implements TwoWayFieldConverterWithValueFactory<ValueTypeOf<ReadonlyTypeDefOf<T>> | null, boolean, E, ValuePath, Context> {
+import { type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConversion } from 'types/field_converters';
+export declare class NullableToBooleanConverter<T extends Type, E, ValuePath extends string, Context, NullType extends null | undefined> implements TwoWayFieldConverterWithValueFactory<ValueOfType<ReadonlyTypeOfType<T>> | NullType, boolean, E, ValuePath, Context> {
     private readonly typeDef;
     private readonly prototype;
-    readonly defaultValue: ValueTypeOf<ReadonlyTypeDefOf<T>> | null;
-    constructor(typeDef: T, prototype: ValueTypeOf<ReadonlyTypeDefOf<T>>, defaultToNull?: boolean);
-    convert(from: ValueTypeOf<ReadonlyTypeDefOf<T>> | null): boolean;
-    revert(from: boolean): FieldConversion<ValueTypeOf<ReadonlyTypeDefOf<T>> | null, E>;
-    create(): ValueTypeOf<ReadonlyTypeDefOf<T>> | null;
+    private readonly nullType;
+    readonly defaultValue: ValueOfType<ReadonlyTypeOfType<T>> | NullType;
+    constructor(typeDef: T, prototype: ValueOfType<ReadonlyTypeOfType<T>>, nullType: NullType, defaultToNull?: boolean);
+    convert(from: ValueOfType<ReadonlyTypeOfType<T>> | NullType): AnnotatedFieldConversion<boolean>;
+    revert(from: boolean): UnreliableFieldConversion<ValueOfType<ReadonlyTypeOfType<T>> | NullType, E>;
+    create(): ValueOfType<ReadonlyTypeOfType<T>> | NullType;
 }

package/.out/field_converters/nullable_to_boolean_converter.js

@@ -1,28 +1,34 @@
 import { copy, } from '@strictly/define';
-import { FieldConversionResult, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class NullableToBooleanConverter {
     typeDef;
     prototype;
+    nullType;
     defaultValue;
-    constructor(typeDef, prototype, defaultToNull = true) {
+    constructor(typeDef, prototype, nullType, defaultToNull = true) {
         this.typeDef = typeDef;
         this.prototype = prototype;
-        this.defaultValue = defaultToNull ? null : prototype;
+        this.nullType = nullType;
+        this.defaultValue = defaultToNull ? this.nullType : prototype;
     }
     convert(from) {
-        return from != null;
+        return {
+            value: from !== this.nullType,
+            required: false,
+            readonly: false,
+        };
     }
     revert(from) {
         if (from) {
             const value = 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() {

package/.out/field_converters/select_value_type_converter.d.ts

@@ -1,23 +1,28 @@
-import { type StringKeyOf } from '@strictly/base';
-import { type LiteralTypeDef, type Type, type UnionTypeDef, type ValueTypeOf, type ValueTypesOfDiscriminatedUnion } from '@strictly/define';
-import { type FieldConversion, type TwoWayFieldConverterWithValueFactory } from 'types/field_converters';
-export declare abstract class AbstractSelectValueTypeConverter<T extends Type, To extends string | null, Values extends Readonly<Record<NonNullable<To>, ValueTypeOf<T>>>, NoSuchValueError, ValuePath extends string, Context> implements TwoWayFieldConverterWithValueFactory<ValueTypeOf<T>, keyof Values | null, NoSuchValueError, ValuePath, Context> {
+import { type ExhaustiveArrayOfUnion, type StringKeyOf } from '@strictly/base';
+import { type LiteralTypeDef, type ReadonlyTypeOfType, type Type, type UnionTypeDef, type ValueOfType, type ValueTypesOfDiscriminatedUnion } from '@strictly/define';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConversion } from 'types/field_converters';
+export declare abstract class AbstractSelectValueTypeConverter<T extends Type, From extends ValueOfType<T> | undefined, To extends string | null, Values extends Readonly<Record<NonNullable<To>, From>>, NoSuchValueError, ValuePath extends string, Context> implements TwoWayFieldConverterWithValueFactory<From, To, NoSuchValueError, ValuePath, Context> {
     protected readonly typeDef: T;
     protected readonly values: Values;
     private readonly defaultValueKey;
     private readonly noSuchValueError;
-    constructor(typeDef: T, values: Values, defaultValueKey: keyof Values | null, noSuchValueError: NoSuchValueError | null);
-    revert(from: keyof Values | null): FieldConversion<ValueTypeOf<T>, NoSuchValueError>;
-    convert(from: ValueTypeOf<T>): To;
-    protected abstract doConvert(from: ValueTypeOf<T>): To;
-    create(): ValueTypeOf<T>;
+    private readonly required;
+    constructor(typeDef: T, values: Values, defaultValueKey: keyof Values | null | undefined, noSuchValueError: NoSuchValueError | null, required: boolean);
+    revert(from: To): UnreliableFieldConversion<From, NoSuchValueError>;
+    convert(from: From): AnnotatedFieldConversion<To>;
+    protected abstract doConvert(from: NonNullable<ValueOfType<T>>): To;
+    create(): From;
 }
-export declare class SelectDiscriminatedUnionConverter<U extends UnionTypeDef, To extends StringKeyOf<U['unions']> | null, ValuePath extends string, Context> extends AbstractSelectValueTypeConverter<Type<U>, To, ValueTypesOfDiscriminatedUnion<U>, never, ValuePath, Context> {
-    constructor(typeDef: Type<U>, values: ValueTypesOfDiscriminatedUnion<U>, defaultValueKey: keyof U['unions']);
-    protected doConvert(from: ValueTypeOf<Type<U>>): any;
+export declare 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, ValuePath, Context> {
+    constructor(type: Type<U>, values: ValueTypesOfDiscriminatedUnion<U>, defaultValueKey: keyof U['unions'], required: Required);
+    protected doConvert(from: NonNullable<ValueOfType<Type<U>>>): any;
 }
-export declare class SelectLiteralConverter<L extends string | number | null, To extends string | null, Values extends Record<NonNullable<L>, NonNullable<To>>, NoSuchValueError, ValuePath extends string, Context> extends AbstractSelectValueTypeConverter<Type<LiteralTypeDef<L>>, To, Record<NonNullable<To>, L>, NoSuchValueError, ValuePath, Context> {
+export declare class SelectLiteralConverter<L extends string | number | null, From extends L | (Required extends true ? never : undefined), To extends string | null, 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>, NonNullable<From>>, NoSuchValueError, ValuePath, Context> {
     private readonly valuesToStrings;
-    constructor(typeDef: Type<LiteralTypeDef<L>>, valuesToStrings: Values, defaultValue: L | null, noSuchValueError: NoSuchValueError | null);
-    protected doConvert(from: L): Values[NonNullable<L>];
+    constructor(typeDef: Type<LiteralTypeDef<L>>, valuesToStrings: Values, defaultValue: From, noSuchValueError: NoSuchValueError | null, required: Required);
+    protected doConvert(from: NonNullable<From>): Values[NonNullable<From>];
+}
+export declare 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?: boolean);
+    protected doConvert(from: NonNullable<L>): NonNullable<L>;
 }

package/.out/field_converters/select_value_type_converter.js

@@ -1,47 +1,51 @@
 import { reverse, } from '@strictly/base';
 import { copy, } from '@strictly/define';
-import { FieldConversionResult, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class AbstractSelectValueTypeConverter {
     typeDef;
     values;
     defaultValueKey;
     noSuchValueError;
-    constructor(typeDef, values, defaultValueKey, noSuchValueError) {
+    required;
+    constructor(typeDef, values, defaultValueKey, noSuchValueError, required) {
         this.typeDef = typeDef;
         this.values = values;
         this.defaultValueKey = defaultValueKey;
         this.noSuchValueError = noSuchValueError;
+        this.required = required;
     }
     revert(from) {
         const prototype = 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) {
-        if (from == null) {
-            return null;
-        }
-        return this.doConvert(from);
+        const value = from == null ? from : this.doConvert(from);
+        return {
+            value,
+            required: this.required,
+            readonly: false,
+        };
     }
     create() {
         return this.defaultValueKey != null ? this.values[this.defaultValueKey] : null;
     }
 }
 export class SelectDiscriminatedUnionConverter extends AbstractSelectValueTypeConverter {
-    constructor(typeDef, values, defaultValueKey) {
-        super(typeDef, values, defaultValueKey, null);
+    constructor(type, values, defaultValueKey, required) {
+        super(type, values, defaultValueKey, null, required);
     }
     doConvert(from) {
         const { definition: { discriminator, }, } = this.typeDef;
@@ -50,11 +54,22 @@ export class SelectDiscriminatedUnionConverter extends AbstractSelectValueTypeCo
 }
 export class SelectLiteralConverter extends AbstractSelectValueTypeConverter {
     valuesToStrings;
-    constructor(typeDef, valuesToStrings, defaultValue, noSuchValueError) {
-        super(typeDef, reverse(valuesToStrings), defaultValue && valuesToStrings[defaultValue], noSuchValueError);
+    constructor(typeDef, valuesToStrings, defaultValue, noSuchValueError, required) {
+        super(typeDef, reverse(valuesToStrings), defaultValue && valuesToStrings[defaultValue], noSuchValueError, required);
         this.valuesToStrings = valuesToStrings;
     }
     doConvert(from) {
-        return from && this.valuesToStrings[from];
+        return this.valuesToStrings[from];
+    }
+}
+export class SelectStringConverter extends AbstractSelectValueTypeConverter {
+    constructor(typeDef, allowedValues, defaultValue, noSuchValueError, required = false) {
+        super(typeDef, allowedValues.reduce(function (acc, value) {
+            acc[value] = value;
+            return acc;
+        }, {}), defaultValue, noSuchValueError, required);
+    }
+    doConvert(from) {
+        return from;
     }
 }

package/.out/field_converters/specs/chain_field_converter.tests.d.ts

@@ -0,0 +1 @@
+export {};