@strato-admin/core 0.1.0 → 0.3.0

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

@@ -0,0 +1,226 @@
+import { useCallback, useMemo, useState, useRef, useEffect } from 'react';
+import lodashDebounce from 'lodash/debounce.js';
+import removeEmpty from '../../util/removeEmpty';
+import { queryReducer, HIDE_FILTER, SET_FILTER, SET_PAGE, SET_PER_PAGE, SET_SORT, SHOW_FILTER, SORT_ASC, } from '../list';
+/**
+ * Get the reference inputs parameters (page, sort, filters) and modifiers.
+ *
+ * @returns {Array} A tuple [parameters, modifiers].
+ * Destructure as [
+ *    { page, perPage, sort, order, filter, filterValues, displayedFilters, requestSignature },
+ *    { setFilters, hideFilter, showFilter, setPage, setPerPage, setSort }
+ * ]
+ *
+ * @example
+ *
+ * const [referenceParams, referenceParamsActions] = useReferenceParams({
+ *      resource: 'posts',
+ *      filterDefaultValues: {
+ *          published: true
+ *      },
+ *      sort: {
+ *          field: 'published_at',
+ *          order: 'DESC'
+ *      },
+ *      perPage: 25
+ * });
+ *
+ * const {
+ *      page,
+ *      perPage,
+ *      sort,
+ *      order,
+ *      filter,
+ *      filterValues,
+ *      displayedFilters,
+ *      requestSignature
+ * } = referenceParams;
+ *
+ * const {
+ *      setFilters,
+ *      hideFilter,
+ *      showFilter,
+ *      setPage,
+ *      setPerPage,
+ *      setSort,
+ * } = referenceParamsActions;
+ */
+export const useReferenceParams = ({ resource, filter, sort = defaultSort, page = 1, perPage = 10, debounce = 500, }) => {
+    const [params, setParams] = useState(defaultParams);
+    const tempParams = useRef(undefined);
+    const requestSignature = [
+        resource,
+        JSON.stringify(params),
+        JSON.stringify(filter),
+        JSON.stringify(sort),
+        page,
+        perPage,
+    ];
+    const query = useMemo(() => getQuery({
+        params: params,
+        filterDefaultValues: filter,
+        sort,
+        page,
+        perPage,
+    }), requestSignature // eslint-disable-line react-hooks/exhaustive-deps
+    );
+    const changeParams = useCallback(action => {
+        if (!tempParams.current) {
+            // no other changeParams action dispatched this tick
+            const newTempParams = queryReducer(query, action);
+            tempParams.current = newTempParams;
+            // schedule side effects for next tick
+            setTimeout(() => {
+                setParams(newTempParams);
+                tempParams.current = undefined;
+            }, 0);
+        }
+        else {
+            // side effects already scheduled, just change the params
+            tempParams.current = queryReducer(tempParams.current, action);
+        }
+    }, requestSignature); // eslint-disable-line react-hooks/exhaustive-deps
+    const setSort = useCallback((sort) => changeParams({
+        type: SET_SORT,
+        payload: sort,
+    }), requestSignature // eslint-disable-line react-hooks/exhaustive-deps
+    );
+    const setPage = useCallback((newPage) => changeParams({ type: SET_PAGE, payload: newPage }), requestSignature // eslint-disable-line react-hooks/exhaustive-deps
+    );
+    const setPerPage = useCallback((newPerPage) => changeParams({ type: SET_PER_PAGE, payload: newPerPage }), requestSignature // eslint-disable-line react-hooks/exhaustive-deps
+    );
+    const filterValues = query.filter || emptyObject;
+    const displayedFilterValues = query.displayedFilters || emptyObject;
+    const debouncedSetFilters = useRef(lodashDebounce((filter, displayedFilters = undefined) => {
+        changeParams({
+            type: SET_FILTER,
+            payload: {
+                filter: removeEmpty(filter),
+                displayedFilters,
+            },
+        });
+    }, debounce));
+    useEffect(() => {
+        return () => {
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+            debouncedSetFilters.current.cancel();
+        };
+    }, []);
+    const setFilters = useCallback((filter, displayedFilters = undefined, debounce = false) => {
+        debounce
+            ? debouncedSetFilters.current(filter, displayedFilters)
+            : changeParams({
+                type: SET_FILTER,
+                payload: {
+                    filter: removeEmpty(filter),
+                    displayedFilters,
+                },
+            });
+    }, requestSignature // eslint-disable-line react-hooks/exhaustive-deps
+    );
+    const hideFilter = useCallback((filterName) => {
+        changeParams({
+            type: HIDE_FILTER,
+            payload: filterName,
+        });
+    }, requestSignature); // eslint-disable-line react-hooks/exhaustive-deps
+    const showFilter = useCallback((filterName, defaultValue) => {
+        changeParams({
+            type: SHOW_FILTER,
+            payload: {
+                filterName,
+                defaultValue,
+            },
+        });
+    }, requestSignature); // eslint-disable-line react-hooks/exhaustive-deps
+    return [
+        {
+            filterValues,
+            requestSignature,
+            ...query,
+            displayedFilters: displayedFilterValues,
+        },
+        {
+            changeParams,
+            setPage,
+            setPerPage,
+            setSort,
+            setFilters,
+            hideFilter,
+            showFilter,
+        },
+    ];
+};
+export const validQueryParams = [
+    'page',
+    'perPage',
+    'sort',
+    'order',
+    'filter',
+    'displayedFilters',
+];
+/**
+ * Merge list params from 2 different sources:
+ *   - the params stored in the local state
+ *   - the props passed to the List component (including the filter defaultValues)
+ */
+export const getQuery = ({ params, filterDefaultValues, sort, page, perPage, }) => {
+    const query = hasCustomParams(params)
+        ? { ...params }
+        : { filter: filterDefaultValues || {} };
+    if (!query.sort) {
+        query.sort = sort.field;
+        query.order = sort.order;
+    }
+    if (query.page == null) {
+        query.page = page;
+    }
+    if (query.perPage == null) {
+        query.perPage = perPage;
+    }
+    if (query.page == null) {
+        query.page = 1;
+    }
+    return {
+        ...query,
+        page: getNumberOrDefault(query.page, 1),
+        perPage: getNumberOrDefault(query.perPage, 10),
+    };
+};
+/**
+ * Check if user has already set custom sort, page, or filters for this list
+ *
+ * User params come from the Redux store as the params props. By default,
+ * this object is:
+ *
+ * { filter: {}, order: null, page: 1, perPage: null, sort: null }
+ *
+ * To check if the user has custom params, we must compare the params
+ * to these initial values.
+ *
+ * @param {Object} params
+ */
+export const hasCustomParams = (params) => {
+    return (params &&
+        params.filter &&
+        (Object.keys(params.filter).length > 0 ||
+            params.order != null ||
+            params.page !== 1 ||
+            params.perPage != null ||
+            params.sort != null));
+};
+export const getNumberOrDefault = (possibleNumber, defaultValue) => {
+    if (typeof possibleNumber === 'undefined') {
+        return defaultValue;
+    }
+    const parsedNumber = typeof possibleNumber === 'string'
+        ? parseInt(possibleNumber, 10)
+        : possibleNumber;
+    return isNaN(parsedNumber) ? defaultValue : parsedNumber;
+};
+const emptyObject = {};
+const defaultSort = {
+    field: 'id',
+    order: SORT_ASC,
+};
+const defaultParams = {};

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

