@strato-admin/core 0.1.1 → 0.3.0

package/dist/ra-core/src/form/FormDataConsumer.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFormContext } from 'react-hook-form';
+import get from 'lodash/get.js';
+import { useFormValues } from './useFormValues';
+import { useWrappedSource } from '../core';
+/**
+ * Get the current (edited) value of the record from the form and pass it
+ * to a child function
+ *
+ * @example
+ *
+ * const PostEdit = () => (
+ *     <Edit>
+ *         <SimpleForm<FieldValues>>
+ *             <BooleanInput source="hasEmail" />
+ *             <FormDataConsumer>
+ *                 {({ formData }) => formData.hasEmail &&
+ *                      <TextInput source="email" />
+ *                 }
+ *             </FormDataConsumer>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ *
+ * @example
+ *
+ * const OrderEdit = () => (
+ *     <Edit>
+ *         <SimpleForm>
+ *             <SelectInput source="country" choices={countries} />
+ *             <FormDataConsumer<FieldValues>>
+ *                 {({ formData }) =>
+ *                      <SelectInput
+ *                          source="city"
+ *                          choices={getCitiesFor(formData.country)}
+ *                      />
+ *                 }
+ *             </FormDataConsumer>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ */
+export const FormDataConsumer = (props) => {
+    const form = useFormContext();
+    const { formState: { 
+    // Don't know exactly why, but this is needed for the form values to be updated
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isDirty, }, } = form;
+    const formData = useFormValues();
+    return (_jsx(FormDataConsumerView, { formData: formData, ...props }));
+};
+export const FormDataConsumerView = (props) => {
+    const { children, formData, source } = props;
+    let result;
+    const finalSource = useWrappedSource(source || '');
+    // Passes an empty string here as we don't have the children sources and we just want to know if we are in an iterator
+    const matches = ArraySourceRegex.exec(finalSource);
+    // If we have an index, we are in an iterator like component (such as the SimpleFormIterator)
+    if (matches) {
+        const scopedFormData = get(formData, matches[0]);
+        result = children({ formData, scopedFormData });
+    }
+    else {
+        result = children({ formData });
+    }
+    return result === undefined ? null : result;
+};
+const ArraySourceRegex = new RegExp(/.+\.\d+$/);

package/dist/ra-core/src/form/WarnWhenUnsavedChanges.d.ts

@@ -0,0 +1,5 @@
+export declare const WarnWhenUnsavedChanges: ({ enable, formRootPathName, formControl, }: {
+    enable?: boolean | undefined;
+    formRootPathName: any;
+    formControl: any;
+}) => null;

package/dist/ra-core/src/form/WarnWhenUnsavedChanges.js

@@ -0,0 +1,5 @@
+import { useWarnWhenUnsavedChanges } from './useWarnWhenUnsavedChanges';
+export const WarnWhenUnsavedChanges = ({ enable = true, formRootPathName, formControl, }) => {
+    useWarnWhenUnsavedChanges(enable, formRootPathName, formControl);
+    return null;
+};

package/dist/ra-core/src/form/choices/ChoicesContext.d.ts

