@strato-admin/core 0.1.1 → 0.3.0

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

@@ -0,0 +1,22 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useListContextWithProps } from './useListContextWithProps';
+import { RecordContextProvider } from '../record';
+export const RecordsIterator = (props) => {
+    const { children, render } = props;
+    const { data, total, isPending, error } = useListContextWithProps(props);
+    if (isPending === true ||
+        error ||
+        data == null ||
+        data.length === 0 ||
+        total === 0) {
+        return null;
+    }
+    if (!render && !children) {
+        return null;
+    }
+    return (_jsx(_Fragment, { children: data.map((record, index) => (_jsx(RecordContextProvider, { value: record, children: render ? render(record, index) : children }, record.id ?? `row${index}`))) }));
+};
+/**
+ * @deprecated use RecordsIterator instead.
+ */
+export const ListIterator = RecordsIterator;

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

@@ -0,0 +1,32 @@
+import React, { ReactNode } from 'react';
+import { RaRecord } from '../../types';
+import { ListControllerResult } from './useListController';
+/**
+ * Render prop version of useListContextWithProps
+ *
+ * @example
+ * const BookList = () => (
+ *    <List>
+ *       <WithListContext render={({ data }) => (
+ *          <ul>
+ *            {data && data.map(record => (
+ *              <li key={record.id}>{record.title}</li>
+ *            ))}
+ *          </ul>
+ *       )} />
+ *   </List>
+ * );
+ */
+export declare const WithListContext: <RecordType extends RaRecord>({ empty, loading, offline, error, render, children, ...props }: WithListContextProps<RecordType>) => React.ReactNode;
+export interface WithListContextProps<RecordType extends RaRecord> extends React.PropsWithChildren<Partial<Pick<ListControllerResult<RecordType>, 'data' | 'total' | 'isPending'>>> {
+    render?: (context: Partial<ListControllerResult<RecordType>>) => ReactNode;
+    loading?: React.ReactNode;
+    offline?: React.ReactNode;
+    errorState?: ListControllerResult<RecordType>['error'];
+    error?: React.ReactNode;
+    empty?: React.ReactNode;
+    /**
+     * @deprecated
+     */
+    label?: string;
+}

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

@@ -0,0 +1,42 @@
+import { useListContextWithProps } from './useListContextWithProps';
+/**
+ * Render prop version of useListContextWithProps
+ *
+ * @example
+ * const BookList = () => (
+ *    <List>
+ *       <WithListContext render={({ data }) => (
+ *          <ul>
+ *            {data && data.map(record => (
+ *              <li key={record.id}>{record.title}</li>
+ *            ))}
+ *          </ul>
+ *       )} />
+ *   </List>
+ * );
+ */
+export const WithListContext = ({ empty, loading, offline, error, render, children, ...props }) => {
+    const context = useListContextWithProps(props);
+    const { data, total, isPaused, isPending, isPlaceholderData, error: errorState, } = context;
+    if (!isPaused && isPending && loading !== false && loading !== undefined) {
+        return loading;
+    }
+    if (isPaused &&
+        (isPending || isPlaceholderData) &&
+        offline !== false &&
+        offline !== undefined) {
+        return offline;
+    }
+    if (errorState && error !== false && error !== undefined) {
+        return error;
+    }
+    if ((data == null || data.length === 0 || total === 0) &&
+        empty !== false &&
+        empty !== undefined) {
+        return empty;
+    }
+    if (render) {
+        return render(context);
+    }
+    return children;
+};

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

@@ -0,0 +1,30 @@
+export * from './FilterContext';
+export * from './InfiniteListBase';
+export * from './InfinitePaginationContext';
+export * from './ListBase';
+export * from './ListContext';
+export * from './ListContextProvider';
+export * from './ListController';
+export * from './ListFilterContext';
+export * from './ListPaginationContext';
+export * from './ListSortContext';
+export * from './queryReducer';
+export * from './RecordsIterator';
+export * from './useExpanded';
+export * from './useFilterContext';
+export * from './useInfiniteListController';
+export * from './useInfinitePaginationContext';
+export * from './useList';
+export * from './useListContext';
+export * from './useListContextWithProps';
+export * from './useListController';
+export * from './useListFilterContext';
+export * from './useListPaginationContext';
+export * from './useListParams';
+export * from './useListSortContext';
+export * from './useRecordSelection';
+export * from './useUnselect';
+export * from './useUnselectAll';
+export * from './useSelectAll';
+export * from './WithListContext';
+export * from './useSavedQueries';

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