@@ -0,0 +1,7 @@
+/**
+ * A hook 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 useSimpleFormIterator: () => import("@strato-admin/core").SimpleFormIteratorContextValue;

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

@@ -0,0 +1,15 @@
+import { useContext } from 'react';
+import { SimpleFormIteratorContext } from './SimpleFormIteratorContext';
+/**
+ * A hook 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 useSimpleFormIterator = () => {
+    const context = useContext(SimpleFormIteratorContext);
+    if (!context) {
+        throw new Error('useSimpleFormIterator must be used inside a SimpleFormIterator');
+    }
+    return context;
+};

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

@@ -0,0 +1,7 @@
+/**
+ * A hook 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 useSimpleFormIteratorItem: () => import("@strato-admin/core").SimpleFormIteratorItemContextValue;

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

@@ -0,0 +1,15 @@
+import { useContext } from 'react';
+import { SimpleFormIteratorItemContext } from './SimpleFormIteratorItemContext';
+/**
+ * A hook 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 useSimpleFormIteratorItem = () => {
+    const context = useContext(SimpleFormIteratorItemContext);
+    if (!context) {
+        throw new Error('useSimpleFormIteratorItem must be used inside a SimpleFormIteratorItem');
+    }
+    return context;
+};

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

@@ -0,0 +1,54 @@
+import * as React from 'react';
+import { ChangeEvent, ReactElement } from 'react';
+import { Identifier } from '../../types';
+import { OptionText } from '../../form/choices/useChoices';
+/**
+ * This hook provides support for suggestion creation in inputs which have choices.
+ *
+ * @param options The hook option
+ * @param {ReactElement} options.create A react element which will be rendered when users choose to create a new choice. This component must call the `useCreateSuggestionContext` hook which provides `onCancel`, `onCreate` and `filter`. See the examples.
+ * @param {React.ReactNode|string} options.createLabel Optional. The label for the choice item allowing users to create a new choice. Can be a translation key. Defaults to `ra.action.create`.
+ * @param {React.ReactNode|string} options.createItemLabel Optional. The label for the choice item allowing users to create a new choice when they already entered a filter. Can be a translation key. The function and ttranslation will receive an `item` parameter. Providing this option will turn the create label when there is no filter to be a hint (i.e. a disabled item).
+ * @param {any} options.createValue Optional. The value for the choice item allowing users to create a new choice. Defaults to `@@ra-create`.
+ * @param {any} options.createHintValue Optional. The value for the (disabled) item hinting users on how to create a new choice. Defaults to `@@ra-create-hint`.
+ * @param {String} options.filter Optional. The filter users may have already entered. Useful for autocomplete inputs for example.
+ * @param {OnCreateHandler} options.onCreate Optional. A function which will be called when users choose to create a new choice, if the `create` option wasn't provided.
+ * @param {Function} options.handleChange A function to pass to the input. Receives the same parameter as the original event handler and an additional newItem parameter if a new item was create.
+ *
+ * @returns {UseSupportCreateValue} An object with the following properties:
+ * - getCreateItem: a function which will return the label of the choice for create a new choice.
+ * - handleChange: a function which should be called when the input value changes. It will call the `onCreate` function if the value is the createValue.
+ * - createElement: a React element to render after the input. It will be rendered when users choose to create a new choice. It renders null otherwise.
+ * - getOptionDisabled: a function which should be passed to the input to disable the create choice when the filter is empty (to make it a hint).
+ */
+export declare const useSupportCreateSuggestion: (options: SupportCreateSuggestionOptions) => UseSupportCreateValue;
+export interface SupportCreateSuggestionOptions {
+    create?: ReactElement;
+    createValue?: string;
+    createHintValue?: string;
+    createLabel?: React.ReactNode;
+    createItemLabel?: string | ((filter: string) => React.ReactNode);
+    filter?: string;
+    handleChange: (value: any) => void;
+    onCreate?: OnCreateHandler;
+    optionText?: OptionText;
+}
+export interface UseSupportCreateValue {
+    createId: string;
+    createHintId: string;
+    getCreateItem: (filterValue?: string) => {
+        id: Identifier;
+        [key: string]: any;
+    };
+    handleChange: (eventOrValue: ChangeEvent | any) => Promise<void>;
+    createElement: ReactElement | null;
+    getOptionDisabled: (option: any) => boolean;
+}
+interface CreateSuggestionContextValue {
+    filter?: string;
+    onCreate: (choice: any) => void;
+    onCancel: () => void;
+}
+export declare const useCreateSuggestionContext: () => CreateSuggestionContextValue;
+export type OnCreateHandler = (filter?: string) => any | Promise<any>;
+export {};

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

