@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

package/dist/ra-core/src/controller/field/useReferenceManyFieldController.js

@@ -0,0 +1,264 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import get from 'lodash/get.js';
+import isEqual from 'lodash/isEqual.js';
+import lodashDebounce from 'lodash/debounce.js';
+import { removeEmpty, useEvent } from '../../util';
+import { useDataProvider, useGetManyReference } from '../../dataProvider';
+import { useNotify } from '../../notification';
+import { DEFAULT_MAX_RESULTS } from '../list/useListController';
+import usePaginationState from '../usePaginationState';
+import { useRecordSelection } from '../list/useRecordSelection';
+import useSortState from '../useSortState';
+import { useResourceContext, useGetResourceLabel } from '../../core';
+import { useRecordContext } from '../record';
+import { defaultExporter } from '../../export';
+import { useTranslate } from '../../i18n';
+/**
+ * Fetch reference records, and return them when available
+ *
+ * Uses dataProvider.getManyReference() internally.
+ *
+ * @example // fetch the comments related to the current post
+ * const { isPending, data } = useReferenceManyFieldController({
+ *     reference: 'comments',
+ *     target: 'post_id',
+ *     record: { id: 123, title: 'hello, world' },
+ *     resource: 'posts',
+ * });
+ *
+ * @param {Object} props
+ * @param {string} props.reference The linked resource name. Required.
+ * @param {string} props.target The target resource key. Required.
+ * @param {Object} props.filter The filter applied on the recorded records list
+ * @param {number} props.page the page number
+ * @param {number} props.perPage the number of item per page
+ * @param {Object} props.record The current resource record
+ * @param {string} props.resource The current resource name
+ * @param {Object} props.sort the sort to apply to the referenced records
+ * @param {string} props.source The key of the linked resource identifier
+ * @param {UseQuery Options} props.queryOptions `react-query` options`
+ *
+ * @returns {ListControllerResult} The reference many props
+ */
+export const useReferenceManyFieldController = (props) => {
+    const { debounce = 500, reference, target, filter = defaultFilter, exporter = defaultExporter, source = 'id', page: initialPage, perPage: initialPerPage, sort: initialSort = { field: 'id', order: 'DESC' }, queryOptions = {}, } = props;
+    const notify = useNotify();
+    const translate = useTranslate();
+    const record = useRecordContext(props);
+    const resource = useResourceContext(props);
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const { meta, ...otherQueryOptions } = queryOptions;
+    // pagination logic
+    const { page, setPage, perPage, setPerPage } = usePaginationState({
+        page: initialPage,
+        perPage: initialPerPage,
+    });
+    // sort logic
+    const { sort, setSort: setSortState } = useSortState(initialSort);
+    const setSort = useCallback((sort) => {
+        setSortState(sort);
+        setPage(1);
+    }, [setPage, setSortState]);
+    // selection logic
+    const [selectedIds, selectionModifiers] = useRecordSelection({
+        resource: reference,
+        storeKey: props.storeKey ?? `${resource}.${record?.id}.${reference}`,
+    });
+    const onUnselectItems = useCallback((fromAllStoreKeys) => {
+        return selectionModifiers.unselect(selectedIds, fromAllStoreKeys);
+    }, [selectedIds, selectionModifiers]);
+    // filter logic
+    const filterRef = useRef(filter);
+    const [displayedFilters, setDisplayedFilters] = useState({});
+    const [filterValues, setFilterValues] = useState(filter);
+    const hideFilter = useCallback((filterName) => {
+        setDisplayedFilters(previousState => {
+            const { [filterName]: _, ...newState } = previousState;
+            return newState;
+        });
+        setFilterValues(previousState => {
+            const { [filterName]: _, ...newState } = previousState;
+            return newState;
+        });
+    }, [setDisplayedFilters, setFilterValues]);
+    const showFilter = useCallback((filterName, defaultValue) => {
+        setDisplayedFilters(previousState => ({
+            ...previousState,
+            [filterName]: true,
+        }));
+        setFilterValues(previousState => ({
+            ...previousState,
+            [filterName]: defaultValue,
+        }));
+    }, [setDisplayedFilters, setFilterValues]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const debouncedSetFilters = useCallback(lodashDebounce((filters, displayedFilters) => {
+        setFilterValues(removeEmpty(filters));
+        setDisplayedFilters(displayedFilters);
+        setPage(1);
+    }, debounce), [setDisplayedFilters, setFilterValues, setPage]);
+    const setFilters = useCallback((filters, displayedFilters, debounce = false) => {
+        if (debounce) {
+            debouncedSetFilters(filters, displayedFilters);
+        }
+        else {
+            setFilterValues(removeEmpty(filters));
+            setDisplayedFilters(displayedFilters);
+            setPage(1);
+        }
+    }, [setDisplayedFilters, setFilterValues, setPage, debouncedSetFilters]);
+    // handle filter prop change
+    useEffect(() => {
+        if (!isEqual(filter, filterRef.current)) {
+            filterRef.current = filter;
+            setFilterValues(filter);
+        }
+    }, [filter]);
+    const recordValue = get(record, source);
+    const { data, total, meta: responseMeta, pageInfo, error, isFetching, isLoading, isPaused, isPending, isPlaceholderData, refetch, } = useGetManyReference(reference, {
+        target,
+        id: recordValue,
+        pagination: { page, perPage },
+        sort,
+        filter: filterValues,
+        meta,
+    }, {
+        enabled: recordValue != null,
+        placeholderData: previousData => previousData,
+        onError: error => notify(typeof error === 'string'
+            ? error
+            : error?.message ||
+                "strato.notification.http_error', {
+            type: 'error',
+            messageArgs: {
+                _: typeof error === 'string'
+                    ? error
+                    : error?.message
+                        ? error.message
+                        : undefined,
+            },
+        }),
+        ...otherQueryOptions,
+    });
+    const onSelectAll = useEvent(async ({ limit = 250, queryOptions = {}, } = {}) => {
+        const { meta, onSuccess, onError } = queryOptions;
+        try {
+            const results = await queryClient.fetchQuery({
+                queryKey: [
+                    reference,
+                    'getManyReference',
+                    {
+                        target,
+                        id: get(record, source),
+                        pagination: { page: 1, perPage: limit },
+                        sort,
+                        filter,
+                        meta,
+                    },
+                ],
+                queryFn: () => dataProvider.getManyReference(reference, {
+                    target,
+                    id: get(record, source),
+                    pagination: { page: 1, perPage: limit },
+                    sort,
+                    filter,
+                    meta,
+                }),
+            });
+            const allIds = results.data?.map(({ id }) => id) || [];
+            selectionModifiers.select(allIds);
+            if (allIds.length === limit) {
+                notify("strato.message.select_all_limit_reached', {
+                    messageArgs: { max: limit },
+                    type: 'warning',
+                });
+            }
+            if (onSuccess) {
+                onSuccess(results);
+            }
+            return results.data;
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+            notify("strato.notification.http_error', { type: 'warning' });
+        }
+    });
+    const getData = useEvent(async ({ maxResults, meta: metaOverride } = {}) => {
+        if (recordValue == null || total === 0) {
+            return [];
+        }
+        const limit = maxResults ?? (total != null ? total : DEFAULT_MAX_RESULTS);
+        const { data } = await queryClient.fetchQuery({
+            queryKey: [
+                reference,
+                'getManyReference',
+                {
+                    target,
+                    id: recordValue,
+                    pagination: { page: 1, perPage: limit },
+                    sort,
+                    filter: filterValues,
+                    meta: metaOverride ?? meta,
+                },
+            ],
+            queryFn: () => dataProvider.getManyReference(reference, {
+                target,
+                id: recordValue,
+                pagination: { page: 1, perPage: limit },
+                sort,
+                filter: filterValues,
+                meta: metaOverride ?? meta,
+            }),
+        });
+        return data;
+    });
+    const getResourceLabel = useGetResourceLabel();
+    const defaultTitle = translate(`resources.${reference}.page.list`, {
+        _: translate("strato.page.list', {
+            name: getResourceLabel(reference, 2),
+        }),
+    });
+    return {
+        sort,
+        data,
+        meta: responseMeta,
+        defaultTitle,
+        displayedFilters,
+        error,
+        exporter,
+        filterValues,
+        hideFilter,
+        isFetching,
+        isLoading,
+        isPaused,
+        isPending,
+        isPlaceholderData,
+        onSelect: selectionModifiers.select,
+        onSelectAll,
+        onToggleItem: selectionModifiers.toggle,
+        onUnselectItems,
+        page,
+        perPage,
+        refetch,
+        resource: reference,
+        selectedIds,
+        setFilters,
+        setPage,
+        setPerPage,
+        hasNextPage: pageInfo
+            ? pageInfo.hasNextPage
+            : total != null
+                ? page * perPage < total
+                : undefined,
+        hasPreviousPage: pageInfo ? pageInfo.hasPreviousPage : page > 1,
+        setSort,
+        showFilter,
+        total,
+        getData,
+    };
+};
+const defaultFilter = {};

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