@@ -0,0 +1,30 @@
+export * from './FilterContext';
+export * from './InfiniteListBase';
+export * from './InfinitePaginationContext';
+export * from './ListBase';
+export * from './ListContext';
+export * from './ListContextProvider';
+export * from './ListController';
+export * from './ListFilterContext';
+export * from './ListPaginationContext';
+export * from './ListSortContext';
+export * from './queryReducer';
+export * from './RecordsIterator';
+export * from './useExpanded';
+export * from './useFilterContext';
+export * from './useInfiniteListController';
+export * from './useInfinitePaginationContext';
+export * from './useList';
+export * from './useListContext';
+export * from './useListContextWithProps';
+export * from './useListController';
+export * from './useListFilterContext';
+export * from './useListPaginationContext';
+export * from './useListParams';
+export * from './useListSortContext';
+export * from './useRecordSelection';
+export * from './useUnselect';
+export * from './useUnselectAll';
+export * from './useSelectAll';
+export * from './WithListContext';
+export * from './useSavedQueries';

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

@@ -0,0 +1,45 @@
+import { Reducer } from 'react';
+import { ListParams } from './useListParams';
+export declare const SET_SORT = "SET_SORT";
+export declare const SORT_ASC = "ASC";
+export declare const SORT_DESC = "DESC";
+export declare const SET_PAGE = "SET_PAGE";
+export declare const SET_PER_PAGE = "SET_PER_PAGE";
+export declare const SET_FILTER = "SET_FILTER";
+export declare const SHOW_FILTER = "SHOW_FILTER";
+export declare const HIDE_FILTER = "HIDE_FILTER";
+type ActionTypes = {
+    type: typeof SET_SORT;
+    payload: {
+        field: string;
+        order?: typeof SORT_ASC | typeof SORT_DESC;
+    };
+} | {
+    type: typeof SET_PAGE;
+    payload: number;
+} | {
+    type: typeof SET_PER_PAGE;
+    payload: number;
+} | {
+    type: typeof SET_FILTER;
+    payload: {
+        filter: any;
+        displayedFilters?: {
+            [key: string]: boolean;
+        };
+    };
+} | {
+    type: typeof SHOW_FILTER;
+    payload: {
+        filterName: string;
+        defaultValue?: any;
+    };
+} | {
+    type: typeof HIDE_FILTER;
+    payload: string;
+};
+/**
+ * This reducer is for the react-router query string.
+ */
+export declare const queryReducer: Reducer<ListParams, ActionTypes>;
+export default queryReducer;

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

@@ -0,0 +1,85 @@
+import set from 'lodash/set.js';
+import removeEmpty from '../../util/removeEmpty';
+import removeKey from '../../util/removeKey';
+export const SET_SORT = 'SET_SORT';
+export const SORT_ASC = 'ASC';
+export const SORT_DESC = 'DESC';
+export const SET_PAGE = 'SET_PAGE';
+export const SET_PER_PAGE = 'SET_PER_PAGE';
+export const SET_FILTER = 'SET_FILTER';
+export const SHOW_FILTER = 'SHOW_FILTER';
+export const HIDE_FILTER = 'HIDE_FILTER';
+const oppositeOrder = direction => direction === SORT_DESC ? SORT_ASC : SORT_DESC;
+/**
+ * This reducer is for the react-router query string.
+ */
+export const queryReducer = (previousState, action) => {
+    switch (action.type) {
+        case SET_SORT:
+            if (action.payload.field === previousState.sort) {
+                return {
+                    ...previousState,
+                    order: action.payload.order ??
+                        oppositeOrder(previousState.order),
+                    page: 1,
+                };
+            }
+            return {
+                ...previousState,
+                sort: action.payload.field,
+                order: action.payload.order || SORT_ASC,
+                page: 1,
+            };
+        case SET_PAGE:
+            return { ...previousState, page: action.payload };
+        case SET_PER_PAGE:
+            return { ...previousState, page: 1, perPage: action.payload };
+        case SET_FILTER: {
+            return {
+                ...previousState,
+                page: 1,
+                filter: action.payload.filter,
+                displayedFilters: action.payload.displayedFilters
+                    ? action.payload.displayedFilters
+                    : previousState.displayedFilters,
+            };
+        }
+        case SHOW_FILTER: {
+            if (previousState.displayedFilters &&
+                previousState.displayedFilters[action.payload.filterName]) {
+                // the filter is already shown
+                return previousState;
+            }
+            return {
+                ...previousState,
+                filter: typeof action.payload.defaultValue !== 'undefined'
+                    ? set(previousState.filter, action.payload.filterName, action.payload.defaultValue)
+                    : previousState.filter,
+                // we don't use lodash.set() for displayed filters
+                // to avoid problems with compound filter names (e.g. 'author.name')
+                displayedFilters: {
+                    ...previousState.displayedFilters,
+                    [action.payload.filterName]: true,
+                },
+            };
+        }
+        case HIDE_FILTER: {
+            return {
+                ...previousState,
+                filter: removeEmpty(removeKey(previousState.filter, action.payload)),
+                // we don't use lodash.set() for displayed filters
+                // to avoid problems with compound filter names (e.g. 'author.name')
+                displayedFilters: previousState.displayedFilters
+                    ? Object.keys(previousState.displayedFilters).reduce((filters, filter) => {
+                        return filter !== action.payload
+                            ? { ...filters, [filter]: true }
+                            : filters;
+                    }, {})
+                    : previousState.displayedFilters,
+            };
+        }
+        default:
+            return previousState;
+    }
+};
+export default queryReducer;

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