@@ -0,0 +1,90 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, isValidElement, useContext, useRef, useState, } from 'react';
+import { useTranslate } from '../../i18n/useTranslate';
+import set from 'lodash/set.js';
+/**
+ * This hook provides support for suggestion creation in inputs which have choices.
+ *
+ * @param options The hook option
+ * @param {ReactElement} options.create A react element which will be rendered when users choose to create a new choice. This component must call the `useCreateSuggestionContext` hook which provides `onCancel`, `onCreate` and `filter`. See the examples.
+ * @param {React.ReactNode|string} options.createLabel Optional. The label for the choice item allowing users to create a new choice. Can be a translation key. Defaults to `ra.action.create`.
+ * @param {React.ReactNode|string} options.createItemLabel Optional. The label for the choice item allowing users to create a new choice when they already entered a filter. Can be a translation key. The function and ttranslation will receive an `item` parameter. Providing this option will turn the create label when there is no filter to be a hint (i.e. a disabled item).
+ * @param {any} options.createValue Optional. The value for the choice item allowing users to create a new choice. Defaults to `@@ra-create`.
+ * @param {any} options.createHintValue Optional. The value for the (disabled) item hinting users on how to create a new choice. Defaults to `@@ra-create-hint`.
+ * @param {String} options.filter Optional. The filter users may have already entered. Useful for autocomplete inputs for example.
+ * @param {OnCreateHandler} options.onCreate Optional. A function which will be called when users choose to create a new choice, if the `create` option wasn't provided.
+ * @param {Function} options.handleChange A function to pass to the input. Receives the same parameter as the original event handler and an additional newItem parameter if a new item was create.
+ *
+ * @returns {UseSupportCreateValue} An object with the following properties:
+ * - getCreateItem: a function which will return the label of the choice for create a new choice.
+ * - handleChange: a function which should be called when the input value changes. It will call the `onCreate` function if the value is the createValue.
+ * - createElement: a React element to render after the input. It will be rendered when users choose to create a new choice. It renders null otherwise.
+ * - getOptionDisabled: a function which should be passed to the input to disable the create choice when the filter is empty (to make it a hint).
+ */
+export const useSupportCreateSuggestion = (options) => {
+    const { create, createLabel = "strato.action.create', createItemLabel, createValue = '@@ra-create', createHintValue = '@@ra-create-hint', optionText = 'name', filter, handleChange, onCreate, } = options;
+    const translate = useTranslate();
+    const [renderOnCreate, setRenderOnCreate] = useState(false);
+    const filterRef = useRef(filter);
+    return {
+        createId: createValue,
+        createHintId: createHintValue,
+        getCreateItem: (filter) => {
+            filterRef.current = filter;
+            return set({
+                id: createItemLabel && !filter
+                    ? createHintValue
+                    : createValue,
+            }, typeof optionText === 'string' ? optionText : 'name', filter && createItemLabel
+                ? typeof createItemLabel === 'string'
+                    ? translate(createItemLabel, {
+                        item: filter,
+                        _: createItemLabel,
+                    })
+                    : createItemLabel(filter)
+                : typeof createLabel === 'string'
+                    ? translate(createLabel, { _: createLabel })
+                    : createLabel);
+        },
+        handleChange: async (eventOrValue) => {
+            const value = eventOrValue?.target?.value || eventOrValue;
+            const finalValue = Array.isArray(value) ? [...value].pop() : value;
+            if (finalValue?.id === createValue || finalValue === createValue) {
+                if (!isValidElement(create)) {
+                    if (!onCreate) {
+                        // this should never happen because the createValue is only added if a create function is provided
+                        // @see AutocompleteInput:filterOptions
+                        throw new Error('To create a new option, you must pass an onCreate function or a create element.');
+                    }
+                    const newSuggestion = await onCreate(filter);
+                    if (newSuggestion) {
+                        handleChange(newSuggestion);
+                        return;
+                    }
+                }
+                else {
+                    setRenderOnCreate(true);
+                    return;
+                }
+            }
+            handleChange(eventOrValue);
+        },
+        createElement: renderOnCreate && isValidElement(create) ? (_jsx(CreateSuggestionContext.Provider, { value: {
+                filter: filterRef.current,
+                onCancel: () => setRenderOnCreate(false),
+                onCreate: item => {
+                    setRenderOnCreate(false);
+                    handleChange(item);
+                },
+            }, children: create })) : null,
+        getOptionDisabled: option => option?.id === createHintValue || option === createHintValue,
+    };
+};
+const CreateSuggestionContext = createContext(undefined);
+export const useCreateSuggestionContext = () => {
+    const context = useContext(CreateSuggestionContext);
+    if (!context) {
+        throw new Error('useCreateSuggestionContext must be used inside a CreateSuggestionContext.Provider');
+    }
+    return context;
+};

package/dist/ra-core/src/controller/list/FilterContext.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+export type FilterContextType = React.ReactNode[] | undefined;
+/**
+ * Make filters accessible to sub components
+ */
+export declare const FilterContext: React.Context<FilterContextType>;

package/dist/ra-core/src/controller/list/FilterContext.js

@@ -0,0 +1,5 @@
+import * as React from 'react';
+/**
+ * Make filters accessible to sub components
+ */
+export const FilterContext = React.createContext(undefined);

package/dist/ra-core/src/controller/list/InfiniteListBase.d.ts

@@ -0,0 +1,47 @@
+import { ReactNode } from 'react';
+import { InfiniteListControllerProps, InfiniteListControllerResult } from './useInfiniteListController';
+import { RaRecord } from '../../types';
+/**
+ * Call useInfiniteListController and put the value in a ListContext
+ *
+ * Base class for <InfiniteList> components, without UI.
+ *
+ * Accepts any props accepted by useInfiniteListController:
+ * - filter: permanent filter applied to the list
+ * - filters: Filter element, to display the filters
+ * - filterDefaultValues: object;
+ * - perPage: Number of results per page
+ * - sort: Default sort
+ * - exporter: exported function
+ *
+ * @example // Custom list layout
+ *
+ * const PostList = () => (
+ *     <InfiniteListBase perPage={10}>
+ *         <div>
+ *              List metrics...
+ *         </div>
+ *         <Grid container>
+ *             <Grid item xs={8}>
+ *                 <SimpleList primaryText={record => record.title} />
+ *             </Grid>
+ *             <Grid item xs={4}>
+ *                 List instructions...
+ *             </Grid>
+ *         </Grid>
+ *         <div>
+ *             Post related links...
+ *         </div>
+ *     </ListBase>
+ * );
+ */
+export declare const InfiniteListBase: <RecordType extends RaRecord = any>({ authLoading, loading, offline, error, empty, children, render, ...props }: InfiniteListBaseProps<RecordType>) => import("react/jsx-runtime").JSX.Element;
+export interface InfiniteListBaseProps<RecordType extends RaRecord = any> extends InfiniteListControllerProps<RecordType> {
+    authLoading?: ReactNode;
+    loading?: ReactNode;
+    offline?: ReactNode;
+    error?: ReactNode;
+    empty?: ReactNode;
+    children?: ReactNode;
+    render?: (props: InfiniteListControllerResult<RecordType>) => ReactNode;
+}

package/dist/ra-core/src/controller/list/InfiniteListBase.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useInfiniteListController, } from './useInfiniteListController';
+import { OptionalResourceContextProvider } from '../../core';
+import { ListContextProvider } from './ListContextProvider';
+import { InfinitePaginationContext } from './InfinitePaginationContext';
+import { useIsAuthPending } from '../../auth';
+/**
+ * Call useInfiniteListController and put the value in a ListContext
+ *
+ * Base class for <InfiniteList> components, without UI.
+ *
+ * Accepts any props accepted by useInfiniteListController:
+ * - filter: permanent filter applied to the list
+ * - filters: Filter element, to display the filters
+ * - filterDefaultValues: object;
+ * - perPage: Number of results per page
+ * - sort: Default sort
+ * - exporter: exported function
+ *
+ * @example // Custom list layout
+ *
+ * const PostList = () => (
+ *     <InfiniteListBase perPage={10}>
+ *         <div>
+ *              List metrics...
+ *         </div>
+ *         <Grid container>
+ *             <Grid item xs={8}>
+ *                 <SimpleList primaryText={record => record.title} />
+ *             </Grid>
+ *             <Grid item xs={4}>
+ *                 List instructions...
+ *             </Grid>
+ *         </Grid>
+ *         <div>
+ *             Post related links...
+ *         </div>
+ *     </ListBase>
+ * );
+ */
+export const InfiniteListBase = ({ authLoading, loading, offline, error, empty, children, render, ...props }) => {
+    const controllerProps = useInfiniteListController(props);
+    const isAuthPending = useIsAuthPending({
+        resource: controllerProps.resource,
+        action: 'list',
+    });
+    if (!render && !children) {
+        throw new Error("<InfiniteListBase> requires either a 'render' prop or 'children' prop");
+    }
+    const { isPaused, isPending, isPlaceholderData, error: errorState, data, total, hasPreviousPage, hasNextPage, filterValues, } = controllerProps;
+    const showAuthLoading = isAuthPending &&
+        !props.disableAuthentication &&
+        authLoading !== false &&
+        authLoading !== undefined;
+    const showLoading = !isPaused &&
+        ((!props.disableAuthentication && isAuthPending) || isPending) &&
+        loading !== false &&
+        loading !== undefined;
+    const showOffline = isPaused &&
+        // If isPending and isPaused are true, we are offline and couldn't even load the initial data
+        // If isPaused and isPlaceholderData are true, we are offline and couldn't even load data with different parameters on the same useQuery observer
+        (isPending || isPlaceholderData) &&
+        offline !== false &&
+        offline !== undefined;
+    const showError = errorState && error !== false && error !== undefined;
+    const showEmpty = !errorState &&
+        // the list is not loading data for the first time
+        !isPending &&
+        // the API returned no data (using either normal or partial pagination)
+        (total === 0 ||
+            (total == null &&
+                hasPreviousPage === false &&
+                hasNextPage === false &&
+                // @ts-ignore FIXME total may be undefined when using partial pagination but the ListControllerResult type is wrong about it
+                data.length === 0)) &&
+        // the user didn't set any filters
+        !Object.keys(filterValues).length &&
+        // there is an empty page component
+        empty !== undefined &&
+        empty !== false;
+    return (
+    // We pass props.resource here as we don't need to create a new ResourceContext if the props is not provided
+    _jsx(OptionalResourceContextProvider, { value: props.resource, children: _jsx(ListContextProvider, { value: controllerProps, children: _jsx(InfinitePaginationContext.Provider, { value: {
+                    hasNextPage: controllerProps.hasNextPage,
+                    fetchNextPage: controllerProps.fetchNextPage,
+                    isFetchingNextPage: controllerProps.isFetchingNextPage,
+                    hasPreviousPage: controllerProps.hasPreviousPage,
+                    fetchPreviousPage: controllerProps.fetchPreviousPage,
+                    isFetchingPreviousPage: controllerProps.isFetchingPreviousPage,
+                }, children: showAuthLoading
+                    ? authLoading
+                    : showLoading
+                        ? loading
+                        : showOffline
+                            ? offline
+                            : showError
+                                ? error
+                                : showEmpty
+                                    ? empty
+                                    : render
+                                        ? render(controllerProps)
+                                        : children }) }) }));
+};

