@strato-admin/core 0.1.0 → 0.3.0

package/dist/ra-core/src/dataTable/index.js

@@ -0,0 +1,11 @@
+export * from './DataTableBase';
+export * from './DataTableCallbacksContext';
+export * from './DataTableColumnRankContext';
+export * from './DataTableColumnFilterContext';
+export * from './DataTableConfigContext';
+export * from './DataTableDataContext';
+export * from './DataTableRenderContext';
+export * from './DataTableSelectedIdsContext';
+export * from './DataTableSortContext';
+export * from './DataTableStoreContext';
+export * from './types';

package/dist/ra-core/src/dataTable/types.d.ts

@@ -0,0 +1,2 @@
+import { Identifier, RaRecord } from '../types';
+export type RowClickFunctionBase<RecordType extends RaRecord = RaRecord> = (id: Identifier, resource: string, record: RecordType) => string | false | Promise<string | false>;

package/dist/ra-core/src/dataTable/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ra-core/src/export/ExporterContext.d.ts

@@ -0,0 +1,2 @@
+import { Exporter } from '../types';
+export declare const ExporterContext: import("react").Context<false | Exporter>;

package/dist/ra-core/src/export/ExporterContext.js

@@ -0,0 +1,4 @@
+import { createContext } from 'react';
+import { defaultExporter } from './defaultExporter';
+export const ExporterContext = createContext(defaultExporter);
+ExporterContext.displayName = 'ExporterContext';

package/dist/ra-core/src/export/defaultExporter.d.ts

@@ -0,0 +1,2 @@
+import { Exporter } from '../types';
+export declare const defaultExporter: Exporter;

package/dist/ra-core/src/export/defaultExporter.js

@@ -0,0 +1,3 @@
+import jsonExport from 'jsonexport/dist/index.js';
+import { downloadCSV } from './downloadCSV';
+export const defaultExporter = (data, _, __, resource) => jsonExport(data, (err, csv) => downloadCSV(csv, resource));

package/dist/ra-core/src/export/downloadCSV.d.ts

@@ -0,0 +1 @@
+export declare const downloadCSV: (csv: string, filename?: string) => void;

package/dist/ra-core/src/export/downloadCSV.js

@@ -0,0 +1,17 @@
+export const downloadCSV = (csv, filename = 'export') => {
+    const fakeLink = document.createElement('a');
+    fakeLink.style.display = 'none';
+    document.body.appendChild(fakeLink);
+    const blob = new Blob([csv], { type: 'text/csv;charset=utf-8' });
+    // @ts-ignore
+    if (window.navigator && window.navigator.msSaveOrOpenBlob) {
+        // Manage IE11+ & Edge
+        // @ts-ignore
+        window.navigator.msSaveOrOpenBlob(blob, `${filename}.csv`);
+    }
+    else {
+        fakeLink.setAttribute('href', URL.createObjectURL(blob));
+        fakeLink.setAttribute('download', `${filename}.csv`);
+        fakeLink.click();
+    }
+};

package/dist/ra-core/src/export/fetchRelatedRecords.d.ts

@@ -0,0 +1,14 @@
+import { DataProvider, FetchRelatedRecords } from '../types';
+/**
+ * Helper function for calling the dataProvider.getMany() method,
+ * and getting a Promise for the records indexed by id in return.
+ *
+ * @example
+ *     fetchRelatedRecords(dataProvider)(records, 'post_id', 'posts').then(posts =>
+ *         posts.map(record => ({
+ *             ...record,
+ *             post_title: posts[record.post_id].title,
+ *         }))
+ *     );
+ */
+export declare const fetchRelatedRecords: (dataProvider: DataProvider) => FetchRelatedRecords;

package/dist/ra-core/src/export/fetchRelatedRecords.js

@@ -0,0 +1,19 @@
+import { getRelatedIds } from './getRelatedIds';
+/**
+ * Helper function for calling the dataProvider.getMany() method,
+ * and getting a Promise for the records indexed by id in return.
+ *
+ * @example
+ *     fetchRelatedRecords(dataProvider)(records, 'post_id', 'posts').then(posts =>
+ *         posts.map(record => ({
+ *             ...record,
+ *             post_title: posts[record.post_id].title,
+ *         }))
+ *     );
+ */
+export const fetchRelatedRecords = (dataProvider) => (data, field, resource) => dataProvider
+    .getMany(resource, { ids: getRelatedIds(data, field) })
+    .then(({ data }) => data.reduce((acc, post) => {
+    acc[post.id] = post;
+    return acc;
+}, {}));