@@ -0,0 +1,31 @@
+import { Identifier } from '../../types';
+/**
+ * State-like hook for controlling the expanded state of a list item
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {string|integer} id The record identifier, e.g. 123
+ * @param {boolean} single Forces only one id to be expanded at a time
+ * @returns {Object} Destructure as [expanded, toggleExpanded].
+ *
+ * @example
+ *
+ * const [expanded, toggleExpanded] = useExpanded('posts', 123);
+ * const expandIcon = expanded ? ExpandLess : ExpandMore;
+ * const onExpandClick = () => toggleExpanded();
+ */
+export declare const useExpanded: (resource: string, id: Identifier, single?: boolean) => [boolean, () => void];
+/**
+ * State-like hook for controlling the expanded state of many list items
+ * expanded state is true when at least one item from ids is expanded.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Identifier[]} ids A list of record identifiers
+ * @returns {Object} Destructure as [expanded, toggleExpanded].
+ *
+ * @example
+ *
+ * const [expanded, toggleExpanded] = useExpandAll('posts', [123, 124, 125]);
+ * const expandIcon = expanded ? ExpandLess : ExpandMore;
+ * const onExpandClick = () => toggleExpanded();
+ */
+export declare const useExpandAll: (resource: string, ids: Identifier[]) => [boolean, () => void];

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

@@ -0,0 +1,70 @@
+import { useCallback } from 'react';
+import { useStore } from '../../store';
+/**
+ * State-like hook for controlling the expanded state of a list item
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {string|integer} id The record identifier, e.g. 123
+ * @param {boolean} single Forces only one id to be expanded at a time
+ * @returns {Object} Destructure as [expanded, toggleExpanded].
+ *
+ * @example
+ *
+ * const [expanded, toggleExpanded] = useExpanded('posts', 123);
+ * const expandIcon = expanded ? ExpandLess : ExpandMore;
+ * const onExpandClick = () => toggleExpanded();
+ */
+export const useExpanded = (resource, id, single = false) => {
+    const [expandedIds, setExpandedIds] = useStore(`${resource}.datagrid.expanded`, emptyArray);
+    const expanded = Array.isArray(expandedIds)
+        ? // eslint-disable-next-line eqeqeq
+            expandedIds.map(el => el == id).indexOf(true) !== -1
+        : false;
+    const toggleExpanded = useCallback(() => {
+        setExpandedIds(ids => {
+            if (!Array.isArray(ids)) {
+                return [id];
+            }
+            const index = ids.findIndex(el => el == id); // eslint-disable-line eqeqeq
+            return index > -1
+                ? single
+                    ? []
+                    : [...ids.slice(0, index), ...ids.slice(index + 1)]
+                : single
+                    ? [id]
+                    : [...ids, id];
+        });
+    }, [setExpandedIds, id, single]);
+    return [expanded, toggleExpanded];
+};
+const emptyArray = [];
+/**
+ * State-like hook for controlling the expanded state of many list items
+ * expanded state is true when at least one item from ids is expanded.
+ *
+ * @param {string} resource The resource name, e.g. 'posts'
+ * @param {Identifier[]} ids A list of record identifiers
+ * @returns {Object} Destructure as [expanded, toggleExpanded].
+ *
+ * @example
+ *
+ * const [expanded, toggleExpanded] = useExpandAll('posts', [123, 124, 125]);
+ * const expandIcon = expanded ? ExpandLess : ExpandMore;
+ * const onExpandClick = () => toggleExpanded();
+ */
+export const useExpandAll = (resource, ids) => {
+    const [expandedIds, setExpandedIds] = useStore(`${resource}.datagrid.expanded`, []);
+    const isExpanded = Array.isArray(expandedIds)
+        ? // eslint-disable-next-line eqeqeq
+            expandedIds.some(id => ids.some(id2 => id2 == id))
+        : false;
+    const toggleExpandedAll = useCallback(() => {
+        const unaffectedExpandedIds = expandedIds.filter(
+        // eslint-disable-next-line eqeqeq
+        expanded_id => !ids.some(id => id == expanded_id));
+        setExpandedIds(isExpanded
+            ? unaffectedExpandedIds
+            : unaffectedExpandedIds.concat(ids));
+    }, [expandedIds, setExpandedIds, isExpanded, ids]);
+    return [isExpanded, toggleExpandedAll];
+};

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