package/dist/ra-core/src/controller/list/InfinitePaginationContext.d.ts

@@ -0,0 +1,25 @@
+import { InfiniteListControllerResult } from './useInfiniteListController';
+/**
+ * Context to store the pagination callbacks from the useInfiniteListController() result.
+ *
+ * Use the useInfinitePaginationContext() hook to read the pagination callbacks.
+ *
+ * @typedef {Object} InfinitePaginationContextValue
+ * @prop {Function} fetchNextPage a callback to fetch the next page
+ * @prop {Function} fetchPreviousPage a callback to fetch the previous page
+
+ * @example
+ *
+ * import { useListController, ListPaginationContext } from '@strato-admin/ra-core';
+ *
+ * const List = props => {
+ *     const { fetchNextPage, fetchPreviousPage } = useInfiniteListController(props);
+ *     return (
+ *         <InfinitePaginationContext.Provider value={{ fetchNextPage, fetchPreviousPage }}>
+ *             ...
+ *         </InfinitePaginationContext.Provider>
+ *     );
+ * };
+ */
+export declare const InfinitePaginationContext: import("react").Context<InfinitePaginationContextValue>;
+export type InfinitePaginationContextValue = Pick<InfiniteListControllerResult, 'fetchNextPage' | 'fetchPreviousPage' | 'isFetchingNextPage' | 'hasNextPage' | 'hasPreviousPage' | 'isFetchingPreviousPage'>;

