@strictly/react-form 0.0.9 → 0.0.11

package/.out/core/mobx/specs/form_presenter.tests.js

@@ -9,6 +9,11 @@ import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 import { createMockedAdapter, resetMockAdapter, } from './fixtures';
 const IS_NAN_ERROR = 1;
+class TestFormPresenter extends FormPresenter {
+    createModel(value) {
+        return new FormModel(this.type, value, this.adapters);
+    }
+}
 const originalIntegerToStringAdapter = adapterFromTwoWayConverter(new IntegerToStringConverter(IS_NAN_ERROR), prototypingFieldValueFactory(0));
 const originalBooleanToBooleanAdapter = identityAdapter(false);
 describe('all', function () {
@@ -286,7 +291,7 @@ describe('all', function () {
             const adapters = {
                 $: integerToStringAdapter,
             };
-            const presenter = new FormPresenter(typeDef, adapters);
+            const presenter = new TestFormPresenter(typeDef, adapters);
             const originalValue = 2;
             let model;
             beforeEach(function () {
@@ -330,7 +335,8 @@ describe('all', function () {
                         const newValue = -1;
                         const errorCode = 65;
                         beforeEach(function () {
-                            integerToStringAdapter.revert?.mockReturnValueOnce({
+                            var _a;
+                            (_a = integerToStringAdapter.revert) === null || _a === void 0 ? void 0 : _a.mockReturnValueOnce({
                                 type: UnreliableFieldConversionType.Failure,
                                 error: errorCode,
                                 value: [newValue],
@@ -383,7 +389,7 @@ describe('all', function () {
             const converters = {
                 '$.*': integerToStringAdapter,
             };
-            const presenter = new FormPresenter(typeDef, converters);
+            const presenter = new TestFormPresenter(typeDef, converters);
             let originalValue;
             let model;
             beforeEach(function () {
@@ -543,7 +549,8 @@ describe('all', function () {
                             '7',
                         ],
                     ])('it reports the value of field %s as %s', function (path, fieldValue) {
-                        expect(model.fields[path]?.value).toBe(fieldValue);
+                        var _a;
+                        expect((_a = model.fields[path]) === null || _a === void 0 ? void 0 : _a.value).toBe(fieldValue);
                     });
                     it.each([
                         [
@@ -563,7 +570,8 @@ describe('all', function () {
                             2,
                         ],
                     ])('it reports the error of field %s', function (path, error) {
-                        expect(model.fields[path]?.error).toBe(error);
+                        var _a;
+                        expect((_a = model.fields[path]) === null || _a === void 0 ? void 0 : _a.error).toBe(error);
                     });
                 });
                 describe('add defined value', function () {
@@ -661,7 +669,7 @@ describe('all', function () {
                     $: adapterFromTwoWayConverter(new NullableToBooleanConverter(type, [1], null)),
                     '$.*': integerToStringAdapter,
                 };
-                const presenter = new FormPresenter(type, adapters);
+                const presenter = new TestFormPresenter(type, adapters);
                 let originalValue;
                 let model;
                 beforeEach(function () {
@@ -709,7 +717,7 @@ describe('all', function () {
                     '$.x:a': identityAdapter(0).narrow,
                     '$.y:b': identityAdapter(false).narrow,
                 };
-                const presenter = new FormPresenter(type, adapters);
+                const presenter = new TestFormPresenter(type, adapters);
                 describe('isValuePathActive', function () {
                     describe('discriminator x', function () {
                         const model = presenter.createModel({
@@ -766,7 +774,7 @@ describe('all', function () {
                 $: integerToStringAdapter,
                 '$.fake': booleanToBooleanAdapter,
             };
-            const presenter = new FormPresenter(typeDef, converters);
+            const presenter = new TestFormPresenter(typeDef, converters);
             let originalValue;
             let model;
             beforeEach(function () {

package/.out/core/mobx/specs/sub_form_field_adapters.tests.js

@@ -43,12 +43,13 @@ describe('subFormFieldAdapters', () => {
             expect(returnedValue).toEqual(mockedReturnedValue);
         });
         it('calls revert with the correct paths and values', () => {
+            var _a, _b;
             const mockedReturnedValue = {
                 type: UnreliableFieldConversionType.Success,
                 value: 'ok',
             };
             mockedFieldAdapter1.revert.mockReturnValue(mockedReturnedValue);
-            const returnedValue = adapters['$.a'].revert?.(true, '$.a', { a: 'y' });
+            const returnedValue = (_b = (_a = adapters['$.a']).revert) === null || _b === void 0 ? void 0 : _b.call(_a, true, '$.a', { a: 'y' });
             expect(fieldAdapter1.revert).toHaveBeenCalledWith(true, '$', 'y');
             expect(returnedValue).toEqual(mockedReturnedValue);
         });

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

@@ -1,9 +1,9 @@
 import { type StringConcatOf } from '@strictly/base';
-import { type Type, type ValueOfType } from '@strictly/define';
+import { type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
 import { type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './field_adapter';
 type SubFormFieldAdapter<F extends FieldAdapter, ValuePath extends string, Context> = FieldAdapter<FromOfFieldAdapter<F>, ToOfFieldAdapter<F>, ErrorOfFieldAdapter<F>, ValuePathOfFieldAdapter<F> extends StringConcatOf<'$', infer ValuePathSuffix> ? `${ValuePath}${ValuePathSuffix}` : string, Context>;
 type SubFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, ValuePath extends string, Context> = {
     [K in keyof SubAdapters as K extends StringConcatOf<'$', infer TypePathSuffix> ? `${TypePath}${TypePathSuffix}` : never]: SubFormFieldAdapter<SubAdapters[K], ValuePath, Context>;
 };
-export declare function subFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, TypePathsToValuePaths extends Record<TypePath, string>, ContextType extends Type>(subAdapters: SubAdapters, parentTypePath: TypePath, contextType: ContextType): SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath], ValueOfType<ContextType>>;
+export declare function subFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, TypePathsToValuePaths extends Record<TypePath, string>, ContextType extends Type>(subAdapters: SubAdapters, parentTypePath: TypePath, contextType: ContextType): SubFormFieldAdapters<SubAdapters, TypePath, TypePathsToValuePaths[TypePath], ValueOfType<ReadonlyTypeOfType<ContextType>>>;
 export {};

package/.out/field_converters/integer_to_string_converter.js

@@ -1,10 +1,18 @@
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class IntegerToStringConverter {
-    isNanError;
-    base;
     constructor(isNanError, base = 10) {
-        this.isNanError = isNanError;
-        this.base = base;
+        Object.defineProperty(this, "isNanError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: isNanError
+        });
+        Object.defineProperty(this, "base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: base
+        });
     }
     convert(from) {
         const value = Math.floor(from).toString();

package/.out/field_converters/maybe_identity_converter.js

@@ -1,9 +1,17 @@
 export class MaybeIdentityConverter {
-    converter;
-    isFrom;
     constructor(converter, isFrom) {
-        this.converter = converter;
-        this.isFrom = isFrom;
+        Object.defineProperty(this, "converter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: converter
+        });
+        Object.defineProperty(this, "isFrom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: isFrom
+        });
     }
     convert(from, valuePath, context) {
         return this.converter.convert(from, valuePath, context);

package/.out/field_converters/nullable_to_boolean_converter.js

@@ -1,14 +1,31 @@
 import { copy, } from '@strictly/define';
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class NullableToBooleanConverter {
-    typeDef;
-    prototype;
-    nullType;
-    defaultValue;
     constructor(typeDef, prototype, nullType, defaultToNull = true) {
-        this.typeDef = typeDef;
-        this.prototype = prototype;
-        this.nullType = nullType;
+        Object.defineProperty(this, "typeDef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: typeDef
+        });
+        Object.defineProperty(this, "prototype", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: prototype
+        });
+        Object.defineProperty(this, "nullType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: nullType
+        });
+        Object.defineProperty(this, "defaultValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.defaultValue = defaultToNull ? this.nullType : prototype;
     }
     convert(from) {

package/.out/field_converters/select_value_type_converter.js

@@ -2,17 +2,37 @@ import { reverse, } from '@strictly/base';
 import { copy, } from '@strictly/define';
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class AbstractSelectValueTypeConverter {
-    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;
+        Object.defineProperty(this, "typeDef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: typeDef
+        });
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: values
+        });
+        Object.defineProperty(this, "defaultValueKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: defaultValueKey
+        });
+        Object.defineProperty(this, "noSuchValueError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: noSuchValueError
+        });
+        Object.defineProperty(this, "required", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: required
+        });
     }
     revert(from) {
         const prototype = from == null ? null : this.values[from];
@@ -53,10 +73,14 @@ export class SelectDiscriminatedUnionConverter extends AbstractSelectValueTypeCo
     }
 }
 export class SelectLiteralConverter extends AbstractSelectValueTypeConverter {
-    valuesToStrings;
     constructor(typeDef, valuesToStrings, defaultValue, noSuchValueError, required) {
         super(typeDef, reverse(valuesToStrings), defaultValue && valuesToStrings[defaultValue], noSuchValueError, required);
-        this.valuesToStrings = valuesToStrings;
+        Object.defineProperty(this, "valuesToStrings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: valuesToStrings
+        });
     }
     doConvert(from) {
         return this.valuesToStrings[from];

package/.out/mantine/create_checkbox.js

@@ -3,17 +3,21 @@ import { createUnsafePartialObserverComponent } from 'util/partial';
 import { DefaultErrorRenderer, } from './error_renderer';
 export function createCheckbox(valuePath, Checkbox) {
     const onChange = (e) => {
-        this.onFieldValueChange?.(valuePath, e.target.checked);
+        var _a;
+        (_a = this.onFieldValueChange) === null || _a === void 0 ? void 0 : _a.call(this, valuePath, e.target.checked);
     };
     const onFocus = () => {
-        this.onFieldFocus?.(valuePath);
+        var _a;
+        (_a = this.onFieldFocus) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onBlur = () => {
-        this.onFieldBlur?.(valuePath);
+        var _a;
+        (_a = this.onFieldBlur) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onKeyUp = (e) => {
+        var _a;
         if (e.key === 'Enter') {
-            if (this.onFieldSubmit?.(valuePath)) {
+            if ((_a = this.onFieldSubmit) === null || _a === void 0 ? void 0 : _a.call(this, valuePath)) {
                 e.preventDefault();
             }
         }

package/.out/mantine/create_fields_view.d.ts

@@ -1,7 +1,15 @@
+import { type StringConcatOf } from '@strictly/base';
 import type { FieldsViewProps } from 'core/props';
 import type { ComponentType } from 'react';
 import type { AllFieldsOfFields } from 'types/all_fields_of_fields';
 import type { Fields } from 'types/field';
 import type { SubFormFields } from 'types/sub_form_fields';
 import type { MantineFieldComponent } from './types';
-export declare function createFieldsView<F extends Fields, K extends keyof AllFieldsOfFields<F>, P extends FieldsViewProps<Fields> = FieldsViewProps<SubFormFields<F, K>>>(valuePath: K, FieldsView: ComponentType<P>, observableProps: FieldsViewProps<F>): MantineFieldComponent<FieldsViewProps<P['fields']>, P, never>;
+export type CallbackMapper<ValuePath extends string> = {
+    <Cb extends (...args: any[]) => any>(cb: Cb): Parameters<Cb> extends [infer SubFormValuePath extends string, ...(infer Rest)] ? SubFormValuePath extends StringConcatOf<ValuePath, infer Postfix> ? (valuePath: `$${Postfix}`, ...rest: Rest) => ReturnType<Cb> : never : never;
+};
+export type FieldsView<ValuePath extends string = string, C extends ComponentType<any> = ComponentType<any>> = {
+    Component: C;
+    callbackMapper: CallbackMapper<ValuePath>;
+};
+export declare function createFieldsView<F extends Fields, K extends keyof AllFieldsOfFields<F>, P extends FieldsViewProps<Fields> = FieldsViewProps<SubFormFields<F, K>>>(valuePath: K, FieldsView: ComponentType<P>, observableProps: FieldsViewProps<F>): FieldsView<K, MantineFieldComponent<FieldsViewProps<P['fields']>, P, never>>;

package/.out/mantine/create_fields_view.js

@@ -14,16 +14,19 @@ export function createFieldsView(valuePath, FieldsView, observableProps) {
         observableProps.onFieldValueChange(toKey(subKey), value);
     }
     function onFieldBlur(subKey) {
-        observableProps.onFieldBlur?.(toKey(subKey));
+        var _a;
+        (_a = observableProps.onFieldBlur) === null || _a === void 0 ? void 0 : _a.call(observableProps, toKey(subKey));
     }
     function onFieldFocus(subKey) {
-        observableProps.onFieldFocus?.(toKey(subKey));
+        var _a;
+        (_a = observableProps.onFieldFocus) === null || _a === void 0 ? void 0 : _a.call(observableProps, toKey(subKey));
     }
     function onFieldSubmit(subKey) {
-        observableProps.onFieldSubmit?.(toKey(subKey));
+        var _a;
+        (_a = observableProps.onFieldSubmit) === null || _a === void 0 ? void 0 : _a.call(observableProps, toKey(subKey));
     }
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return observer(function (props) {
+    const Component = observer(function (props) {
         // convert fields to sub-fields
         const subFields = Object.entries(observableProps.fields).reduce((acc, [fieldKey, fieldValue,]) => {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -34,6 +37,18 @@ export function createFieldsView(valuePath, FieldsView, observableProps) {
         }, 
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         {});
-        return (_jsx(FieldsView, { ...props, fields: subFields, onFieldBlur: onFieldBlur, onFieldFocus: onFieldFocus, onFieldSubmit: onFieldSubmit, onFieldValueChange: onFieldValueChange }));
+        return (_jsx(FieldsView, Object.assign({}, props, { fields: subFields, onFieldBlur: onFieldBlur, onFieldFocus: onFieldFocus, onFieldSubmit: onFieldSubmit, onFieldValueChange: onFieldValueChange })));
     });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/consistent-type-assertions
+    const callbackMapper = ((callback) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (subFormValuePath, ...args) => {
+            const valuePath = toKey(subFormValuePath);
+            return callback(valuePath, ...args);
+        };
+    });
+    return {
+        Component,
+        callbackMapper,
+    };
 }

package/.out/mantine/create_form.js

@@ -8,6 +8,6 @@ export function createForm(valuePath, Form, observableProps) {
         const onValueChange = useCallback((value) => {
             observableProps.onFieldValueChange(valuePath, value);
         }, []);
-        return (_jsx(Form, { ...props, onValueChange: onValueChange, value: value }));
+        return (_jsx(Form, Object.assign({}, props, { onValueChange: onValueChange, value: value })));
     });
 }

package/.out/mantine/create_radio_group.js

@@ -3,17 +3,21 @@ import { createUnsafePartialObserverComponent, } from 'util/partial';
 import { DefaultErrorRenderer, } from './error_renderer';
 export function createRadioGroup(valuePath, RadioGroup) {
     const onChange = (value) => {
-        this.onFieldValueChange?.(valuePath, value);
+        var _a;
+        (_a = this.onFieldValueChange) === null || _a === void 0 ? void 0 : _a.call(this, valuePath, value);
     };
     const onFocus = () => {
-        this.onFieldFocus?.(valuePath);
+        var _a;
+        (_a = this.onFieldFocus) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onBlur = () => {
-        this.onFieldBlur?.(valuePath);
+        var _a;
+        (_a = this.onFieldBlur) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onKeyUp = (e) => {
+        var _a;
         if (e.key === 'Enter') {
-            if (this.onFieldSubmit?.(valuePath)) {
+            if ((_a = this.onFieldSubmit) === null || _a === void 0 ? void 0 : _a.call(this, valuePath)) {
                 e.preventDefault();
             }
         }

package/.out/mantine/create_text_input.js

@@ -3,17 +3,21 @@ import { createUnsafePartialObserverComponent } from 'util/partial';
 import { DefaultErrorRenderer, } from './error_renderer';
 export function createTextInput(valuePath, TextInput) {
     const onChange = (e) => {
-        this.onFieldValueChange?.(valuePath, e.target.value);
+        var _a;
+        (_a = this.onFieldValueChange) === null || _a === void 0 ? void 0 : _a.call(this, valuePath, e.target.value);
     };
     const onFocus = () => {
-        this.onFieldFocus?.(valuePath);
+        var _a;
+        (_a = this.onFieldFocus) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onBlur = () => {
-        this.onFieldBlur?.(valuePath);
+        var _a;
+        (_a = this.onFieldBlur) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onKeyUp = (e) => {
+        var _a;
         if (e.key === 'Enter') {
-            if (this.onFieldSubmit?.(valuePath)) {
+            if ((_a = this.onFieldSubmit) === null || _a === void 0 ? void 0 : _a.call(this, valuePath)) {
                 e.preventDefault();
             }
         }

package/.out/mantine/create_value_input.js

@@ -3,17 +3,21 @@ import { createUnsafePartialObserverComponent } from 'util/partial';
 import { DefaultErrorRenderer, } from './error_renderer';
 export function createValueInput(valuePath, ValueInput) {
     const onChange = (value) => {
-        this.onFieldValueChange?.(valuePath, value);
+        var _a;
+        (_a = this.onFieldValueChange) === null || _a === void 0 ? void 0 : _a.call(this, valuePath, value);
     };
     const onFocus = () => {
-        this.onFieldFocus?.(valuePath);
+        var _a;
+        (_a = this.onFieldFocus) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onBlur = () => {
-        this.onFieldBlur?.(valuePath);
+        var _a;
+        (_a = this.onFieldBlur) === null || _a === void 0 ? void 0 : _a.call(this, valuePath);
     };
     const onKeyUp = (e) => {
+        var _a;
         if (e.key === 'Enter') {
-            if (this.onFieldSubmit?.(valuePath)) {
+            if ((_a = this.onFieldSubmit) === null || _a === void 0 ? void 0 : _a.call(this, valuePath)) {
                 e.preventDefault();
             }
         }

package/.out/mantine/hooks.d.ts

@@ -11,6 +11,7 @@ import { type StringFieldsOfFields } from 'types/string_fields_of_fields';
 import { type SubFormFields } from 'types/sub_form_fields';
 import { type ValueTypeOfField } from 'types/value_type_of_field';
 import { type SuppliedCheckboxProps } from './create_checkbox';
+import { type FieldsView } from './create_fields_view';
 import { DefaultList, type SuppliedListProps } from './create_list';
 import { type SuppliedPillProps } from './create_pill';
 import { type SuppliedRadioProps } from './create_radio';
@@ -51,7 +52,7 @@ declare class MantineFormImpl<F extends Fields> implements MantineForm<F> {
     pill<K extends keyof AllFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedPillProps, PillProps, ErrorOfField<F[K]>>;
     pill<K extends keyof AllFieldsOfFields<F>, P extends SuppliedPillProps>(valuePath: K, Pill: ComponentType<P>): MantineFieldComponent<SuppliedPillProps, P, ErrorOfField<F[K]>>;
     list<K extends keyof ListFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedListProps<`${K}.${number}`>, ComponentProps<typeof DefaultList<ElementOfArray<F[K]['value']>, K>>, never>;
-    fieldsView<K extends keyof AllFieldsOfFields<F>, P extends FieldsViewProps<Fields> = FieldsViewProps<SubFormFields<F, K>>>(valuePath: K, FieldsView: ComponentType<P>): MantineFieldComponent<FieldsViewProps<P['fields']>, P, never>;
+    fieldsView<K extends keyof AllFieldsOfFields<F>, P extends FieldsViewProps<Fields> = FieldsViewProps<SubFormFields<F, K>>>(valuePath: K, FieldsView: ComponentType<P>): FieldsView<K, MantineFieldComponent<FieldsViewProps<P['fields']>, P, never>>;
     form<K extends keyof AllFieldsOfFields<F>, P extends FormProps<ValueTypeOfField<F[K]>> = FormProps<ValueTypeOfField<F[K]>>>(valuePath: K, Form: ComponentType<P>): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never>;
 }
 export {};