@@ -0,0 +1,2 @@
+import { type FilterContextType } from './FilterContext';
+export declare const useFilterContext: () => FilterContextType;

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

@@ -0,0 +1,5 @@
+import { useContext } from 'react';
+import { FilterContext } from './FilterContext';
+export const useFilterContext = () => {
+    return useContext(FilterContext);
+};

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

@@ -0,0 +1,44 @@
+import type { InfiniteQueryObserverBaseResult, InfiniteData } from '@tanstack/react-query';
+import type { UseInfiniteGetListOptions } from '../../dataProvider';
+import type { ListControllerResult } from './useListController';
+import type { RaRecord, SortPayload, FilterPayload, Exporter, GetInfiniteListResult } from '../../types';
+/**
+ * Prepare data for the InfiniteList view
+ *
+ * @param {Object} props The props passed to the InfiniteList component.
+ *
+ * @return {Object} controllerProps Fetched and computed data for the List view
+ *
+ * @example
+ *
+ * import { useInfiniteListController } from 'react-admin';
+ * import ListView from './ListView';
+ *
+ * const MyList = props => {
+ *     const controllerProps = useInfiniteListController(props);
+ *     return <ListView {...controllerProps} {...props} />;
+ * }
+ */
+export declare const useInfiniteListController: <RecordType extends RaRecord = any, ErrorType = Error>(props?: InfiniteListControllerProps<RecordType, ErrorType>) => InfiniteListControllerResult<RecordType, ErrorType>;
+export interface InfiniteListControllerProps<RecordType extends RaRecord = any, ErrorType = Error> {
+    debounce?: number;
+    disableAuthentication?: boolean;
+    /**
+     * Whether to disable the synchronization of the list parameters with the current location (URL search parameters)
+     */
+    disableSyncWithLocation?: boolean;
+    exporter?: Exporter | false;
+    filter?: FilterPayload;
+    filterDefaultValues?: object;
+    perPage?: number;
+    queryOptions?: UseInfiniteGetListOptions<RecordType, ErrorType>;
+    resource?: string;
+    sort?: SortPayload;
+    storeKey?: string | false;
+}
+export type InfiniteListControllerResult<RecordType extends RaRecord = any, ErrorType = Error> = ListControllerResult<RecordType> & {
+    fetchNextPage: InfiniteQueryObserverBaseResult<InfiniteData<GetInfiniteListResult<RecordType>>, ErrorType>['fetchNextPage'];
+    fetchPreviousPage: InfiniteQueryObserverBaseResult<InfiniteData<GetInfiniteListResult<RecordType>>, ErrorType>['fetchPreviousPage'];
+    isFetchingNextPage: InfiniteQueryObserverBaseResult<InfiniteData<GetInfiniteListResult<RecordType>>, ErrorType>['isFetchingNextPage'];
+    isFetchingPreviousPage: InfiniteQueryObserverBaseResult<InfiniteData<GetInfiniteListResult<RecordType>>, ErrorType>['isFetchingPreviousPage'];
+};

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