@@ -0,0 +1,17 @@
+import useFilterState from './useFilterState';
+import useSortState, { SortProps } from './useSortState';
+import usePaginationState, { PaginationHookResult } from './usePaginationState';
+import { useCheckMinimumRequiredProps } from './checkMinimumRequiredProps';
+export type { PaginationHookResult, SortProps };
+export { useCheckMinimumRequiredProps, useFilterState, usePaginationState, useSortState, };
+export * from './button';
+export * from './create';
+export * from './edit';
+export * from './field';
+export * from './input';
+export * from './list';
+export * from './record';
+export * from './saveContext';
+export * from './show';
+export * from './useReference';
+export * from './usePrevNextController';

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

@@ -0,0 +1,16 @@
+import useFilterState from './useFilterState';
+import useSortState from './useSortState';
+import usePaginationState from './usePaginationState';
+import { useCheckMinimumRequiredProps } from './checkMinimumRequiredProps';
+export { useCheckMinimumRequiredProps, useFilterState, usePaginationState, useSortState, };
+export * from './button';
+export * from './create';
+export * from './edit';
+export * from './field';
+export * from './input';
+export * from './list';
+export * from './record';
+export * from './saveContext';
+export * from './show';
+export * from './useReference';
+export * from './usePrevNextController';

package/dist/ra-core/src/controller/input/ArrayInputContext.d.ts