package/dist/ra-core/src/export/getRelatedIds.d.ts

@@ -0,0 +1,24 @@
+import { RaRecord, Identifier } from '../types';
+/**
+ * Extracts, aggregates and deduplicates the ids of related records
+ *
+ * @example
+ *     const books = [
+ *         { id: 1, author_id: 123, title: 'Pride and Prejudice' },
+ *         { id: 2, author_id: 123, title: 'Sense and Sensibility' },
+ *         { id: 3, author_id: 456, title: 'War and Peace' },
+ *     ];
+ *     getRelatedIds(books, 'author_id'); => [123, 456]
+ *
+ * @example
+ *     const books = [
+ *         { id: 1, tag_ids: [1, 2], title: 'Pride and Prejudice' },
+ *         { id: 2, tag_ids: [2, 3], title: 'Sense and Sensibility' },
+ *         { id: 3, tag_ids: [4], title: 'War and Peace' },
+ *     ];
+ *     getRelatedIds(records, 'tag_ids'); => [1, 2, 3, 4]
+ *
+ * @param {Object[]} records An array of records
+ * @param {string} field the identifier of the record field to use
+ */
+export declare const getRelatedIds: (records: RaRecord[], field: string) => Identifier[];

package/dist/ra-core/src/export/getRelatedIds.js

@@ -0,0 +1,26 @@
+/**
+ * Extracts, aggregates and deduplicates the ids of related records
+ *
+ * @example
+ *     const books = [
+ *         { id: 1, author_id: 123, title: 'Pride and Prejudice' },
+ *         { id: 2, author_id: 123, title: 'Sense and Sensibility' },
+ *         { id: 3, author_id: 456, title: 'War and Peace' },
+ *     ];
+ *     getRelatedIds(books, 'author_id'); => [123, 456]
+ *
+ * @example
+ *     const books = [
+ *         { id: 1, tag_ids: [1, 2], title: 'Pride and Prejudice' },
+ *         { id: 2, tag_ids: [2, 3], title: 'Sense and Sensibility' },
+ *         { id: 3, tag_ids: [4], title: 'War and Peace' },
+ *     ];
+ *     getRelatedIds(records, 'tag_ids'); => [1, 2, 3, 4]
+ *
+ * @param {Object[]} records An array of records
+ * @param {string} field the identifier of the record field to use
+ */
+export const getRelatedIds = (records, field) => Array.from(new Set(records
+    .filter(record => record[field] != null)
+    .map(record => record[field])
+    .reduce((ids, value) => ids.concat(value), [])));

package/dist/ra-core/src/export/index.d.ts

@@ -0,0 +1,5 @@
+export * from './defaultExporter';
+export * from './downloadCSV';
+export * from './ExporterContext';
+export * from './fetchRelatedRecords';
+export * from './useBulkExport';

package/dist/ra-core/src/export/index.js

@@ -0,0 +1,5 @@
+export * from './defaultExporter';
+export * from './downloadCSV';
+export * from './ExporterContext';
+export * from './fetchRelatedRecords';
+export * from './useBulkExport';

package/dist/ra-core/src/export/useBulkExport.d.ts

@@ -0,0 +1,11 @@
+import { Exporter, RaRecord } from '../types';
+/**
+ * A hook that provides a callback to export the selected records from the nearest ListContext and call the exporter function for them.
+ */
+export declare function useBulkExport<RecordType extends RaRecord = any>(options?: UseBulkExportOptions<RecordType>): UseBulkExportResult;
+export type UseBulkExportResult = () => void;
+export interface UseBulkExportOptions<RecordType extends RaRecord = any> {
+    exporter?: Exporter<RecordType>;
+    meta?: any;
+    resource?: string;
+}

package/dist/ra-core/src/export/useBulkExport.js