@@ -0,0 +1,175 @@
+import { isValidElement, useCallback, useEffect, useMemo } from 'react';
+import { useAuthenticated, useRequireAccess } from '../../auth';
+import { useTranslate } from '../../i18n';
+import { useNotify } from '../../notification';
+import { useDataProvider, useInfiniteGetList } from '../../dataProvider';
+import { defaultExporter } from '../../export';
+import { useResourceContext, useGetResourceLabel } from '../../core';
+import { useRecordSelection } from './useRecordSelection';
+import { useListParams } from './useListParams';
+import { useSelectAll } from './useSelectAll';
+import { useEvent } from '../../util';
+/**
+ * Prepare data for the InfiniteList view
+ *
+ * @param {Object} props The props passed to the InfiniteList component.
+ *
+ * @return {Object} controllerProps Fetched and computed data for the List view
+ *
+ * @example
+ *
+ * import { useInfiniteListController } from 'react-admin';
+ * import ListView from './ListView';
+ *
+ * const MyList = props => {
+ *     const controllerProps = useInfiniteListController(props);
+ *     return <ListView {...controllerProps} {...props} />;
+ * }
+ */
+export const useInfiniteListController = (props = {}) => {
+    const { debounce = 500, disableAuthentication = false, disableSyncWithLocation = false, exporter = defaultExporter, filter, filterDefaultValues, perPage = 10, queryOptions, sort, storeKey, } = props;
+    const resource = useResourceContext(props);
+    const { meta, ...otherQueryOptions } = queryOptions ?? {};
+    if (!resource) {
+        throw new Error(`<InfiniteList> was called outside of a ResourceContext and without a resource prop. You must set the resource prop.`);
+    }
+    if (filter && isValidElement(filter)) {
+        throw new Error('<InfiniteList> received a React element as `filter` props. If you intended to set the list filter elements, use the `filters` (with an s) prop instead. The `filter` prop is internal and should not be set by the developer.');
+    }
+    const { isPending: isPendingAuthenticated } = useAuthenticated({
+        enabled: !disableAuthentication,
+    });
+    const { isPending: isPendingCanAccess } = useRequireAccess({
+        action: 'list',
+        resource,
+        enabled: !disableAuthentication && !isPendingAuthenticated,
+    });
+    const translate = useTranslate();
+    const notify = useNotify();
+    const dataProvider = useDataProvider();
+    const [query, queryModifiers] = useListParams({
+        debounce,
+        disableSyncWithLocation,
+        filterDefaultValues,
+        perPage,
+        resource,
+        sort,
+        storeKey,
+    });
+    const [selectedIds, selectionModifiers] = useRecordSelection({ resource });
+    const onUnselectItems = useCallback((fromAllStoreKeys) => {
+        return selectionModifiers.unselect(selectedIds, fromAllStoreKeys);
+    }, [selectedIds, selectionModifiers]);
+    const { data, total, error, isLoading, isPaused, isPending, isPlaceholderData, isFetching, hasNextPage, hasPreviousPage, fetchNextPage, isFetchingNextPage, fetchPreviousPage, isFetchingPreviousPage, refetch, meta: responseMeta, } = useInfiniteGetList(resource, {
+        pagination: {
+            page: query.page,
+            perPage: query.perPage,
+        },
+        sort: { field: query.sort, order: query.order },
+        filter: { ...query.filter, ...filter },
+        meta,
+    }, {
+        enabled: (!isPendingAuthenticated && !isPendingCanAccess) ||
+            disableAuthentication,
+        placeholderData: previousData => previousData,
+        retry: false,
+        onError: error => notify(error?.message || "strato.notification.http_error', {
+            type: 'error',
+            messageArgs: {
+                _: error?.message,
+            },
+        }),
+        ...otherQueryOptions,
+    });
+    const onSelectAll = useSelectAll({
+        resource,
+        sort: { field: query.sort, order: query.order },
+        filter: { ...query.filter, ...filter },
+    });
+    // change page if there is no data
+    useEffect(() => {
+        if (query.page <= 0 ||
+            (!isFetching &&
+                query.page > 1 &&
+                (data == null || data?.pages.length === 0))) {
+            // Query for a page that doesn't exist, set page to 1
+            queryModifiers.setPage(1);
+            return;
+        }
+        if (total == null) {
+            return;
+        }
+        const totalPages = Math.ceil(total / query.perPage) || 1;
+        if (!isFetching && query.page > totalPages) {
+            // Query for a page out of bounds, set page to the last existing page
+            // It occurs when deleting the last element of the last page
+            queryModifiers.setPage(totalPages);
+        }
+    }, [isFetching, query.page, query.perPage, data, queryModifiers, total]);
+    const currentSort = useMemo(() => ({
+        field: query.sort,
+        order: query.order,
+    }), [query.sort, query.order]);
+    const getResourceLabel = useGetResourceLabel();
+    const defaultTitle = translate(`resources.${resource}.page.list`, {
+        _: translate("strato.page.list', {
+            name: getResourceLabel(resource, 2),
+        }),
+    });
+    const unwrappedData = useMemo(() => data?.pages?.reduce((acc, page) => [...acc, ...page.data], []), [data]);
+    const getData = useEvent(async ({ maxResults, meta: metaOverride } = {}) => {
+        if (total === 0) {
+            return [];
+        }
+        const limit = maxResults ?? (total != null ? total : DEFAULT_MAX_RESULTS);
+        const { data } = await dataProvider.getList(resource, {
+            sort: currentSort,
+            filter: filter
+                ? { ...query.filterValues, ...filter }
+                : query.filterValues,
+            pagination: { page: 1, perPage: limit },
+            meta: metaOverride ?? meta,
+        });
+        return data;
+    });
+    return {
+        sort: currentSort,
+        data: unwrappedData,
+        defaultTitle,
+        displayedFilters: query.displayedFilters,
+        error,
+        exporter,
+        filter,
+        filterValues: query.filterValues,
+        hideFilter: queryModifiers.hideFilter,
+        isFetching,
+        isLoading,
+        isPaused,
+        isPending,
+        isPlaceholderData,
+        onSelect: selectionModifiers.select,
+        onSelectAll,
+        onToggleItem: selectionModifiers.toggle,
+        onUnselectItems,
+        page: query.page,
+        perPage: query.perPage,
+        refetch,
+        resource,
+        selectedIds,
+        setFilters: queryModifiers.setFilters,
+        setPage: queryModifiers.setPage,
+        setPerPage: queryModifiers.setPerPage,
+        setSort: queryModifiers.setSort,
+        showFilter: queryModifiers.showFilter,
+        total: total,
+        hasNextPage,
+        hasPreviousPage,
+        fetchNextPage,
+        isFetchingNextPage,
+        fetchPreviousPage,
+        isFetchingPreviousPage,
+        meta: responseMeta,
+        getData,
+    };
+};
+const DEFAULT_MAX_RESULTS = 1000;

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