@@ -0,0 +1,65 @@
+import { UseGetListHookValue } from '../../dataProvider/useGetList';
+import { FilterPayload, RaRecord, SortPayload } from '../../types';
+/**
+ * Context to store choices and functions to retrieve them.
+ *
+ * Use the useChoicesContext() hook to read the context.
+ */
+export declare const ChoicesContext: import("react").Context<ChoicesContextValue<any> | undefined>;
+export type ChoicesContextBaseValue<RecordType extends RaRecord = any> = {
+    displayedFilters: any;
+    filter?: FilterPayload;
+    filterValues: any;
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+    hideFilter: (filterName: string) => void;
+    isFetching: boolean;
+    isLoading: boolean;
+    isPaused?: boolean;
+    isPlaceholderData?: boolean;
+    page: number;
+    perPage: number;
+    refetch: (() => void) | UseGetListHookValue<RecordType>['refetch'];
+    resource: string;
+    setFilters: (filters: any, displayedFilters?: any, debounce?: boolean) => void;
+    setPage: (page: number) => void;
+    setPerPage: (page: number) => void;
+    setSort: (sort: SortPayload) => void;
+    showFilter: (filterName: string, defaultValue: any) => void;
+    sort: SortPayload;
+    source: string;
+    isFromReference: boolean;
+};
+export interface ChoicesContextLoadingResult<RecordType extends RaRecord = any> extends ChoicesContextBaseValue<RecordType> {
+    allChoices: undefined;
+    availableChoices: undefined;
+    selectedChoices: undefined;
+    total: undefined;
+    error: null;
+    isPending: true;
+}
+export interface ChoicesContextErrorResult<RecordType extends RaRecord = any, TError = Error> extends ChoicesContextBaseValue<RecordType> {
+    allChoices: undefined;
+    availableChoices: undefined;
+    selectedChoices: undefined;
+    total: undefined;
+    error: TError;
+    isPending: false;
+}
+export interface ChoicesContextRefetchErrorResult<RecordType extends RaRecord = any, TError = Error> extends ChoicesContextBaseValue<RecordType> {
+    allChoices: RecordType[];
+    availableChoices: RecordType[];
+    selectedChoices: RecordType[];
+    total: number;
+    error: TError;
+    isPending: false;
+}
+export interface ChoicesContextSuccessResult<RecordType extends RaRecord = any> extends ChoicesContextBaseValue<RecordType> {
+    allChoices: RecordType[];
+    availableChoices: RecordType[];
+    selectedChoices: RecordType[];
+    total: number;
+    error: null;
+    isPending: false;
+}
+export type ChoicesContextValue<RecordType extends RaRecord = any> = ChoicesContextLoadingResult<RecordType> | ChoicesContextErrorResult<RecordType> | ChoicesContextRefetchErrorResult<RecordType> | ChoicesContextSuccessResult<RecordType>;

package/dist/ra-core/src/form/choices/ChoicesContext.js

@@ -0,0 +1,7 @@
+import { createContext } from 'react';
+/**
+ * Context to store choices and functions to retrieve them.
+ *
+ * Use the useChoicesContext() hook to read the context.
+ */
+export const ChoicesContext = createContext(undefined);