@@ -0,0 +1,30 @@
+import { useCallback } from 'react';
+import { useResourceContext } from '../core/useResourceContext';
+import { useListContext } from '../controller/list/useListContext';
+import { useDataProvider } from '../dataProvider/useDataProvider';
+import { useNotify } from '../notification/useNotify';
+import { fetchRelatedRecords } from './fetchRelatedRecords';
+/**
+ * A hook that provides a callback to export the selected records from the nearest ListContext and call the exporter function for them.
+ */
+export function useBulkExport(options = {}) {
+    const { exporter: customExporter, meta } = options;
+    const resource = useResourceContext(options);
+    const { exporter: exporterFromContext, selectedIds } = useListContext();
+    const exporter = customExporter || exporterFromContext;
+    const dataProvider = useDataProvider();
+    const notify = useNotify();
+    return useCallback(() => {
+        if (exporter && resource) {
+            dataProvider
+                .getMany(resource, { ids: selectedIds, meta })
+                .then(({ data }) => exporter(data, fetchRelatedRecords(dataProvider), dataProvider, resource))
+                .catch(error => {
+                console.error(error);
+                notify("strato.notification.http_error', {
+                    type: 'error',
+                });
+            });
+        }
+    }, [dataProvider, exporter, notify, resource, selectedIds, meta]);
+}

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

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { UseFormProps } from 'react-hook-form';
+import { type ValidateForm } from './validation';
+/**
+ * This component offers a convenient way to create a form that automatically
+ * updates the filters when the user changes its child input values.
+ *
+ * It fits nicely alongside a `<FilterList>` component, but you can also use it
+ * at other places to create your own filter UI.
+ *
+ * @example
+ * import MailIcon from '@mui/icons-material/MailOutline';
+ * import TitleIcon from '@mui/icons-material/Title';
+ * import { Card, CardContent } from '@mui/material';
+ * import * as React from 'react';
+ * import {
+ *     FilterLiveForm,
+ *     FilterList,
+ *     FilterListItem,
+ *     FilterListSection,
+ *     TextInput,
+ * } from 'react-admin';
+ *
+ * export const BookListAside = () => (
+ *     <Card sx={{ order: -1, mr: 2, mt: 6, width: 250, height: 'fit-content' }}>
+ *         <CardContent>
+ *             <FilterList label="Subscribed to newsletter" icon={<MailIcon />}>
+ *                 <FilterListItem label="Yes" value={{ has_newsletter: true }} />
+ *                 <FilterListItem label="No" value={{ has_newsletter: false }} />
+ *             </FilterList>
+ *             <FilterListSection label="Title" icon={<TitleIcon />}>
+ *                 <FilterLiveForm>
+ *                     <TextInput source="title" resettable helperText={false} />
+ *                 </FilterLiveForm>
+ *             </FilterListSection>
+ *         </CardContent>
+ *     </Card>
+ * );
+ */
+export declare const FilterLiveForm: (props: FilterLiveFormProps) => import("react/jsx-runtime").JSX.Element;
+export interface FilterLiveFormProps extends Omit<UseFormProps, 'onSubmit' | 'defaultValues'> {
+    children: ReactNode;
+    validate?: ValidateForm;
+    debounce?: number | false;
+    resource?: string;
+    formComponent?: React.ComponentType<Pick<React.HTMLAttributes<HTMLFormElement>, 'onSubmit'>>;
+}
+/**
+ * Because we are using controlled inputs with react-hook-form, we must provide a default value
+ * for each input when resetting the form. (see https://react-hook-form.com/docs/useform/reset).
+ * To ensure we don't provide undefined which will result to the current input value being reapplied
+ * and due to the dynamic nature of the filter form, we rebuild the filter form values from its current
+ * values and make sure to pass at least an empty string for each input.
+ */
+export declare const getFilterFormValues: (formValues: Record<string, any>, filterValues: Record<string, any>) => {};

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