@@ -0,0 +1,16 @@
+import { InfinitePaginationContextValue } from './InfinitePaginationContext';
+/**
+ * Hook to read the infinite pagination callbacks from the InfinitePaginationContext.
+ *
+ * Must be used within a <InfinitePaginationContext.Provider> (e.g. as a descendent of <InfiniteList>
+ * or <InfiniteListBase>).
+ *
+ * @typedef {Object} InfinitePaginationContextValue
+ * @prop {Function} fetchNextPage a callback to fetch the next page
+ * @prop {Function} fetchPreviousPage a callback to fetch the previous page
+ *
+ * @returns {InfinitePaginationContextValue} infinite pagination callbacks
+ *
+ * @see useInfiniteListController for how the callbacks are built
+ */
+export declare const useInfinitePaginationContext: () => InfinitePaginationContextValue;

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

@@ -0,0 +1,17 @@
+import { useContext } from 'react';
+import { InfinitePaginationContext, } from './InfinitePaginationContext';
+/**
+ * Hook to read the infinite pagination callbacks from the InfinitePaginationContext.
+ *
+ * Must be used within a <InfinitePaginationContext.Provider> (e.g. as a descendent of <InfiniteList>
+ * or <InfiniteListBase>).
+ *
+ * @typedef {Object} InfinitePaginationContextValue
+ * @prop {Function} fetchNextPage a callback to fetch the next page
+ * @prop {Function} fetchPreviousPage a callback to fetch the previous page
+ *
+ * @returns {InfinitePaginationContextValue} infinite pagination callbacks
+ *
+ * @see useInfiniteListController for how the callbacks are built
+ */
+export const useInfinitePaginationContext = () => useContext(InfinitePaginationContext);