@strictly/react-form 0.0.8 → 0.0.9

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

@@ -7,6 +7,9 @@ declare class FieldAdapterBuilder<From, To, E, ValuePath extends string, Context
     constructor(convert: AnnotatedFieldConverter<From, To, ValuePath, Context>, create: FieldValueFactory<From, ValuePath, Context>, revert?: UnreliableFieldConverter<To, From, E, ValuePath, Context> | undefined);
     chain<To2, E2 = E>(converter: AnnotatedFieldConverter<To, To2, ValuePath, Context>, reverter?: UnreliableFieldConverter<To2, To, E2, ValuePath, Context>): FieldAdapterBuilder<From, To2, E | E2, ValuePath, Context>;
     withReverter(reverter: UnreliableFieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+    nullable(): FieldAdapterBuilder<From | null, To | null, E, ValuePath, Context>;
+    optional(): FieldAdapterBuilder<From | undefined, To | undefined, E, ValuePath, Context>;
+    private or;
     withIdentity(isFrom: (from: To | From) => from is From): FieldAdapterBuilder<From, To | From, E, ValuePath, Context>;
     get narrow(): FieldAdapter<From, To, E, ValuePath, Context>;
 }
@@ -17,5 +20,6 @@ export declare function adapterFromTwoWayConverter<From, To, E, ValuePath extend
 export declare function adapterFromPrototype<From, To, ValuePath extends string, Context>(converter: AnnotatedFieldConverter<From, To, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
 export declare function adapterFromPrototype<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
 export declare function identityAdapter<V, ValuePath extends string, Context>(prototype: V, required?: boolean): FieldAdapterBuilder<V, V, never, ValuePath, Context>;
+export declare function trimmingStringAdapter<ValuePath extends string, Context>(): FieldAdapterBuilder<string, string, never, ValuePath, Context>;
 export declare function listAdapter<E, ValuePath extends string, Context>(): FieldAdapterBuilder<readonly E[], readonly E[], never, ValuePath, Context>;
 export {};

package/.out/core/mobx/field_adapter_builder.js

@@ -1,7 +1,9 @@
 import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chain_field_converter';
 import { annotatedIdentityConverter, unreliableIdentityConverter, } from 'field_converters/identity_converter';
 import { MaybeIdentityConverter } from 'field_converters/maybe_identity_converter';
+import { TrimmingStringConverter } from 'field_converters/trimming_string_converter';
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
+import { UnreliableFieldConversionType, } from 'types/field_converters';
 class FieldAdapterBuilder {
     convert;
     create;
@@ -17,6 +19,32 @@ class FieldAdapterBuilder {
     withReverter(reverter) {
         return new FieldAdapterBuilder(this.convert, this.create, reverter);
     }
+    nullable() {
+        return this.or(null);
+    }
+    optional() {
+        return this.or(undefined);
+    }
+    or(proto) {
+        function isFrom(v) {
+            return v !== proto;
+        }
+        function isTo(v) {
+            return v !== proto;
+        }
+        return new FieldAdapterBuilder((v, valuePath, context) => isFrom(v)
+            ? this.convert(v, valuePath, context)
+            : {
+                value: v,
+                readonly: false,
+                required: false,
+            }, this.create, (v, valuePath, context) => isTo(v) && this.revert
+            ? this.revert(v, valuePath, context)
+            : {
+                type: UnreliableFieldConversionType.Success,
+                value: proto,
+            });
+    }
     withIdentity(isFrom) {
         const identityConverter = new MaybeIdentityConverter({
             convert: this.convert,
@@ -46,6 +74,9 @@ export function adapterFromPrototype(converter, prototype) {
 export function identityAdapter(prototype, required) {
     return new FieldAdapterBuilder(annotatedIdentityConverter(required), prototypingFieldValueFactory(prototype), unreliableIdentityConverter());
 }
+export function trimmingStringAdapter() {
+    return adapterFromTwoWayConverter(new TrimmingStringConverter(), prototypingFieldValueFactory(''));
+}
 export function listAdapter() {
     return new FieldAdapterBuilder(annotatedIdentityConverter(false), prototypingFieldValueFactory([]), unreliableIdentityConverter());
 }

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

@@ -4,11 +4,11 @@ import { type FormPresenter } from './form_presenter';
 import { type ValuePathsOfPresenter } from './types';
 type ValueOfPresenter<P extends FormPresenter<any, any, any, any>> = P extends FormPresenter<infer T, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;
 type ModelOfPresenter<P extends FormPresenter<any, any, any, any>> = ReturnType<P['createModel']>;
-export declare function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, any>>(presenter: P, value: ValueOfPresenter<P>, { onValidFieldSubmit, onValidFormSubmit, }: {
+export declare function useDefaultMobxFormHooks<P extends FormPresenter<any, any, any, any>>(presenter: P, value: ValueOfPresenter<P>, { onValidFieldSubmit, onValidFormSubmit, }?: {
     onValidFieldSubmit?: <Path extends ValuePathsOfPresenter<P>>(model: ModelOfPresenter<P>, valuePath: Path) => void;
     onValidFormSubmit?: (model: ModelOfPresenter<P>, value: ValueOfPresenter<P>) => void;
 }): {
     model: ModelOfPresenter<P>;
-    onFormSubmit?: (value: ValueOfPresenter<P>) => void;
+    onFormSubmit?: () => void;
 } & Omit<FieldsViewProps<ModelOfPresenter<P>['fields']>, 'fields'>;
 export {};

package/.out/core/mobx/hooks.js

@@ -1,6 +1,6 @@
 import { useCallback, useMemo, } from 'react';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit, onValidFormSubmit, }) {
+export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit, onValidFormSubmit, } = {}) {
     const model = useMemo(function () {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return presenter.createModel(value);

package/.out/field_converters/chain_field_converter.js

@@ -40,12 +40,12 @@ export function chainUnreliableFieldConverter(from, to) {
 }
 export function chainAnnotatedFieldConverter(from, to) {
     return function (value, valuePath, context) {
-        const { required: intermediateRequired, readonly: intermediateDisabled, value: intermediateValue, } = from(value, valuePath, context);
-        const { required: finalRequired, readonly: finalDisabled, value: finalValue, } = to(intermediateValue, valuePath, context);
+        const { required: intermediateRequired, readonly: intermediateReadonly, value: intermediateValue, } = from(value, valuePath, context);
+        const { required: finalRequired, readonly: finalReadonly, value: finalValue, } = to(intermediateValue, valuePath, context);
         return {
             value: finalValue,
             required: intermediateRequired || finalRequired,
-            readonly: intermediateDisabled || finalDisabled,
+            readonly: intermediateReadonly || finalReadonly,
         };
     };
 }

package/.out/mantine/error_renderer.d.ts

@@ -1,6 +1,10 @@
 import { type ComponentType } from 'react';
-export type ErrorRendererProps<E> = {
+import { type ErrorOfField } from 'types/error_of_field';
+import { type Fields } from 'types/field';
+type InternalErrorRendererProps<E> = {
     error: E;
 };
-export type ErrorRenderer<E = any> = ComponentType<ErrorRendererProps<E>>;
-export declare function DefaultErrorRenderer({ error, }: ErrorRendererProps<any>): string;
+export type ErrorRendererProps<F extends Fields, K extends keyof Fields> = InternalErrorRendererProps<ErrorOfField<F[K]>>;
+export type ErrorRenderer<E = any> = ComponentType<InternalErrorRendererProps<E>>;
+export declare function DefaultErrorRenderer({ error, }: InternalErrorRendererProps<any>): string;
+export {};