@@ -0,0 +1,9 @@
+import { UseFieldArrayReturn } from 'react-hook-form';
+/**
+ * A React context that provides access to an ArrayInput methods as provided by react-hook-form
+ * Useful to create custom array input iterators.
+ * @see {ArrayInput}
+ * @see {@link https://react-hook-form.com/docs/usefieldarray}
+ */
+export declare const ArrayInputContext: import("react").Context<ArrayInputContextValue | undefined>;
+export type ArrayInputContextValue = UseFieldArrayReturn;

package/dist/ra-core/src/controller/input/ArrayInputContext.js

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+/**
+ * A React context that provides access to an ArrayInput methods as provided by react-hook-form
+ * Useful to create custom array input iterators.
+ * @see {ArrayInput}
+ * @see {@link https://react-hook-form.com/docs/usefieldarray}
+ */
+export const ArrayInputContext = createContext(undefined);

package/dist/ra-core/src/controller/input/SimpleFormIteratorContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A React context that provides access to a SimpleFormIterator data (the total number of items) and mutators (add, reorder and remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export declare const SimpleFormIteratorContext: import("react").Context<SimpleFormIteratorContextValue | undefined>;
+export type SimpleFormIteratorContextValue = {
+    add: (item?: any) => void;
+    clear: () => void;
+    remove: (index: number) => void;
+    reOrder: (index: number, newIndex: number) => void;
+    source: string;
+    total: number;
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorContext.js

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+/**
+ * A React context that provides access to a SimpleFormIterator data (the total number of items) and mutators (add, reorder and remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export const SimpleFormIteratorContext = createContext(undefined);

package/dist/ra-core/src/controller/input/SimpleFormIteratorItemContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A React context that provides access to a SimpleFormIterator item meta (its index and the total number of items) and mutators (reorder and remove this remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export declare const SimpleFormIteratorItemContext: import("react").Context<SimpleFormIteratorItemContextValue | undefined>;
+export type SimpleFormIteratorItemContextValue = {
+    index: number;
+    total: number;
+    remove: () => void;
+    reOrder: (newIndex: number) => void;
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorItemContext.js

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+/**
+ * A React context that provides access to a SimpleFormIterator item meta (its index and the total number of items) and mutators (reorder and remove this remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export const SimpleFormIteratorItemContext = createContext(undefined);

package/dist/ra-core/src/controller/input/index.d.ts

@@ -0,0 +1,17 @@
+export * from './referenceDataStatus';
+export * from './useReferenceArrayInputController';
+export * from './useReferenceInputController';
+export * from './ReferenceInputBase';
+export * from './ReferenceArrayInputBase';
+export * from './ArrayInputBase';
+export * from './ArrayInputContext';
+export * from './SimpleFormIteratorBase';
+export * from './SimpleFormIteratorItemBase';
+export * from './useArrayInput';
+export * from './sanitizeInputRestProps';
+export * from './SimpleFormIteratorContext';
+export * from './SimpleFormIteratorItemContext';
+export * from './useSimpleFormIterator';
+export * from './useSimpleFormIteratorItem';
+export * from './useGetArrayInputNewItemDefaults';
+export * from './useSupportCreateSuggestion';

package/dist/ra-core/src/controller/input/index.js

@@ -0,0 +1,17 @@
+export * from './referenceDataStatus';
+export * from './useReferenceArrayInputController';
+export * from './useReferenceInputController';
+export * from './ReferenceInputBase';
+export * from './ReferenceArrayInputBase';
+export * from './ArrayInputBase';
+export * from './ArrayInputContext';
+export * from './SimpleFormIteratorBase';
+export * from './SimpleFormIteratorItemBase';
+export * from './useArrayInput';
+export * from './sanitizeInputRestProps';
+export * from './SimpleFormIteratorContext';
+export * from './SimpleFormIteratorItemContext';
+export * from './useSimpleFormIterator';
+export * from './useSimpleFormIteratorItem';
+export * from './useGetArrayInputNewItemDefaults';
+export * from './useSupportCreateSuggestion';

package/dist/ra-core/src/controller/input/referenceDataStatus.d.ts

@@ -0,0 +1,32 @@
+import { RaRecord, TranslateFunction } from '../../types';
+import { MatchingReferencesError } from './types';
+import { ControllerRenderProps } from 'react-hook-form';
+interface GetStatusForInputParams<RecordType extends RaRecord = RaRecord> {
+    field: Pick<ControllerRenderProps, 'value'>;
+    matchingReferences: RecordType[] | MatchingReferencesError;
+    referenceRecord: RecordType;
+    translate: TranslateFunction;
+}
+export declare const getStatusForInput: <RecordType extends RaRecord = RaRecord>({ field, matchingReferences, referenceRecord, translate, }: GetStatusForInputParams<RecordType>) => {
+    waiting: any;
+    error: string | null;
+    warning: string | null;
+    choices: RecordType[];
+};
+export declare const REFERENCES_STATUS_READY = "REFERENCES_STATUS_READY";
+export declare const REFERENCES_STATUS_INCOMPLETE = "REFERENCES_STATUS_INCOMPLETE";
+export declare const REFERENCES_STATUS_EMPTY = "REFERENCES_STATUS_EMPTY";
+export declare const getSelectedReferencesStatus: <RecordType extends RaRecord = any>(field: Pick<ControllerRenderProps, "value">, referenceRecords: RecordType[]) => "REFERENCES_STATUS_READY" | "REFERENCES_STATUS_INCOMPLETE" | "REFERENCES_STATUS_EMPTY";
+interface GetStatusForArrayInputParams<RecordType extends RaRecord = any> {
+    field: ControllerRenderProps;
+    matchingReferences: RecordType[] | MatchingReferencesError;
+    referenceRecords: RecordType[];
+    translate: TranslateFunction;
+}
+export declare const getStatusForArrayInput: <RecordType extends RaRecord = any>({ field, matchingReferences, referenceRecords, translate, }: GetStatusForArrayInputParams<RecordType>) => {
+    waiting: boolean;
+    error: string | null;
+    warning: string | null;
+    choices: RecordType[];
+};
+export {};

package/dist/ra-core/src/controller/input/referenceDataStatus.js

@@ -0,0 +1,74 @@
+const isMatchingReferencesError = (matchingReferences) => matchingReferences && matchingReferences.error !== undefined;
+export const getStatusForInput = ({ field, matchingReferences, referenceRecord, translate = x => x, }) => {
+    const matchingReferencesError = isMatchingReferencesError(matchingReferences)
+        ? translate(matchingReferences.error, {
+            _: matchingReferences.error,
+        })
+        : null;
+    const selectedReferenceError = field.value && !referenceRecord
+        ? translate("strato.input.references.single_missing', {
+            _: "strato.input.references.single_missing',
+        })
+        : null;
+    return {
+        waiting: (field.value && selectedReferenceError && !matchingReferences) ||
+            (!field.value && !matchingReferences),
+        error: (field.value &&
+            selectedReferenceError &&
+            matchingReferencesError) ||
+            (!field.value && matchingReferencesError)
+            ? field.value
+                ? selectedReferenceError
+                : matchingReferencesError
+            : null,
+        warning: selectedReferenceError || matchingReferencesError,
+        choices: Array.isArray(matchingReferences)
+            ? matchingReferences
+            : [referenceRecord].filter(choice => choice),
+    };
+};
+export const REFERENCES_STATUS_READY = 'REFERENCES_STATUS_READY';
+export const REFERENCES_STATUS_INCOMPLETE = 'REFERENCES_STATUS_INCOMPLETE';
+export const REFERENCES_STATUS_EMPTY = 'REFERENCES_STATUS_EMPTY';
+export const getSelectedReferencesStatus = (field, referenceRecords) => !field.value || field.value.length === referenceRecords.length
+    ? REFERENCES_STATUS_READY
+    : referenceRecords.length > 0
+        ? REFERENCES_STATUS_INCOMPLETE
+        : REFERENCES_STATUS_EMPTY;
+export const getStatusForArrayInput = ({ field, matchingReferences, referenceRecords, translate = x => x, }) => {
+    // selectedReferencesDataStatus can be "empty" (no data was found for references from input.value)
+    // or "incomplete" (Not all of the reference data was found)
+    // or "ready" (all references data was found or there is no references from input.value)
+    const selectedReferencesDataStatus = getSelectedReferencesStatus(field, referenceRecords);
+    const matchingReferencesError = isMatchingReferencesError(matchingReferences)
+        ? translate(matchingReferences.error, {
+            _: matchingReferences.error,
+        })
+        : null;
+    const choices = Array.isArray(matchingReferences)
+        ? referenceRecords.concat(matchingReferences.filter(choice => referenceRecords.findIndex(c => c.id === choice.id) === -1))
+        : referenceRecords;
+    return {
+        waiting: (!matchingReferences &&
+            field.value &&
+            selectedReferencesDataStatus === REFERENCES_STATUS_EMPTY) ||
+            (!matchingReferences && !field.value),
+        error: matchingReferencesError &&
+            (!field.value ||
+                (field.value &&
+                    selectedReferencesDataStatus === REFERENCES_STATUS_EMPTY))
+            ? translate("strato.input.references.all_missing', {
+                _: "strato.input.references.all_missing',
+            })
+            : null,
+        warning: matchingReferencesError ||
+            (field.value &&
+                selectedReferencesDataStatus !== REFERENCES_STATUS_READY)
+            ? matchingReferencesError ||
+                translate("strato.input.references.many_missing', {
+                    _: "strato.input.references.many_missing',
+                })
+            : null,
+        choices,
+    };
+};

package/dist/ra-core/src/controller/input/sanitizeInputRestProps.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeInputRestProps: ({ afterSubmit, allowNull, alwaysOn, beforeSubmit, component, data, defaultValue, error, format, formatOnBlur, initializeForm, input, isEqual, isRequired, label, limitChoicesToValue, locale, meta, multiple, name, options, optionText, optionValue, parse, record, ref, refetch, render, resource, setFilter, setPagination, setSort, shouldUnregister, source, submitError, subscription, textAlign, translate, translateChoice, validate, validateFields, value, ...rest }: any) => any;

package/dist/ra-core/src/controller/input/sanitizeInputRestProps.js

@@ -0,0 +1 @@
+export const sanitizeInputRestProps = ({ afterSubmit, allowNull, alwaysOn, beforeSubmit, component, data, defaultValue, error, format, formatOnBlur, initializeForm, input, isEqual, isRequired, label, limitChoicesToValue, locale, meta, multiple, name, options, optionText, optionValue, parse, record, ref, refetch, render, resource, setFilter, setPagination, setSort, shouldUnregister, source, submitError, subscription, textAlign, translate, translateChoice, validate, validateFields, value, ...rest }) => rest;

package/dist/ra-core/src/controller/input/types.d.ts

@@ -0,0 +1,3 @@
+export interface MatchingReferencesError {
+    error: string;
+}

package/dist/ra-core/src/controller/input/types.js

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

package/dist/ra-core/src/controller/input/useArrayInput.d.ts

@@ -0,0 +1,8 @@
+import { ArrayInputContextValue } from './ArrayInputContext';
+/**
+ * A hook to access an array input methods as provided by react-hook-form.
+ * Useful to create custom array input iterators.
+ * @see {ArrayInput}
+ * @see https://react-hook-form.com/docs/usefieldarray
+ */
+export declare const useArrayInput: (props?: Partial<ArrayInputContextValue>) => ArrayInputContextValue;

package/dist/ra-core/src/controller/input/useArrayInput.js

@@ -0,0 +1,29 @@
+import { useContext, useMemo } from 'react';
+import { ArrayInputContext } from './ArrayInputContext';
+/**
+ * A hook to access an array input methods as provided by react-hook-form.
+ * Useful to create custom array input iterators.
+ * @see {ArrayInput}
+ * @see https://react-hook-form.com/docs/usefieldarray
+ */
+export const useArrayInput = (props) => {
+    const context = useContext(ArrayInputContext);
+    const memo = useMemo(() => ({
+        append: props?.append,
+        fields: props?.fields,
+        insert: props?.insert,
+        move: props?.move,
+        prepend: props?.prepend,
+        remove: props?.remove,
+        replace: props?.replace,
+        swap: props?.swap,
+        update: props?.update,
+    }), [props]);
+    if (props?.fields) {
+        return memo;
+    }
+    if (!context) {
+        throw new Error('useArrayInput must be used inside an ArrayInputContextProvider');
+    }
+    return context;
+};

package/dist/ra-core/src/controller/input/useGetArrayInputNewItemDefaults.d.ts

@@ -0,0 +1,3 @@
+import { type ReactNode } from 'react';
+import type { ArrayInputContextValue } from './ArrayInputContext';
+export declare const useGetArrayInputNewItemDefaults: (fields: ArrayInputContextValue["fields"]) => (inputs?: ReactNode) => Record<string, unknown> | "";

package/dist/ra-core/src/controller/input/useGetArrayInputNewItemDefaults.js

@@ -0,0 +1,37 @@
+import { Children, isValidElement, useRef } from 'react';
+import { FormDataConsumer } from '../../form/FormDataConsumer';
+import { useEvent } from '../../util';
+export const useGetArrayInputNewItemDefaults = (fields) => {
+    const initialDefaultValue = useRef({});
+    if (fields.length > 0) {
+        const { id, ...rest } = fields[0];
+        initialDefaultValue.current = rest;
+        for (const k in initialDefaultValue.current)
+            initialDefaultValue.current[k] = null;
+    }
+    return useEvent((inputs) => {
+        if (Children.count(inputs) === 1 &&
+            isValidElement(Children.only(inputs)) &&
+            // @ts-ignore
+            !Children.only(inputs).props.source &&
+            // Make sure it's not a FormDataConsumer
+            // @ts-ignore
+            Children.only(inputs).type !== FormDataConsumer) {
+            // ArrayInput used for an array of scalar values
+            // (e.g. tags: ['foo', 'bar'])
+            return '';
+        }
+        // ArrayInput used for an array of objects
+        // (e.g. authors: [{ firstName: 'John', lastName: 'Doe' }, { firstName: 'Jane', lastName: 'Doe' }])
+        const defaultValue = initialDefaultValue.current;
+        Children.forEach(inputs, input => {
+            if (isValidElement(input) &&
+                input.type !== FormDataConsumer &&
+                input.props.source) {
+                defaultValue[input.props.source] =
+                    input.props.defaultValue ?? null;
+            }
+        });
+        return defaultValue;
+    });
+};

package/dist/ra-core/src/controller/input/useReferenceArrayInputController.d.ts

@@ -0,0 +1,48 @@
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { FilterPayload, RaRecord, SortPayload } from '../../types';
+import type { ChoicesContextValue } from '../../form';
+/**
+ * Prepare data for the ReferenceArrayInput components
+ *
+ * @example
+ *
+ * const { allChoices, availableChoices, selectedChoices, error, isFetching, isLoading, isPending } = useReferenceArrayInputController({
+ *      record: { referenceIds: ['id1', 'id2']};
+ *      reference: 'reference';
+ *      resource: 'resource';
+ *      source: 'referenceIds';
+ * });
+ *
+ * @param {Object} props
+ * @param {Object} props.record The current resource record
+ * @param {string} props.reference The linked resource name
+ * @param {string} props.resource The current resource name
+ * @param {string} props.source The key of the linked resource identifier
+ *
+ * @param {Props} props
+ *
+ * @return {Object} controllerProps Fetched data and callbacks for the ReferenceArrayInput components
+ */
+export declare const useReferenceArrayInputController: <RecordType extends RaRecord = any>(props: UseReferenceArrayInputParams<RecordType>) => ChoicesContextValue<RecordType>;
+export interface UseReferenceArrayInputParams<RecordType extends RaRecord = any> {
+    debounce?: number;
+    filter?: FilterPayload;
+    queryOptions?: Omit<UseQueryOptions<{
+        data: RecordType[];
+        total?: number;
+        pageInfo?: {
+            hasNextPage?: boolean;
+            hasPreviousPage?: boolean;
+        };
+    }>, 'queryFn' | 'queryKey'> & {
+        meta?: any;
+    };
+    page?: number;
+    perPage?: number;
+    record?: RecordType;
+    reference: string;
+    resource?: string;
+    sort?: SortPayload;
+    source: string;
+    enableGetChoices?: (filters: any) => boolean;
+}