package/dist/ra-core/src/controller/list/InfinitePaginationContext.js

@@ -0,0 +1,32 @@
+import { createContext } from 'react';
+/**
+ * Context to store the pagination callbacks from the useInfiniteListController() result.
+ *
+ * Use the useInfinitePaginationContext() hook to read the pagination callbacks.
+ *
+ * @typedef {Object} InfinitePaginationContextValue
+ * @prop {Function} fetchNextPage a callback to fetch the next page
+ * @prop {Function} fetchPreviousPage a callback to fetch the previous page
+
+ * @example
+ *
+ * import { useListController, ListPaginationContext } from '@strato-admin/ra-core';
+ *
+ * const List = props => {
+ *     const { fetchNextPage, fetchPreviousPage } = useInfiniteListController(props);
+ *     return (
+ *         <InfinitePaginationContext.Provider value={{ fetchNextPage, fetchPreviousPage }}>
+ *             ...
+ *         </InfinitePaginationContext.Provider>
+ *     );
+ * };
+ */
+export const InfinitePaginationContext = createContext({
+    hasNextPage: false,
+    fetchNextPage: () => Promise.reject('not implemented'),
+    isFetchingNextPage: false,
+    hasPreviousPage: false,
+    fetchPreviousPage: () => Promise.reject('not implemented'),
+    isFetchingPreviousPage: false,
+});
+InfinitePaginationContext.displayName = 'InfinitePaginationContext';