@strictly/react-form 0.0.30 → 0.0.31

package/.out/core/mobx/{field_adapter.d.ts → FieldAdapter.d.ts}

@@ -1,4 +1,4 @@
-import { type AnnotatedFieldConverter, type FieldValueFactory, type UnreliableFieldConverter } from 'types/field_converters';
+import { type AnnotatedFieldConverter, type FieldValueFactory, type UnreliableFieldConverter } from 'types/FieldConverters';
 export type FieldAdapter<From = any, To = any, E = any, ValuePath extends string = any, Context = any> = {
     readonly convert: AnnotatedFieldConverter<From, To, ValuePath, Context>;
     readonly create: FieldValueFactory<From, ValuePath, Context>;

package/.out/core/mobx/{field_adapters_of_values.d.ts → FieldAdaptersOfValues.d.ts}

@@ -1,4 +1,4 @@
-import { type FieldAdapter } from './field_adapter';
+import { type FieldAdapter } from './FieldAdapter';
 export type FieldAdaptersOfValues<FlattenedValues extends Readonly<Record<string, any>>, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedValues, string>> = Readonly<Record<keyof FlattenedValues, any>>, Context = any> = {
     readonly [K in keyof FlattenedValues]: FieldAdapter<FlattenedValues[K], any, any, TypePathsToValuePaths[K], Context>;
 };

package/.out/core/mobx/{flattened_adapters_of_fields.d.ts → FlattenedAdaptersOfFields.d.ts}

@@ -1,7 +1,7 @@
 import { type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
-import { type FieldAdapter } from 'core/mobx/field_adapter';
+import { type FieldAdapter } from 'core/mobx/FieldAdapter';
 import { type SimplifyDeep, type ValueOf } from 'type-fest';
-import { type Field } from 'types/field';
+import { type Field } from 'types/Field';
 export type FlattenedAdaptersOfFields<ValuePathsToTypePaths extends Readonly<Record<string, string>>, FlattenedTypeDefs extends Partial<Readonly<Record<ValueOf<ValuePathsToTypePaths>, Type>>>, FormFields extends Partial<Readonly<Record<keyof ValuePathsToTypePaths, Field>>>> = SimplifyDeep<{
     readonly [K in keyof ValuePathsToTypePaths as FormFields[K] extends Field ? ValuePathsToTypePaths[K] : never]: AdapterOfField<NonNullable<FormFields[K]>, FlattenedTypeDefs[ValuePathsToTypePaths[K]], K>;
 }>;

package/.out/core/mobx/{form_fields_of_field_adapters.d.ts → FormFieldsOfFieldAdapters.d.ts}

@@ -1,6 +1,6 @@
 import { type ValueOf } from 'type-fest';
-import { type Field } from 'types/field';
-import { type FieldAdapter } from './field_adapter';
+import { type Field } from 'types/Field';
+import { type FieldAdapter } from './FieldAdapter';
 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]]>;
 };

package/.out/core/mobx/{form_model.d.ts → FormModel.d.ts}

@@ -1,9 +1,9 @@
 import { type ElementOfArray, type Maybe } from '@strictly/base';
 import { type Accessor, type FlattenedValuesOfType, type MobxValueOfType, type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
 import { type ReadonlyDeep, type SimplifyDeep, type StringKeyOf, type UnionToIntersection, type ValueOf } from 'type-fest';
-import { type Field } from 'types/field';
-import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type ToOfFieldAdapter } from './field_adapter';
-import { type FlattenedListTypesOfType } from './flattened_list_types_of_type';
+import { type Field } from 'types/Field';
+import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type ToOfFieldAdapter } from './FieldAdapter';
+import { type FlattenedListTypesOfType } from './FlattenedListTypesOfType';
 export type FlattenedConvertedFieldsOf<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
     readonly [K in keyof ValuePathsToAdapters]: Field<ToOfFieldAdapter<ValuePathsToAdapters[K]>, ErrorOfFieldAdapter<ValuePathsToAdapters[K]>>;
 };

package/.out/core/mobx/{form_model.js → FormModel.js}