@@ -0,0 +1,161 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import isEqual from 'lodash/isEqual.js';
+import cloneDeep from 'lodash/cloneDeep.js';
+import get from 'lodash/get.js';
+import mergeWith from 'lodash/mergeWith.js';
+import set from 'lodash/set.js';
+import { useEffect } from 'react';
+import { FormProvider, useForm } from 'react-hook-form';
+import { SourceContextProvider, useResourceContext, } from '../core';
+import { FormGroupsProvider } from './groups/FormGroupsProvider';
+import { getSimpleValidationResolver } from './validation';
+import { useDebouncedEvent } from '../util';
+import { useListContext } from '../controller/list/useListContext';
+/**
+ * This component offers a convenient way to create a form that automatically
+ * updates the filters when the user changes its child input values.
+ *
+ * It fits nicely alongside a `<FilterList>` component, but you can also use it
+ * at other places to create your own filter UI.
+ *
+ * @example
+ * import MailIcon from '@mui/icons-material/MailOutline';
+ * import TitleIcon from '@mui/icons-material/Title';
+ * import { Card, CardContent } from '@mui/material';
+ * import * as React from 'react';
+ * import {
+ *     FilterLiveForm,
+ *     FilterList,
+ *     FilterListItem,
+ *     FilterListSection,
+ *     TextInput,
+ * } from 'react-admin';
+ *
+ * export const BookListAside = () => (
+ *     <Card sx={{ order: -1, mr: 2, mt: 6, width: 250, height: 'fit-content' }}>
+ *         <CardContent>
+ *             <FilterList label="Subscribed to newsletter" icon={<MailIcon />}>
+ *                 <FilterListItem label="Yes" value={{ has_newsletter: true }} />
+ *                 <FilterListItem label="No" value={{ has_newsletter: false }} />
+ *             </FilterList>
+ *             <FilterListSection label="Title" icon={<TitleIcon />}>
+ *                 <FilterLiveForm>
+ *                     <TextInput source="title" resettable helperText={false} />
+ *                 </FilterLiveForm>
+ *             </FilterListSection>
+ *         </CardContent>
+ *     </Card>
+ * );
+ */
+export const FilterLiveForm = (props) => {
+    const { filterValues, setFilters } = useListContext();
+    const resource = useResourceContext(props);
+    const { debounce = 500, resolver, validate, children, formComponent: Component = HTMLForm, ...rest } = props;
+    const finalResolver = resolver
+        ? resolver
+        : validate
+            ? getSimpleValidationResolver(validate)
+            : undefined;
+    const formContext = useForm({
+        mode: 'onChange',
+        resolver: finalResolver,
+        ...rest,
+    });
+    const { handleSubmit, getValues, reset, watch, formState } = formContext;
+    const { isValid } = formState;
+    const hasJustBeenModifiedByUser = React.useRef(false);
+    // Reapply filterValues when they change externally
+    useEffect(() => {
+        // Unless users has just modified the form themselves in which case we want to avoid overriding it with
+        // a previous value which was applied with a delay (debounce in List)
+        if (hasJustBeenModifiedByUser.current) {
+            hasJustBeenModifiedByUser.current = false;
+            return;
+        }
+        const newValues = getFilterFormValues(getValues(), filterValues);
+        const previousValues = getValues();
+        if (!isEqual(newValues, previousValues)) {
+            reset(newValues);
+        }
+        // The reference to the filterValues object is not updated when it changes,
+        // so we must stringify it to compare it by value.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [JSON.stringify(filterValues), getValues, reset]);
+    const onSubmit = (values) => {
+        // Do not call setFilters if the form is invalid
+        if (!isValid) {
+            return;
+        }
+        setFilters(mergeObjNotArray(filterValues, values));
+    };
+    const debouncedOnSubmit = useDebouncedEvent(onSubmit, debounce || 0);
+    // Submit the form on values change
+    useEffect(() => {
+        const { unsubscribe } = watch((values, { name }) => {
+            // Check that the name is present to avoid setting filters when
+            // watch was triggered by a reset
+            if (name) {
+                if (get(values, name) === '') {
+                    const newValues = cloneDeep(values);
+                    set(newValues, name, '');
+                    hasJustBeenModifiedByUser.current = true;
+                    debouncedOnSubmit(newValues);
+                }
+                else {
+                    hasJustBeenModifiedByUser.current = true;
+                    debouncedOnSubmit(values);
+                }
+            }
+        });
+        return () => unsubscribe();
+    }, [watch, debouncedOnSubmit]);
+    const sourceContext = React.useMemo(() => ({
+        getSource: (source) => source,
+        getLabel: (source) => `resources.${resource}.fields.${source}`,
+    }), [resource]);
+    return (_jsx(FormProvider, { ...formContext, children: _jsx(FormGroupsProvider, { children: _jsx(SourceContextProvider, { value: sourceContext, children: _jsx(Component, { onSubmit: handleSubmit(onSubmit), children: children }) }) }) }));
+};
+const HTMLForm = (props) => (_jsx("form", { ...props }));
+// Lodash merge customizer to merge objects but not arrays
+const mergeCustomizer = (objValue, srcValue) => {
+    if (Array.isArray(srcValue)) {
+        return srcValue;
+    }
+};
+const mergeObjNotArray = (a, b) => mergeWith(cloneDeep(a), b, mergeCustomizer);
+/**
+ * Because we are using controlled inputs with react-hook-form, we must provide a default value
+ * for each input when resetting the form. (see https://react-hook-form.com/docs/useform/reset).
+ * To ensure we don't provide undefined which will result to the current input value being reapplied
+ * and due to the dynamic nature of the filter form, we rebuild the filter form values from its current
+ * values and make sure to pass at least an empty string for each input.
+ */
+export const getFilterFormValues = (formValues, filterValues) => {
+    return Object.keys(formValues).reduce((acc, key) => {
+        acc[key] = getInputValue(formValues, key, filterValues);
+        return acc;
+    }, {});
+};
+const getInputValue = (formValues, key, filterValues) => {
+    if (formValues[key] === undefined || formValues[key] === null) {
+        return get(filterValues, key, '');
+    }
+    if (Array.isArray(formValues[key])) {
+        return get(filterValues, key, '');
+    }
+    if (formValues[key] instanceof Date) {
+        return get(filterValues, key, '');
+    }
+    if (typeof formValues[key] === 'object') {
+        const inputValues = Object.keys(formValues[key]).reduce((acc, innerKey) => {
+            const nestedInputValue = getInputValue(formValues[key], innerKey, (filterValues || {})[key] ?? {});
+            acc[innerKey] = nestedInputValue;
+            return acc;
+        }, {});
+        if (!Object.keys(inputValues).length)
+            return '';
+        return inputValues;
+    }
+    return get(filterValues, key, '');
+};

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

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { FieldValues, UseFormProps, SubmitHandler } from 'react-hook-form';
+import { RaRecord } from '../types';
+import { SaveHandler } from '../controller';
+import { ValidateForm } from './validation/getSimpleValidationResolver';
+/**
+ * Creates a form element, initialized with the current record, calling the saveContext on submit
+ *
+ * Wrapper around react-hook-form's useForm, FormContextProvider, and <form>.
+ * Also sets up a FormGroupContext, and handles submission validation.
+ *
+ * @example
+ *
+ * const MyForm = ({ record, defaultValues, validate }) => (
+ *    <Form record={record} defaultValues={defaultValues} validate={validate}>
+ *        <Stack>
+ *            <TextInput source="title" />
+ *            <SaveButton />
+ *        </Stack>
+ *    </Form>
+ * );
+ *
+ * @typedef {Object} Props the props you can use
+ * @prop {Object} defaultValues
+ * @prop {Function} validate
+ * @prop {Function} save
+ *
+ * @see useForm
+ * @see FormGroupContext
+ *
+ * @link https://react-hook-form.com/docs/useformcontext
+ */
+export declare function Form<RecordType = any>(props: FormProps<RecordType>): import("react/jsx-runtime").JSX.Element;
+export type FormProps<RecordType = any> = FormOwnProps<RecordType> & Omit<UseFormProps, 'onSubmit'> & {
+    validate?: ValidateForm;
+    noValidate?: boolean;
+    WarnWhenUnsavedChangesComponent?: React.ComponentType<{
+        enable?: boolean;
+        formRootPathName?: string;
+        formControl?: any;
+    }>;
+};
+export interface FormOwnProps<RecordType = any> {
+    children: ReactNode;
+    className?: string;
+    defaultValues?: any;
+    formRootPathname?: string;
+    id?: string;
+    record?: Partial<RaRecord>;
+    resource?: string;
+    onSubmit?: SubmitHandler<FieldValues> | SaveHandler<RecordType>;
+    warnWhenUnsavedChanges?: boolean;
+    sanitizeEmptyValues?: boolean;
+    disableInvalidFormNotification?: boolean;
+}

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

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import { FormProvider, } from 'react-hook-form';
+import { FormGroupsProvider } from './groups/FormGroupsProvider';
+import { useRecordContext, OptionalRecordContextProvider, } from '../controller';
+import { SourceContextProvider, useResourceContext, } from '../core';
+import { useCanBlock } from '../routing';
+import { WarnWhenUnsavedChanges } from './WarnWhenUnsavedChanges';
+import { useAugmentedForm } from './useAugmentedForm';
+/**
+ * Creates a form element, initialized with the current record, calling the saveContext on submit
+ *
+ * Wrapper around react-hook-form's useForm, FormContextProvider, and <form>.
+ * Also sets up a FormGroupContext, and handles submission validation.
+ *
+ * @example
+ *
+ * const MyForm = ({ record, defaultValues, validate }) => (
+ *    <Form record={record} defaultValues={defaultValues} validate={validate}>
+ *        <Stack>
+ *            <TextInput source="title" />
+ *            <SaveButton />
+ *        </Stack>
+ *    </Form>
+ * );
+ *
+ * @typedef {Object} Props the props you can use
+ * @prop {Object} defaultValues
+ * @prop {Function} validate
+ * @prop {Function} save
+ *
+ * @see useForm
+ * @see FormGroupContext
+ *
+ * @link https://react-hook-form.com/docs/useformcontext
+ */
+export function Form(props) {
+    const { children, id, className, noValidate = false, formRootPathname, warnWhenUnsavedChanges, WarnWhenUnsavedChangesComponent = WarnWhenUnsavedChanges, } = props;
+    const record = useRecordContext(props);
+    const resource = useResourceContext(props);
+    const { form, formHandleSubmit } = useAugmentedForm(props);
+    const sourceContext = React.useMemo(() => ({
+        getSource: (source) => source,
+        getLabel: (source) => `resources.${resource}.fields.${source}`,
+    }), [resource]);
+    const canBlock = useCanBlock();
+    if (warnWhenUnsavedChanges &&
+        !canBlock &&
+        process.env.NODE_ENV === 'development') {
+        console.error('Cannot use the warnWhenUnsavedChanges feature outside of a DataRouter. ' +
+            'The warnWhenUnsavedChanges feature is disabled. ' +
+            'Remove the warnWhenUnsavedChanges prop or convert your custom router to a Data Router.');
+    }
+    return (_jsx(OptionalRecordContextProvider, { value: record, children: _jsx(SourceContextProvider, { value: sourceContext, children: _jsx(FormProvider, { ...form, children: _jsxs(FormGroupsProvider, { children: [_jsx("form", { onSubmit: formHandleSubmit, noValidate: noValidate, id: id, className: className, children: children }), warnWhenUnsavedChanges && canBlock && (_jsx(WarnWhenUnsavedChangesComponent, { enable: true, formRootPathName: formRootPathname, formControl: form.control }))] }) }) }) }));
+}

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

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { FieldValues } from 'react-hook-form';
+/**
+ * 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 declare const FormDataConsumer: <TFieldValues extends FieldValues = FieldValues>(props: ConnectedProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export declare const FormDataConsumerView: <TFieldValues extends FieldValues = FieldValues>(props: Props<TFieldValues>) => string | number | bigint | boolean | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
+export interface FormDataConsumerRenderParams<TFieldValues extends FieldValues = FieldValues, TScopedFieldValues extends FieldValues = TFieldValues> {
+    formData: TFieldValues;
+    scopedFormData?: TScopedFieldValues;
+}
+export type FormDataConsumerRender<TFieldValues extends FieldValues = FieldValues> = (params: FormDataConsumerRenderParams<TFieldValues>) => ReactNode;
+interface ConnectedProps<TFieldValues extends FieldValues = FieldValues> {
+    children: FormDataConsumerRender<TFieldValues>;
+    /**
+     * @deprecated This prop will be removed in a future major release.
+     */
+    form?: string;
+    /**
+     * @deprecated This prop will be removed in a future major release.
+     */
+    record?: any;
+    /**
+     * @deprecated This prop will be removed in a future major release.
+     */
+    source?: string;
+    /**
+     * @deprecated This prop will be removed in a future major release.
+     */
+    [key: string]: any;
+}
+interface Props<TFieldValues extends FieldValues> extends ConnectedProps {
+    formData: TFieldValues;
+    /**
+     * @deprecated This prop will be removed in a future major release.
+     */
+    index?: number;
+}
+export {};