@strictly/react-form 0.0.4 → 0.0.5

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

@@ -17,5 +17,5 @@ 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 listAdapter<E, K extends string, ValuePath extends string, Context>(): FieldAdapterBuilder<readonly E[], readonly K[], 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,6 +1,5 @@
 import { chainAnnotatedFieldConverter, chainUnreliableFieldConverter, } from 'field_converters/chain_field_converter';
 import { annotatedIdentityConverter, unreliableIdentityConverter, } from 'field_converters/identity_converter';
-import { listConverter } from 'field_converters/list_converter';
 import { MaybeIdentityConverter } from 'field_converters/maybe_identity_converter';
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
 class FieldAdapterBuilder {
@@ -48,5 +47,5 @@ export function identityAdapter(prototype, required) {
     return new FieldAdapterBuilder(annotatedIdentityConverter(required), prototypingFieldValueFactory(prototype), unreliableIdentityConverter());
 }
 export function listAdapter() {
-    return new FieldAdapterBuilder(listConverter(), prototypingFieldValueFactory([]));
+    return new FieldAdapterBuilder(annotatedIdentityConverter(false), prototypingFieldValueFactory([]), unreliableIdentityConverter());
 }

package/.out/mantine/create_list.d.ts

@@ -4,12 +4,13 @@ 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 MantineFieldComponent, type MantineForm } from './types';
-export type SuppliedListProps<Value = any> = {
+export type SuppliedListProps<Value = any, ListPath extends string = string> = {
     values: readonly Value[];
+    listPath: ListPath;
 };
 export declare function createList<F extends Fields, K extends keyof ListFieldsOfFields<F>, Props extends SuppliedListProps<ElementOfArray<ValueTypeOfField<F[K]>>> & {
-    children: (value: ElementOfArray<ValueTypeOfField<F[K]>>, index: number) => React.ReactNode;
+    children: (valuePath: `${K}.${number}`, value: ElementOfArray<ValueTypeOfField<F[K]>>, index: number) => React.ReactNode;
 }>(this: MantineForm<F>, valuePath: K, List: ComponentType<Props>): MantineFieldComponent<SuppliedListProps<ElementOfArray<ValueTypeOfField<F[K]>>>, Props>;
-export declare function DefaultList<Value>({ values, children, }: SuppliedListProps<Value> & {
-    children: (value: Value, index: number) => React.ReactNode;
+export declare function DefaultList<Value, ListPath extends string>({ values, listPath, children, }: SuppliedListProps<Value, ListPath> & {
+    children: (valuePath: `${ListPath}.${number}`, value: Value, index: number) => React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/.out/mantine/create_list.js

@@ -5,12 +5,14 @@ export function createList(valuePath, List) {
         const values = [...this.fields[valuePath].value];
         return {
             values,
+            listPath: valuePath,
         };
     };
     return createUnsafePartialObserverComponent(List, propSource);
 }
-export function DefaultList({ values, children, }) {
+export function DefaultList({ values, listPath, children, }) {
     return (_jsx(_Fragment, { children: values.map(function (value, index) {
-            return children(value, index);
+            const valuePath = `${listPath}.${index}`;
+            return children(valuePath, value, index);
         }) }));
 }

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

@@ -1,4 +1,5 @@
 import { type CheckboxProps, type PillProps, type RadioGroupProps, type RadioProps, type SelectProps, type TextInputProps } from '@mantine/core';
+import { type ElementOfArray } from '@strictly/base';
 import { type FormProps } from 'core/props';
 import { type ComponentProps, type ComponentType } from 'react';
 import { type AllFieldsOfFields } from 'types/all_fields_of_fields';
@@ -48,7 +49,7 @@ declare class MantineFormImpl<F extends Fields> implements MantineForm<F> {
     radio<K extends keyof StringFieldsOfFields<F>, P extends SuppliedRadioProps>(valuePath: K, value: ValueTypeOfField<F[K]>, Radio: ComponentType<P>): MantineFieldComponent<SuppliedRadioProps, P, ErrorOfField<F[K]>>;
     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>;
-    list<K extends keyof ListFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedListProps<`${K}.${number}`>, ComponentProps<typeof DefaultList<`${K}.${number}`>>>;
+    list<K extends keyof ListFieldsOfFields<F>>(valuePath: K): MantineFieldComponent<SuppliedListProps<`${K}.${number}`>, ComponentProps<typeof DefaultList<ElementOfArray<F[K]['value']>, K>>>;
     subForm<K extends keyof AllFieldsOfFields<F>, S extends SubFormFields<F, K>>(valuePath: K, SubForm: ComponentType<FormProps<S>>): ComponentType;
 }
 export {};

package/.out/mantine/specs/list_hooks.stories.js

@@ -5,8 +5,8 @@ import { useMantineForm } from 'mantine/hooks';
 function Component(props) {
     const form = useMantineForm(props);
     const List = form.list('$');
-    return (_jsx(Paper, { p: 'sm', withBorder: true, children: _jsx(Stack, { children: _jsx(List, { children: function (valuePath) {
-                    return (_jsxs(Code, { children: ["ValuePath: ", valuePath] }, valuePath));
+    return (_jsx(Paper, { p: 'sm', withBorder: true, children: _jsx(Stack, { children: _jsx(List, { children: function (valuePath, value, index) {
+                    return (_jsxs(Code, { children: [_jsxs("span", { children: ["ValuePath: ", valuePath] }), _jsx("br", {}), _jsxs("span", { children: ["Value: ", value] }), _jsx("br", {}), _jsxs("span", { children: ["Index: ", index] })] }, valuePath));
                 } }) }) }));
 }
 const meta = {
@@ -37,10 +37,10 @@ export const Populated = {
                 readonly: false,
                 required: false,
                 value: [
-                    '$.4',
-                    '$.6',
-                    '$.19',
-                    '$.0',
+                    'A',
+                    'B',
+                    'C',
+                    'D',
                 ],
             },
         },