@@ -46,7 +46,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 import { assertExists, assertExistsAndReturn, checkValidNumber, map, toArray, UnreachableError, } from '@strictly/base';
 import { equals, flattenAccessorsOfType, flattenTypesOfType, flattenValuesOfType, flattenValueTo, jsonPathPop, mobxCopy, valuePathToTypePath, } from '@strictly/define';
 import { computed, observable, runInAction, } from 'mobx';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export var Validation;
 (function (Validation) {
     Validation[Validation["None"] = 0] = "None";

package/.out/core/mobx/{field_adapter_builder.d.ts → fieldAdapterBuilder.d.ts}

@@ -1,5 +1,5 @@
-import { type AnnotatedFieldConverter, type FieldValueFactory, type TwoWayFieldConverter, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConverter } from 'types/field_converters';
-import { type FieldAdapter } from './field_adapter';
+import { type AnnotatedFieldConverter, type FieldValueFactory, type TwoWayFieldConverter, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConverter } from 'types/FieldConverters';
+import { type FieldAdapter } from './FieldAdapter';
 declare class FieldAdapterBuilder<From, To, E, ValuePath extends string, Context> {
     readonly convert: AnnotatedFieldConverter<From, To, ValuePath, Context>;
     readonly create: FieldValueFactory<From, ValuePath, Context>;

package/.out/core/mobx/{field_adapter_builder.js → fieldAdapterBuilder.js}

@@ -1,9 +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';
+import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chainFieldConverter';
+import { annotatedIdentityConverter, unreliableIdentityConverter, } from 'field_converters/identityConverter';
+import { MaybeIdentityConverter } from 'field_converters/MaybeIdentityConverter';
+import { TrimmingStringConverter } from 'field_converters/TrimmingStringConverter';
+import { prototypingFieldValueFactory } from 'field_value_factories/prototypingFieldValueFactory';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 class FieldAdapterBuilder {
     constructor(convert, create, revert) {
         Object.defineProperty(this, "convert", {

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

@@ -1,5 +1,5 @@
 import { type ReadonlyTypeOfType, type ValueOfType } from '@strictly/define';
-import { type FormModel } from './form_model';
+import { type FormModel } from './FormModel';
 type ValueOfModel<M extends FormModel<any, any, any, any, any>> = M extends FormModel<infer T, any, any, any, any> ? ValueOfType<ReadonlyTypeOfType<T>> : never;
 export declare function useDefaultMobxFormHooks<M extends FormModel<any, any, any, any, any>, F extends M['fields'] = M['fields']>(model: M, { onValidFieldSubmit, onValidFormSubmit, }?: {
     onValidFieldSubmit?: <Path extends keyof F>(valuePath: Path) => void;

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

@@ -1,5 +1,5 @@
 import { useCallback, } from 'react';
-import { Validation, } from './form_model';
+import { Validation, } from './FormModel';
 export function useDefaultMobxFormHooks(model, { onValidFieldSubmit, onValidFormSubmit, } = {}) {
     const onFieldValueChange = useCallback(function (path, value) {
         const validation = Math.min(model.getValidation(path), Validation.Changed);

package/.out/core/mobx/{merge_field_adapters_with_two_way_converter.d.ts → mergeFieldAdaptersWithTwoWayConverter.d.ts}

@@ -1,5 +1,5 @@
-import { type TwoWayFieldConverter } from 'types/field_converters';
-import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './field_adapter';
+import { type TwoWayFieldConverter } from 'types/FieldConverters';
+import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './FieldAdapter';
 export type MergedOfFieldAdaptersWithTwoWayConverter<FieldAdapters extends Readonly<Record<string, FieldAdapter>>, E, Context> = {
     [K in keyof FieldAdapters]: FieldAdapter<FromOfFieldAdapter<FieldAdapters[K]>, ToOfFieldAdapter<FieldAdapters[K]>, ErrorOfFieldAdapter<FieldAdapters[K]> | E, ValuePathOfFieldAdapter<FieldAdapters[K]>, ContextOfFieldAdapter<FieldAdapters[K]> & Context>;
 };

package/.out/core/mobx/{merge_field_adapters_with_two_way_converter.js → mergeFieldAdaptersWithTwoWayConverter.js}

@@ -1,5 +1,5 @@
 import { map } from '@strictly/base';
-import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chain_field_converter';
+import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chainFieldConverter';
 export function mergeFieldAdaptersWithTwoWayConverter(fieldAdapters, converter) {
     return map(fieldAdapters, function (_key, adapter) {
         return {

package/.out/core/mobx/{merge_field_adapters_with_validators.d.ts → mergeFieldAdaptersWithValidators.d.ts}

@@ -1,6 +1,6 @@
 import { type Validator } from '@strictly/define';
 import { type Simplify } from 'type-fest';
-import { type FieldAdapter } from './field_adapter';
+import { type FieldAdapter } from './FieldAdapter';
 export type MergedOfFieldAdaptersWithValidators<FieldAdapters extends Readonly<Record<Key, FieldAdapter>>, Validators extends Partial<Readonly<Record<string, Validator>>>, Key extends keyof Validators = keyof Validators> = Simplify<{
     readonly [K in Key]: MergedOfFieldAdapterWithValidator<FieldAdapters[K], Validators[K]>;
 } & {

package/.out/core/mobx/{merge_field_adapters_with_validators.js → mergeFieldAdaptersWithValidators.js}

@@ -1,6 +1,6 @@
 import { reduce } from '@strictly/base';
 import { annotations, validate, } from '@strictly/define';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export function mergeAdaptersWithValidators(adapters, validators) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return reduce(adapters, function (acc, key, adapter) {

package/.out/core/mobx/specs/{form_model.tests.js → FormModel.tests.js}

@@ -1,13 +1,13 @@
 import { expectDefinedAndReturn } from '@strictly/base';
 import { booleanType, flattenValidatorsOfValidatingType, list, nullType, numberType, object, record, stringType, union, } from '@strictly/define';
-import { adapterFromTwoWayConverter, identityAdapter, } from 'core/mobx/field_adapter_builder';
-import { FormModel, Validation, } from 'core/mobx/form_model';
-import { mergeAdaptersWithValidators } from 'core/mobx/merge_field_adapters_with_validators';
-import { IntegerToStringConverter } from 'field_converters/integer_to_string_converter';
-import { NullableToBooleanConverter } from 'field_converters/nullable_to_boolean_converter';
-import { SelectDiscriminatedUnionConverter } from 'field_converters/select_value_type_converter';
-import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { adapterFromTwoWayConverter, identityAdapter, } from 'core/mobx/fieldAdapterBuilder';
+import { FormModel, Validation, } from 'core/mobx/FormModel';
+import { mergeAdaptersWithValidators } from 'core/mobx/mergeFieldAdaptersWithValidators';
+import { IntegerToStringConverter } from 'field_converters/IntegerToStringConverter';
+import { NullableToBooleanConverter } from 'field_converters/NullableToBooleanConverter';
+import { SelectDiscriminatedUnionConverter } from 'field_converters/SelectValueTypeConverter';
+import { prototypingFieldValueFactory } from 'field_value_factories/prototypingFieldValueFactory';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 import { createMockedAdapter, resetMockAdapter, } from './fixtures';
 const IS_NAN_ERROR = 1;
 const originalIntegerToStringAdapter = adapterFromTwoWayConverter(new IntegerToStringConverter(IS_NAN_ERROR), prototypingFieldValueFactory(0));

package/.out/core/mobx/specs/{merge_field_adapters_with_two_way_converter.tests.js → MergeFieldAdaptersWithTwoWayConverter.tests.js}

@@ -1,7 +1,7 @@
-import { identityAdapter } from 'core/mobx/field_adapter_builder';
-import { mergeFieldAdaptersWithTwoWayConverter, } from 'core/mobx/merge_field_adapters_with_two_way_converter';
-import { annotatedIdentityConverter, unreliableIdentityConverter, } from 'field_converters/identity_converter';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { identityAdapter } from 'core/mobx/fieldAdapterBuilder';
+import { mergeFieldAdaptersWithTwoWayConverter, } from 'core/mobx/mergeFieldAdaptersWithTwoWayConverter';
+import { annotatedIdentityConverter, unreliableIdentityConverter, } from 'field_converters/identityConverter';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 import { createMockedAdapter, createMockTwoWayFieldConverter, resetMockAdapter, resetMockTwoWayFieldConverter, } from './fixtures';
 const error1 = Symbol();
 const error2 = Symbol();

package/.out/core/mobx/specs/{merge_field_adapters_with_validators.tests.js → MergeFieldAdaptersWithValidators.tests.js}

@@ -1,7 +1,7 @@
 import { expectDefined, expectEquals, } from '@strictly/base';
-import { identityAdapter, } from 'core/mobx/field_adapter_builder';
-import { mergeAdaptersWithValidators, } from 'core/mobx/merge_field_adapters_with_validators';
-import { UnreliableFieldConversionType } from 'types/field_converters';
+import { identityAdapter, } from 'core/mobx/fieldAdapterBuilder';
+import { mergeAdaptersWithValidators, } from 'core/mobx/mergeFieldAdaptersWithValidators';
+import { UnreliableFieldConversionType } from 'types/FieldConverters';
 import { createMockedAdapter, resetMockAdapter, } from './fixtures';
 const error1 = 'error 1';
 const error2 = 'error 2';

package/.out/core/mobx/specs/fixtures.d.ts

@@ -1,5 +1,5 @@
-import { type FieldAdapter } from 'core/mobx/field_adapter';
-import { type TwoWayFieldConverter } from 'types/field_converters';
+import { type FieldAdapter } from 'core/mobx/FieldAdapter';
+import { type TwoWayFieldConverter } from 'types/FieldConverters';
 import { type Mocked } from 'vitest';
 export declare function createMockedAdapter<E, To, From, ValuePath extends string>(_original: FieldAdapter<From, To, E, ValuePath>): Mocked<Required<FieldAdapter<From, To, E, ValuePath>>>;
 export declare function resetMockAdapter<E, To, From, ValuePath extends string>({ convert, revert, create, }: FieldAdapter<From, To, E, ValuePath>, mockedAdapter: Mocked<Required<FieldAdapter<From, To, E, ValuePath>>>): void;

package/.out/core/mobx/specs/{sub_form_field_adapters.tests.js → subFormFieldAdapters.tests.js}

@@ -1,5 +1,5 @@
-import { subFormFieldAdapters, } from 'core/mobx/sub_form_field_adapters';
-import { UnreliableFieldConversionType } from 'types/field_converters';
+import { subFormFieldAdapters, } from 'core/mobx/subFormFieldAdapters';
+import { UnreliableFieldConversionType } from 'types/FieldConverters';
 import { mockDeep, mockReset, } from 'vitest-mock-extended';
 describe('subFormFieldAdapters', () => {
     describe('empty value', () => {

package/.out/core/mobx/{sub_form_field_adapters.d.ts → subFormFieldAdapters.d.ts}

@@ -1,5 +1,5 @@
 import { type StringConcatOf } from '@strictly/base';
-import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './field_adapter';
+import { type ContextOfFieldAdapter, type ErrorOfFieldAdapter, type FieldAdapter, type FromOfFieldAdapter, type ToOfFieldAdapter, type ValuePathOfFieldAdapter } from './FieldAdapter';
 type SubFormFieldAdapter<F extends FieldAdapter, ValuePath extends string> = FieldAdapter<FromOfFieldAdapter<F>, ToOfFieldAdapter<F>, ErrorOfFieldAdapter<F>, ValuePathOfFieldAdapter<F> extends StringConcatOf<'$', infer ValuePathSuffix> ? `${ValuePath}${ValuePathSuffix}` : string, ContextOfFieldAdapter<F>>;
 type SubFormFieldAdapters<SubAdapters extends Record<string, FieldAdapter>, TypePath extends string, ValuePath extends string> = {
     [K in keyof SubAdapters as K extends StringConcatOf<'$', infer TypePathSuffix> ? `${TypePath}${TypePathSuffix}` : never]: SubFormFieldAdapter<SubAdapters[K], ValuePath>;

package/.out/core/props.d.ts

@@ -1,4 +1,4 @@
-import { type Fields } from 'types/field';
+import { type Fields } from 'types/Field';
 export type FieldsViewProps<F extends Fields> = {
     fields: F;
     onFieldValueChange<K extends keyof F>(this: void, key: K, value: F[K]['value']): void;

package/.out/field_converters/{integer_to_string_converter.d.ts → IntegerToStringConverter.d.ts}

@@ -1,4 +1,4 @@
-import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/field_converters';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/FieldConverters';
 export declare class IntegerToStringConverter<E, ValuePath extends string, Context> implements TwoWayFieldConverter<number, string, E, ValuePath, Context> {
     private readonly isNanError;
     private readonly base;

package/.out/field_converters/{integer_to_string_converter.js → IntegerToStringConverter.js}

@@ -1,4 +1,4 @@
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export class IntegerToStringConverter {
     constructor(isNanError, base = 10) {
         Object.defineProperty(this, "isNanError", {

package/.out/field_converters/{maybe_identity_converter.d.ts → MaybeIdentityConverter.d.ts}

@@ -1,4 +1,4 @@
-import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/field_converters';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/FieldConverters';
 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;

package/.out/field_converters/{nullable_to_boolean_converter.d.ts → NullableToBooleanConverter.d.ts}

@@ -1,5 +1,5 @@
 import { type ReadonlyTypeOfType, type Type, type ValueOfType } from '@strictly/define';
-import { type AnnotatedFieldConversion, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConversion } from 'types/field_converters';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConversion } from 'types/FieldConverters';
 export declare class NullableToBooleanConverter<T extends Type, ValuePath extends string, Context, NullType extends null | undefined> implements TwoWayFieldConverterWithValueFactory<ValueOfType<ReadonlyTypeOfType<T>> | NullType, boolean, never, ValuePath, Context> {
     private readonly typeDef;
     private readonly prototype;

package/.out/field_converters/{nullable_to_boolean_converter.js → NullableToBooleanConverter.js}

@@ -1,5 +1,5 @@
 import { copy, } from '@strictly/define';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export class NullableToBooleanConverter {
     constructor(typeDef, prototype, nullType, defaultToNull = true) {
         Object.defineProperty(this, "typeDef", {

package/.out/field_converters/{select_value_type_converter.d.ts → SelectValueTypeConverter.d.ts}

@@ -1,6 +1,6 @@
 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';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverterWithValueFactory, type UnreliableFieldConversion } from 'types/FieldConverters';
 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;

package/.out/field_converters/{select_value_type_converter.js → SelectValueTypeConverter.js}

@@ -1,6 +1,6 @@
 import { reverse, } from '@strictly/base';
 import { copy, } from '@strictly/define';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export class AbstractSelectValueTypeConverter {
     constructor(typeDef, values, defaultValueKey, noSuchValueError, required) {
         Object.defineProperty(this, "typeDef", {

package/.out/field_converters/{trimming_string_converter.d.ts → TrimmingStringConverter.d.ts}

@@ -1,4 +1,4 @@
-import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/field_converters';
+import { type AnnotatedFieldConversion, type TwoWayFieldConverter, type UnreliableFieldConversion } from 'types/FieldConverters';
 export declare class TrimmingStringConverter<ValuePath extends string, Context> implements TwoWayFieldConverter<string, string, never, ValuePath, Context> {
     constructor();
     convert(to: string): AnnotatedFieldConversion<string>;

package/.out/field_converters/{trimming_string_converter.js → TrimmingStringConverter.js}

@@ -1,4 +1,4 @@
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export class TrimmingStringConverter {
     constructor() {
     }

package/.out/field_converters/{chain_field_converter.d.ts → chainFieldConverter.d.ts}

@@ -1,3 +1,3 @@
-import { type AnnotatedFieldConverter, type UnreliableFieldConverter } from 'types/field_converters';
+import { type AnnotatedFieldConverter, type UnreliableFieldConverter } from 'types/FieldConverters';
 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 → chainFieldConverter.js}

@@ -1,5 +1,5 @@
 import { UnreachableError, } from '@strictly/base';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export function chainUnreliableFieldConverter(from, to) {
     return function (value, valuePath, context) {
         const fromConversion = from(value, valuePath, context);

package/.out/field_converters/{identity_converter.d.ts → identityConverter.d.ts}

@@ -1,3 +1,3 @@
-import { type AnnotatedFieldConverter, type UnreliableFieldConverter } from 'types/field_converters';
+import { type AnnotatedFieldConverter, type UnreliableFieldConverter } from 'types/FieldConverters';
 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 → identityConverter.js}

@@ -1,4 +1,4 @@
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 export function annotatedIdentityConverter(required = false) {
     return function (value) {
         return {

package/.out/field_converters/specs/{chain_field_converter.tests.js → chainFieldConverter.tests.js}

@@ -1,5 +1,5 @@
-import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chain_field_converter';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chainFieldConverter';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 const CONTEXT = 'ctx';
 const ERROR1 = 'error 1';
 const ERROR2 = 'error 2';

package/.out/field_converters/{validating_converter.d.ts → validatingConverter.d.ts}

@@ -1,3 +1,3 @@
 import { type Validator } from '@strictly/define';
-import { type UnreliableFieldConverter } from 'types/field_converters';
+import { type UnreliableFieldConverter } from 'types/FieldConverters';
 export declare function validatingConverter<V, E, ValuePath extends string, Context>(validators?: readonly Validator<V, E, ValuePath, Context>[]): UnreliableFieldConverter<V, V, E, ValuePath, Context>;

package/.out/field_converters/{validating_converter.js → validatingConverter.js}

@@ -1,5 +1,5 @@
 import { validate, } from '@strictly/define';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
+import { UnreliableFieldConversionType, } from 'types/FieldConverters';
 // delete this?
 export function validatingConverter(validators = []) {
     return function (value, valuePath, context) {

package/.out/field_value_factories/{prototyping_field_value_factory.d.ts → prototypingFieldValueFactory.d.ts}

@@ -1,2 +1,2 @@
-import { type FieldValueFactory } from 'types/field_converters';
+import { type FieldValueFactory } from 'types/FieldConverters';
 export declare function prototypingFieldValueFactory<V, ValuePath extends string, Context>(prototype: V): FieldValueFactory<V, ValuePath, Context>;

package/.out/index.d.ts

@@ -1,25 +1,25 @@
-export * from './core/mobx/field_adapter';
-export * from './core/mobx/field_adapter_builder';
-export * from './core/mobx/field_adapters_of_values';
-export * from './core/mobx/flattened_adapters_of_fields';
-export * from './core/mobx/form_fields_of_field_adapters';
-export * from './core/mobx/form_model';
+export * from './core/mobx/FieldAdapter';
+export * from './core/mobx/fieldAdapterBuilder';
+export * from './core/mobx/FieldAdaptersOfValues';
+export * from './core/mobx/FlattenedAdaptersOfFields';
+export * from './core/mobx/FormFieldsOfFieldAdapters';
+export * from './core/mobx/FormModel';
 export * from './core/mobx/hooks';
-export * from './core/mobx/merge_field_adapters_with_two_way_converter';
-export * from './core/mobx/merge_field_adapters_with_validators';
-export * from './core/mobx/sub_form_field_adapters';
+export * from './core/mobx/mergeFieldAdaptersWithTwoWayConverter';
+export * from './core/mobx/mergeFieldAdaptersWithValidators';
+export * from './core/mobx/subFormFieldAdapters';
 export * from './core/props';
-export * from './field_converters/integer_to_string_converter';
-export * from './field_converters/nullable_to_boolean_converter';
-export * from './field_converters/select_value_type_converter';
-export * from './field_converters/trimming_string_converter';
-export * from './field_converters/validating_converter';
-export * from './field_value_factories/prototyping_field_value_factory';
-export * from './mantine/error_renderer';
+export * from './field_converters/IntegerToStringConverter';
+export * from './field_converters/NullableToBooleanConverter';
+export * from './field_converters/SelectValueTypeConverter';
+export * from './field_converters/TrimmingStringConverter';
+export * from './field_converters/validatingConverter';
+export * from './field_value_factories/prototypingFieldValueFactory';
+export * from './mantine/ErrorRenderer';
 export * from './mantine/hooks';
-export * from './types/error_of_field';
-export * from './types/field';
-export * from './types/field_converters';
-export * from './types/merge_validators';
-export * from './util/empty';
-export * from './util/partial';
+export * from './types/ErrorOfField';
+export * from './types/Field';
+export * from './types/FieldConverters';
+export * from './types/mergeValidators';
+export * from './util/Empty';
+export * from './util/Partial';

package/.out/index.js

@@ -1,25 +1,25 @@
-export * from './core/mobx/field_adapter';
-export * from './core/mobx/field_adapter_builder';
-export * from './core/mobx/field_adapters_of_values';
-export * from './core/mobx/flattened_adapters_of_fields';
-export * from './core/mobx/form_fields_of_field_adapters';
-export * from './core/mobx/form_model';
+export * from './core/mobx/FieldAdapter';
+export * from './core/mobx/fieldAdapterBuilder';
+export * from './core/mobx/FieldAdaptersOfValues';
+export * from './core/mobx/FlattenedAdaptersOfFields';
+export * from './core/mobx/FormFieldsOfFieldAdapters';
+export * from './core/mobx/FormModel';
 export * from './core/mobx/hooks';
-export * from './core/mobx/merge_field_adapters_with_two_way_converter';
-export * from './core/mobx/merge_field_adapters_with_validators';
-export * from './core/mobx/sub_form_field_adapters';
+export * from './core/mobx/mergeFieldAdaptersWithTwoWayConverter';
+export * from './core/mobx/mergeFieldAdaptersWithValidators';
+export * from './core/mobx/subFormFieldAdapters';
 export * from './core/props';
-export * from './field_converters/integer_to_string_converter';
-export * from './field_converters/nullable_to_boolean_converter';
-export * from './field_converters/select_value_type_converter';
-export * from './field_converters/trimming_string_converter';
-export * from './field_converters/validating_converter';
-export * from './field_value_factories/prototyping_field_value_factory';
-export * from './mantine/error_renderer';
+export * from './field_converters/IntegerToStringConverter';
+export * from './field_converters/NullableToBooleanConverter';
+export * from './field_converters/SelectValueTypeConverter';
+export * from './field_converters/TrimmingStringConverter';
+export * from './field_converters/validatingConverter';
+export * from './field_value_factories/prototypingFieldValueFactory';
+export * from './mantine/ErrorRenderer';
 export * from './mantine/hooks';
-export * from './types/error_of_field';
-export * from './types/field';
-export * from './types/field_converters';
-export * from './types/merge_validators';
-export * from './util/empty';
-export * from './util/partial';
+export * from './types/ErrorOfField';
+export * from './types/Field';
+export * from './types/FieldConverters';
+export * from './types/mergeValidators';
+export * from './util/Empty';
+export * from './util/Partial';

package/.out/mantine/{error_renderer.d.ts → ErrorRenderer.d.ts}

@@ -1,6 +1,6 @@
 import { type ComponentType } from 'react';
-import { type ErrorOfField } from 'types/error_of_field';
-import { type Fields } from 'types/field';
+import { type ErrorOfField } from 'types/ErrorOfField';
+import { type Fields } from 'types/Field';
 type InternalErrorRendererProps<E> = {
     error: E;
 };

package/.out/mantine/{create_checkbox.d.ts → createCheckbox.d.ts}

@@ -1,8 +1,8 @@
 import { type CheckboxProps } from '@mantine/core';
 import { type ComponentType } from 'react';
-import { type BooleanFieldsOfFields } from 'types/boolean_fields_of_fields';
-import { type ErrorOfField } from 'types/error_of_field';
-import { type Fields } from 'types/field';
+import { type BooleanFieldsOfFields } from 'types/BooleanFieldsOfFields';
+import { type ErrorOfField } from 'types/ErrorOfField';
+import { type Fields } from 'types/Field';
 import { type MantineFieldComponent, type MantineForm } from './types';
 export type SuppliedCheckboxProps = Pick<CheckboxProps, 'name' | 'checked' | 'disabled' | 'required' | 'error' | 'onChange' | 'onFocus' | 'onBlur' | 'onKeyUp'>;
 export declare function createCheckbox<F extends Fields, K extends keyof BooleanFieldsOfFields<F>, Props extends SuppliedCheckboxProps>(this: MantineForm<F>, valuePath: K, Checkbox: ComponentType<Props>): MantineFieldComponent<SuppliedCheckboxProps, Props, ErrorOfField<F[K]>>;

package/.out/mantine/{create_checkbox.js → createCheckbox.js}

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createUnsafePartialObserverComponent } from 'util/partial';
-import { DefaultErrorRenderer, } from './error_renderer';
+import { createUnsafePartialObserverComponent } from 'util/Partial';
+import { DefaultErrorRenderer, } from './ErrorRenderer';
 export function createCheckbox(valuePath, Checkbox) {
     const onChange = (e) => {
         var _a;

package/.out/mantine/{create_field_view.d.ts → createFieldView.d.ts}

@@ -1,8 +1,8 @@
 import { type ComponentType } from 'react';
-import { type AllFieldsOfFields } from 'types/all_fields_of_fields';
-import { type ErrorOfField } from 'types/error_of_field';
-import { type Fields } from 'types/field';
-import { type ValueTypeOfField } from 'types/value_type_of_field';
+import { type AllFieldsOfFields } from 'types/AllFieldsOfFields';
+import { type ErrorOfField } from 'types/ErrorOfField';
+import { type Fields } from 'types/Field';
+import { type ValueTypeOfField } from 'types/ValueTypeOfField';
 import { type MantineForm } from './types';
 export type FieldViewProps<F extends Fields, K extends keyof F> = {
     children: (props: {

package/.out/mantine/{create_field_view.js → createFieldView.js}

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Observer } from 'mobx-react';
 import { useCallback, } from 'react';
-import { Empty } from 'util/empty';
+import { Empty } from 'util/Empty';
 /**
  * Displays current value and error of a field
  */

package/.out/mantine/{create_fields_view.d.ts → createFieldsView.d.ts}

@@ -1,9 +1,9 @@
 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 { AllFieldsOfFields } from 'types/AllFieldsOfFields';
+import type { Fields } from 'types/Field';
+import type { SubFormFields } from 'types/SubFormFields';
 import type { MantineFieldComponent } from './types';
 export type SubPathsOf<ValuePath extends string, SubFormValuePath extends string> = SubFormValuePath extends StringConcatOf<ValuePath, infer Postfix> ? `$${Postfix}` : never;
 export type CallbackMapper<ValuePath extends string> = {

package/.out/mantine/{create_form.d.ts → createForm.d.ts}

@@ -1,7 +1,7 @@
 import { type FieldsViewProps, type FormProps } 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 ValueTypeOfField } from 'types/value_type_of_field';
+import { type AllFieldsOfFields } from 'types/AllFieldsOfFields';
+import { type Fields } from 'types/Field';
+import { type ValueTypeOfField } from 'types/ValueTypeOfField';
 import { type MantineFieldComponent } from './types';
 export declare function createForm<F extends Fields, K extends keyof AllFieldsOfFields<F>, P extends FormProps<ValueTypeOfField<F[K]>> = FormProps<ValueTypeOfField<F[K]>>>(valuePath: K, Form: ComponentType<P>, observableProps: FieldsViewProps<F>): MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never>;

package/.out/mantine/{create_list.d.ts → createList.d.ts}

@@ -1,8 +1,8 @@
 import { type ElementOfArray } from '@strictly/base';
 import { type ComponentType } from 'react';
-import { type Fields } from 'types/field';
-import { type ListFieldsOfFields } from 'types/list_fields_of_fields';
-import { type ValueTypeOfField } from 'types/value_type_of_field';
+import { type Fields } from 'types/Field';
+import { type ListFieldsOfFields } from 'types/ListFieldsOfFields';
+import { type ValueTypeOfField } from 'types/ValueTypeOfField';
 import { type MantineFieldComponent, type MantineForm } from './types';
 export type SuppliedListProps<Value = any, ListPath extends string = string> = {
     values: readonly Value[];

package/.out/mantine/{create_list.js → createList.js}

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { assertExistsAndReturn, } from '@strictly/base';
 import { Fragment, } from 'react';
-import { createUnsafePartialObserverComponent } from 'util/partial';
+import { createUnsafePartialObserverComponent } from 'util/Partial';
 export function createList(valuePath, List) {
     const propSource = () => {
         const field = this.fields[valuePath];

package/.out/mantine/{create_pill.d.ts → createPill.d.ts}

@@ -1,7 +1,7 @@
 import { type PillProps } from '@mantine/core';
 import { type ComponentType } from 'react';
-import { type AllFieldsOfFields } from 'types/all_fields_of_fields';
-import { type Fields } from 'types/field';
+import { type AllFieldsOfFields } from 'types/AllFieldsOfFields';
+import { type Fields } from 'types/Field';
 import { type MantineFieldComponent, type MantineForm } from './types';
 export type SuppliedPillProps = Pick<PillProps, 'children' | 'disabled'>;
 export declare function createPill<F extends Fields, K extends keyof AllFieldsOfFields<F>, Props extends SuppliedPillProps>(this: MantineForm<F>, valuePath: K, Pill: ComponentType<Props>): MantineFieldComponent<SuppliedPillProps, Props, never>;