package/dist/ra-core/src/form/choices/ChoicesContextProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { ChoicesContextValue } from './ChoicesContext';
+export declare const ChoicesContextProvider: ({ children, value, }: {
+    children: ReactNode;
+    value: ChoicesContextValue;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ra-core/src/form/choices/ChoicesContextProvider.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ChoicesContext } from './ChoicesContext';
+export const ChoicesContextProvider = ({ children, value, }) => (_jsx(ChoicesContext.Provider, { value: value, children: children }));

package/dist/ra-core/src/form/choices/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ChoicesContext';
+export * from './ChoicesContextProvider';
+export * from './useChoicesContext';
+export * from './useChoices';

package/dist/ra-core/src/form/choices/index.js

@@ -0,0 +1,4 @@
+export * from './ChoicesContext';
+export * from './ChoicesContextProvider';
+export * from './useChoicesContext';
+export * from './useChoices';

package/dist/ra-core/src/form/choices/useChoices.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { ReactElement } from 'react';
+import { RaRecord } from '../../types';
+export type OptionTextElement = ReactElement<{
+    record: RaRecord;
+}>;
+export type OptionTextFunc = (choice: any) => React.ReactNode;
+export type OptionText = OptionTextElement | OptionTextFunc | string;
+export interface ChoicesProps {
+    choices?: any[];
+    isFetching?: boolean;
+    isLoading?: boolean;
+    isPending?: boolean;
+    optionValue?: string;
+    optionText?: OptionText;
+    translateChoice?: boolean;
+    disableValue?: string;
+}
+export interface UseChoicesOptions {
+    optionValue?: string;
+    optionText?: OptionText;
+    disableValue?: string;
+    translateChoice?: boolean;
+    createValue?: string;
+    createHintValue?: string;
+}
+export declare const useChoices: ({ optionText, optionValue, disableValue, translateChoice, createValue, createHintValue, }: UseChoicesOptions) => {
+    getChoiceText: (choice: any) => any;
+    getChoiceValue: (choice: any) => any;
+    getDisableValue: (choice: any) => any;
+};

package/dist/ra-core/src/form/choices/useChoices.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { isValidElement, useCallback } from 'react';
+import get from 'lodash/get.js';
+import { useTranslate } from '../../i18n';
+import { RecordContextProvider } from '../../controller';
+/*
+ * Returns helper functions for choices handling.
+ *
+ * @param optionText Either a string defining the property to use to get the choice text, a function or a React element
+ * @param optionValue The property to use to get the choice value
+ * @param translateChoice A boolean indicating whether to option text should be translated
+ *
+ * @returns An object with helper functions:
+ * - getChoiceText: Returns the choice text or a React element
+ * - getChoiceValue: Returns the choice value
+ */
+export const useChoices = ({ optionText = 'name', optionValue = 'id', disableValue = 'disabled', translateChoice = true, createValue = '@@ra-create', createHintValue = '@@ra-create-hint', }) => {
+    const translate = useTranslate();
+    const getChoiceText = useCallback(choice => {
+        if (choice?.id === createValue || choice?.id === createHintValue) {
+            return get(choice, typeof optionText === 'string' ? optionText : 'name');
+        }
+        if (isValidElement(optionText)) {
+            return (_jsx(RecordContextProvider, { value: choice, children: optionText }));
+        }
+        const choiceName = typeof optionText === 'function'
+            ? optionText(choice)
+            : get(choice, optionText);
+        return isValidElement(choiceName)
+            ? choiceName
+            : translateChoice
+                ? translate(String(choiceName), { _: choiceName })
+                : String(choiceName);
+    }, [createHintValue, createValue, optionText, translate, translateChoice]);
+    const getChoiceValue = useCallback(choice => get(choice, optionValue, get(choice, 'id')), [optionValue]);
+    const getDisableValue = useCallback(choice => get(choice, disableValue), [disableValue]);
+    return {
+        getChoiceText,
+        getChoiceValue,
+        getDisableValue,
+    };
+};

package/dist/ra-core/src/form/choices/useChoicesContext.d.ts

@@ -0,0 +1,5 @@
+import { RaRecord } from '../../types';
+import { ChoicesContextValue } from './ChoicesContext';
+export declare const useChoicesContext: <ChoicesType extends RaRecord = RaRecord>(options?: Partial<ChoicesContextValue> & {
+    choices?: ChoicesType[];
+}) => ChoicesContextValue<ChoicesType>;

package/dist/ra-core/src/form/choices/useChoicesContext.js

@@ -0,0 +1,62 @@
+import { useContext, useMemo } from 'react';
+import { useList } from '../../controller';
+import { ChoicesContext } from './ChoicesContext';
+export const useChoicesContext = (options = {}) => {
+    const context = useContext(ChoicesContext);
+    const choices = options.choices && isArrayOfStrings(options.choices)
+        ? convertOptionsToChoices(options.choices)
+        : options.choices;
+    // @ts-ignore cannot satisfy the type of useList because of ability to pass partial options
+    const { data, ...list } = useList({
+        data: choices,
+        isLoading: options.isLoading ?? false,
+        isPending: options.isPending ?? false,
+        isFetching: options.isFetching ?? false,
+        error: options.error,
+        // When not in a ChoicesContext, paginating does not make sense (e.g. AutocompleteInput).
+        perPage: Infinity,
+    });
+    const result = useMemo(() => {
+        // Props take precedence over context.
+        if (options.choices || !context) {
+            return {
+                allChoices: data,
+                availableChoices: options.availableChoices ?? data,
+                selectedChoices: options.selectedChoices ?? data,
+                displayedFilters: options.selectedChoices ?? list.displayedFilters,
+                error: options.error,
+                filter: options.filter ?? list.filter,
+                filterValues: options.filterValues ?? list.filterValues,
+                hasNextPage: options.hasNextPage ?? list.hasNextPage,
+                hasPreviousPage: options.hasPreviousPage ?? list.hasPreviousPage,
+                hideFilter: options.hideFilter ?? list.hideFilter,
+                isFetching: list.isFetching ?? false, // we must take the one for useList, otherwise the loading state isn't synchronized with the data
+                isLoading: list.isLoading ?? false, // same
+                isPaused: list.isPaused ?? false, // same
+                isPending: list.isPending ?? false, // same
+                isPlaceholderData: list.isPlaceholderData ?? false, // same
+                page: options.page ?? list.page,
+                perPage: options.perPage ?? list.perPage,
+                refetch: options.refetch ?? list.refetch,
+                resource: options.resource ?? list.resource,
+                setFilters: options.setFilters ?? list.setFilters,
+                setPage: options.setPage ?? list.setPage,
+                setPerPage: options.setPerPage ?? list.setPerPage,
+                setSort: options.setSort ?? list.setSort,
+                showFilter: options.showFilter ?? list.showFilter,
+                sort: options.sort ?? list.sort,
+                source: options.source,
+                total: options.total ?? list.total,
+                isFromReference: false,
+            };
+        }
+        return context;
+    }, [context, data, list, options]);
+    return result;
+};
+const isArrayOfStrings = (choices) => Array.isArray(choices) &&
+    choices.every(choice => typeof choice === 'string');
+const convertOptionsToChoices = (options) => options.map(choice => ({
+    id: choice,
+    name: choice,
+}));

package/dist/ra-core/src/form/getFormInitialValues.d.ts

@@ -0,0 +1,8 @@
+import { RaRecord } from '../types';
+export default function getFormInitialValues(defaultValues: DefaultValue, record?: Partial<RaRecord>): any;
+interface DefaultValueObject {
+    [key: string]: any;
+}
+type DefaultValueFunction = (record: RaRecord) => DefaultValueObject;
+type DefaultValue = DefaultValueObject | DefaultValueFunction;
+export {};

package/dist/ra-core/src/form/getFormInitialValues.js

@@ -0,0 +1,14 @@
+import merge from 'lodash/merge.js';
+export default function getFormInitialValues(defaultValues, record) {
+    const finalInitialValues = merge({}, getValues(defaultValues, record), record);
+    return finalInitialValues;
+}
+function getValues(values, record) {
+    if (typeof values === 'object') {
+        return values;
+    }
+    if (typeof values === 'function') {
+        return values(record);
+    }
+    return {};
+}

package/dist/ra-core/src/form/groups/FormGroupContext.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Context allowing inputs to register to a specific group.
+ * This enables other components in the group to access group properties such as its
+ * validation (valid/invalid) or whether its inputs have been updated (dirty/pristine).
+ *
+ * This should only be used through a FormGroupContextProvider.
+ */
+export declare const FormGroupContext: import("react").Context<string | null>;
+export type FormGroupContextValue = string;

package/dist/ra-core/src/form/groups/FormGroupContext.js

@@ -0,0 +1,9 @@
+import { createContext } from 'react';
+/**
+ * Context allowing inputs to register to a specific group.
+ * This enables other components in the group to access group properties such as its
+ * validation (valid/invalid) or whether its inputs have been updated (dirty/pristine).
+ *
+ * This should only be used through a FormGroupContextProvider.
+ */
+export const FormGroupContext = createContext(null);

package/dist/ra-core/src/form/groups/FormGroupContextProvider.d.ts

@@ -0,0 +1,49 @@
+import { ReactNode } from 'react';
+/**
+ * This provider allows its input children to register to a specific group.
+ * This enables other components in the group to access group properties such as its
+ * validation (valid/invalid) or whether its inputs have been updated (dirty/pristine).
+ *
+ * @example
+ * import { Edit, SimpleForm, TextInput, FormGroupContextProvider, useFormGroup } from 'react-admin';
+ * import { Accordion, AccordionDetails, AccordionSummary, Typography } from '@mui/material';
+ *
+ * const PostEdit = () => (
+ *     <Edit>
+ *         <SimpleForm>
+ *             <TextInput source="title" />
+ *             <FormGroupContextProvider name="options">
+ *                 <Accordion>
+ *                     <AccordionSummary
+ *                         expandIcon={<ExpandMoreIcon />}
+ *                         aria-controls="options-content"
+ *                         id="options-header"
+ *                     >
+ *                         <AccordionSectionTitle name="options">Options</AccordionSectionTitle>
+ *                     </AccordionSummary>
+ *                     <AccordionDetails id="options-content" aria-labelledby="options-header">
+ *                         <TextInput source="teaser" validate={minLength(20)} />
+ *                     </AccordionDetails>
+ *                 </Accordion>
+ *             </FormGroupContextProvider>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ *
+ * const AccordionSectionTitle = ({ children, name }) => {
+ *     const formGroupState = useFormGroup(name);
+ *     return (
+ *         <Typography color={formGroupState.invalid && formGroupState.dirty ? 'error' : 'inherit'}>
+ *             {children}
+ *         </Typography>
+ *     );
+ * }
+ *
+ * @param props The component props
+ * @param {ReactNode} props.children The form group content
+ * @param {String} props.name The form group name
+ */
+export declare const FormGroupContextProvider: ({ children, name, }: {
+    children: ReactNode;
+    name: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ra-core/src/form/groups/FormGroupContextProvider.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { FormGroupContext } from './FormGroupContext';
+import { useFormGroups } from './useFormGroups';
+/**
+ * This provider allows its input children to register to a specific group.
+ * This enables other components in the group to access group properties such as its
+ * validation (valid/invalid) or whether its inputs have been updated (dirty/pristine).
+ *
+ * @example
+ * import { Edit, SimpleForm, TextInput, FormGroupContextProvider, useFormGroup } from 'react-admin';
+ * import { Accordion, AccordionDetails, AccordionSummary, Typography } from '@mui/material';
+ *
+ * const PostEdit = () => (
+ *     <Edit>
+ *         <SimpleForm>
+ *             <TextInput source="title" />
+ *             <FormGroupContextProvider name="options">
+ *                 <Accordion>
+ *                     <AccordionSummary
+ *                         expandIcon={<ExpandMoreIcon />}
+ *                         aria-controls="options-content"
+ *                         id="options-header"
+ *                     >
+ *                         <AccordionSectionTitle name="options">Options</AccordionSectionTitle>
+ *                     </AccordionSummary>
+ *                     <AccordionDetails id="options-content" aria-labelledby="options-header">
+ *                         <TextInput source="teaser" validate={minLength(20)} />
+ *                     </AccordionDetails>
+ *                 </Accordion>
+ *             </FormGroupContextProvider>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ *
+ * const AccordionSectionTitle = ({ children, name }) => {
+ *     const formGroupState = useFormGroup(name);
+ *     return (
+ *         <Typography color={formGroupState.invalid && formGroupState.dirty ? 'error' : 'inherit'}>
+ *             {children}
+ *         </Typography>
+ *     );
+ * }
+ *
+ * @param props The component props
+ * @param {ReactNode} props.children The form group content
+ * @param {String} props.name The form group name
+ */
+export const FormGroupContextProvider = ({ children, name, }) => {
+    const formGroups = useFormGroups();
+    useEffect(() => {
+        if (!formGroups ||
+            !formGroups.registerGroup ||
+            !formGroups.unregisterGroup) {
+            console.warn(`The FormGroupContextProvider can only be used inside a FormContext such as provided by the SimpleForm and TabbedForm components`);
+            return;
+        }
+        formGroups.registerGroup(name);
+        return () => {
+            formGroups.unregisterGroup(name);
+        };
+    }, [formGroups, name]);
+    return (_jsx(FormGroupContext.Provider, { value: name, children: children }));
+};

package/dist/ra-core/src/form/groups/FormGroupsContext.d.ts

@@ -0,0 +1,15 @@
+export declare const FormGroupsContext: import("react").Context<FormGroupsContextValue | undefined>;
+export type FormGroupSubscriber = () => void;
+export type FormGroupsContextValue = {
+    registerGroup: (name: string) => void;
+    unregisterGroup: (name: string) => void;
+    registerField: (source: string, group?: string) => void;
+    unregisterField: (source: string, group?: string) => void;
+    getGroupFields: (name: string) => string[];
+    /**
+     * Subscribe to any changes of the group content (fields added or removed).
+     * Subscribers can get the current fields of the group by calling getGroupFields.
+     * Returns a function to unsubscribe.
+     */
+    subscribe: (name: string, subscriber: FormGroupSubscriber) => () => void;
+};

package/dist/ra-core/src/form/groups/FormGroupsContext.js

@@ -0,0 +1,3 @@
+import { createContext } from 'react';
+export const FormGroupsContext = createContext(undefined);
+FormGroupsContext.displayName = 'FormGroupsContext';

package/dist/ra-core/src/form/groups/FormGroupsProvider.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+/**
+ * This component provides functions through context to manage form groups,
+ * allowing to link or unlink an input to a group.
+ * @see FormGroupContextProvider
+ * @see useFormGroup
+ * @see useFormGroups
+ */
+export declare const FormGroupsProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ra-core/src/form/groups/FormGroupsProvider.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useRef } from 'react';
+import { FormGroupsContext, } from './FormGroupsContext';
+/**
+ * This component provides functions through context to manage form groups,
+ * allowing to link or unlink an input to a group.
+ * @see FormGroupContextProvider
+ * @see useFormGroup
+ * @see useFormGroups
+ */
+export const FormGroupsProvider = ({ children }) => {
+    const formGroups = useRef({});
+    const subscribers = useRef({});
+    const formContextValue = useMemo(() => ({
+        /**
+         * Register a subscriber function for the specified group. The subscriber
+         * will be called whenever the group content changes (fields added or removed).
+         */
+        subscribe: (group, subscriber) => {
+            if (!subscribers.current[group]) {
+                subscribers.current[group] = [];
+            }
+            subscribers.current[group].push(subscriber);
+            return () => {
+                subscribers.current[group] = subscribers.current[group].filter(s => s !== subscriber);
+            };
+        },
+        getGroupFields: name => formGroups.current[name] || [],
+        registerGroup: name => {
+            formGroups.current[name] = formGroups.current[name] || [];
+        },
+        unregisterGroup: name => {
+            delete formGroups[name];
+        },
+        registerField: (source, group) => {
+            if (group != null) {
+                if (!(formGroups.current[group] || []).includes(source)) {
+                    formGroups.current[group] = [
+                        ...(formGroups.current[group] || []),
+                        source,
+                    ];
+                    // Notify subscribers that the group fields have changed
+                    if (subscribers.current[group]) {
+                        subscribers.current[group].forEach(subscriber => subscriber());
+                    }
+                }
+            }
+        },
+        unregisterField: (source, group) => {
+            if (group != null) {
+                if (!formGroups.current[group]) {
+                    console.warn(`Invalid form group ${group}`);
+                }
+                else {
+                    const fields = new Set(formGroups.current[group]);
+                    fields.delete(source);
+                    formGroups.current[group] = Array.from(fields);
+                    // Notify subscribers that the group fields have changed
+                    if (subscribers.current[group]) {
+                        subscribers.current[group].forEach(subscriber => subscriber());
+                    }
+                }
+            }
+        },
+    }), []);
+    return (_jsx(FormGroupsContext.Provider, { value: formContextValue, children: children }));
+};

package/dist/ra-core/src/form/groups/index.d.ts

@@ -0,0 +1,6 @@
+export * from './FormGroupContext';
+export * from './FormGroupContextProvider';
+export * from './FormGroupsProvider';
+export * from './useFormGroup';
+export * from './useFormGroups';
+export * from './useFormGroupContext';

package/dist/ra-core/src/form/groups/index.js

@@ -0,0 +1,6 @@
+export * from './FormGroupContext';
+export * from './FormGroupContextProvider';
+export * from './FormGroupsProvider';
+export * from './useFormGroup';
+export * from './useFormGroups';
+export * from './useFormGroupContext';