@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

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);

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

@@ -0,0 +1,55 @@
+import { Exporter, FilterPayload, RaRecord, SortPayload } from '../../types';
+import { ListControllerResult } from './useListController';
+/**
+ * Handle filtering, sorting and pagination on local data.
+ *
+ * Returns the data and callbacks expected by <ListContext>.
+ *
+ * @example
+ * const data = [
+ *     { id: 1, name: 'Arnold' },
+ *     { id: 2, name: 'Sylvester' },
+ *     { id: 3, name: 'Jean-Claude' },
+ * ]
+ *
+ * const MyComponent = () => {
+ *     const listContext = useList({ data });
+ *     return (
+ *         <ListContextProvider value={listContext}>
+ *             <Datagrid>
+ *                 <TextField source="id" />
+ *                 <TextField source="name" />
+ *             </Datagrid>
+ *         </ListContextProvider>
+ *     );
+ * };
+ *
+ * @param {UseListOptions} props
+ * @param {RaRecord[]} props.data An array of records
+ * @param {Boolean} props.isFetching: Optional. A boolean indicating whether the data is being loaded
+ * @param {Boolean} props.isLoading: Optional. A boolean indicating whether the data has been loaded at least once
+ * @param {Error | String} props.error: Optional. The error if any occurred while loading the data
+ * @param {Object} props.filter: Optional. An object containing the filters applied on the data
+ * @param {Number} props.page: Optional. The initial page index
+ * @param {Number} props.perPage: Optional. The initial page size
+ * @param {SortPayload} props.sort: Optional. The initial sort (field and order)
+ * @param {filterCallback} prop.filterCallback Optional. A function that allows you to make a custom filter
+ */
+export declare const useList: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseListOptions<RecordType, ErrorType>) => UseListValue<RecordType, ErrorType>;
+export interface UseListOptions<RecordType extends RaRecord = any, ErrorType = Error> {
+    data?: RecordType[];
+    error?: ErrorType | null;
+    filter?: FilterPayload;
+    isFetching?: boolean;
+    isLoading?: boolean;
+    isPaused?: boolean;
+    isPending?: boolean;
+    isPlaceholderData?: boolean;
+    page?: number;
+    perPage?: number;
+    sort?: SortPayload;
+    resource?: string;
+    filterCallback?: (record: RecordType) => boolean;
+    exporter?: Exporter<RecordType> | false;
+}
+export type UseListValue<RecordType extends RaRecord = any, ErrorType = Error> = ListControllerResult<RecordType, ErrorType>;

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

@@ -0,0 +1,223 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import get from 'lodash/get.js';
+import isEqual from 'lodash/isEqual.js';
+import { removeEmpty } from '../../util';
+import { useResourceContext } from '../../core';
+import usePaginationState from '../usePaginationState';
+import useSortState from '../useSortState';
+import { useRecordSelection } from './useRecordSelection';
+import { flattenObject } from '../../dataProvider/fetch';
+import { defaultExporter } from '../../export';
+const refetch = () => {
+    throw new Error('refetch is not available for a ListContext built from useList based on local data');
+};
+/**
+ * Handle filtering, sorting and pagination on local data.
+ *
+ * Returns the data and callbacks expected by <ListContext>.
+ *
+ * @example
+ * const data = [
+ *     { id: 1, name: 'Arnold' },
+ *     { id: 2, name: 'Sylvester' },
+ *     { id: 3, name: 'Jean-Claude' },
+ * ]
+ *
+ * const MyComponent = () => {
+ *     const listContext = useList({ data });
+ *     return (
+ *         <ListContextProvider value={listContext}>
+ *             <Datagrid>
+ *                 <TextField source="id" />
+ *                 <TextField source="name" />
+ *             </Datagrid>
+ *         </ListContextProvider>
+ *     );
+ * };
+ *
+ * @param {UseListOptions} props
+ * @param {RaRecord[]} props.data An array of records
+ * @param {Boolean} props.isFetching: Optional. A boolean indicating whether the data is being loaded
+ * @param {Boolean} props.isLoading: Optional. A boolean indicating whether the data has been loaded at least once
+ * @param {Error | String} props.error: Optional. The error if any occurred while loading the data
+ * @param {Object} props.filter: Optional. An object containing the filters applied on the data
+ * @param {Number} props.page: Optional. The initial page index
+ * @param {Number} props.perPage: Optional. The initial page size
+ * @param {SortPayload} props.sort: Optional. The initial sort (field and order)
+ * @param {filterCallback} prop.filterCallback Optional. A function that allows you to make a custom filter
+ */
+export const useList = (props) => {
+    const { data, error, filter = defaultFilter, isFetching = false, isLoading = false, isPaused = false, isPending = false, isPlaceholderData = false, page: initialPage = 1, perPage: initialPerPage = 1000, sort: initialSort, filterCallback = defaultFilterCallback, exporter = defaultExporter, } = props;
+    const resource = useResourceContext(props);
+    const [finalItems, setFinalItems] = useState(() => ({
+        data,
+        total: data ? data.length : undefined,
+    }));
+    // 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
+        ? {
+            resource,
+        }
+        : { disableSyncWithStore: true });
+    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 => removeEmpty({
+            ...previousState,
+            [filterName]: defaultValue,
+        }));
+    }, [setDisplayedFilters, setFilterValues]);
+    const setFilters = useCallback((filters, displayedFilters = undefined) => {
+        setFilterValues(removeEmpty(filters));
+        if (displayedFilters) {
+            setDisplayedFilters(displayedFilters);
+        }
+        setPage(1);
+    }, [setDisplayedFilters, setFilterValues, setPage]);
+    // handle filter prop change
+    useEffect(() => {
+        if (!isEqual(filter, filterRef.current)) {
+            filterRef.current = filter;
+            setFilterValues(filter);
+        }
+    }, [filter]);
+    const applyFilterAndSort = useCallback((records) => {
+        let tempData = records;
+        if (filterValues) {
+            const flattenFilterValues = flattenObject(filterValues);
+            tempData = records
+                .filter(record => Object.entries(flattenFilterValues).every(([filterName, filterValue]) => {
+                const recordValue = get(record, filterName);
+                const result = Array.isArray(recordValue)
+                    ? Array.isArray(filterValue)
+                        ? recordValue.some(item => filterValue.includes(item))
+                        : recordValue.includes(filterValue)
+                    : Array.isArray(filterValue)
+                        ? filterValue.includes(recordValue)
+                        : filterName === 'q' // special full-text filter
+                            ? Object.keys(record).some(key => typeof record[key] ===
+                                'string' &&
+                                record[key]
+                                    .toLowerCase()
+                                    .includes(filterValue.toLowerCase()))
+                            : filterValue == recordValue; // eslint-disable-line eqeqeq
+                return result;
+            }))
+                .filter(filterCallback);
+        }
+        if (sort.field) {
+            tempData = tempData.sort((a, b) => {
+                if (get(a, sort.field) > get(b, sort.field)) {
+                    return sort.order === 'ASC' ? 1 : -1;
+                }
+                if (get(a, sort.field) < get(b, sort.field)) {
+                    return sort.order === 'ASC' ? -1 : 1;
+                }
+                return 0;
+            });
+        }
+        return tempData;
+    }, [filterValues, filterCallback, sort.field, sort.order]);
+    // We do all the data processing (filtering, sorting, paginating) client-side
+    useEffect(() => {
+        if (isPending || !data)
+            return;
+        const filteredAndSorted = applyFilterAndSort(data);
+        const filteredLength = filteredAndSorted.length;
+        const paginatedData = filteredAndSorted.slice((page - 1) * perPage, page * perPage);
+        setFinalItems({
+            data: paginatedData,
+            total: filteredLength,
+        });
+    }, // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        JSON.stringify(data),
+        applyFilterAndSort,
+        isPending,
+        page,
+        perPage,
+        setFinalItems,
+    ]);
+    const onSelectAll = useCallback(() => {
+        const allIds = data?.map(({ id }) => id) || [];
+        selectionModifiers.select(allIds);
+    }, [data, selectionModifiers]);
+    const getData = useCallback(async ({ maxResults } = {}) => {
+        if (isPending || !data) {
+            return [];
+        }
+        const filteredAndSorted = applyFilterAndSort(data);
+        if (maxResults != null) {
+            return filteredAndSorted.slice(0, maxResults);
+        }
+        return filteredAndSorted;
+    }, [applyFilterAndSort, data, isPending]);
+    return {
+        sort,
+        data: isPending ? undefined : finalItems?.data ?? [],
+        defaultTitle: '',
+        error: error ?? null,
+        displayedFilters,
+        exporter,
+        filterValues,
+        hasNextPage: finalItems?.total == null
+            ? false
+            : page * perPage < finalItems.total,
+        hasPreviousPage: page > 1,
+        hideFilter,
+        isFetching,
+        isLoading,
+        isPaused,
+        isPending,
+        isPlaceholderData,
+        onSelect: selectionModifiers.select,
+        onSelectAll,
+        onToggleItem: selectionModifiers.toggle,
+        onUnselectItems,
+        page,
+        perPage,
+        resource: '',
+        refetch,
+        selectedIds,
+        setFilters,
+        setPage,
+        setPerPage,
+        setSort,
+        showFilter,
+        total: finalItems?.total,
+        getData,
+    };
+};
+const defaultFilter = {};
+const defaultFilterCallback = (record) => Boolean(record);

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

@@ -0,0 +1,59 @@
+import { ListControllerResult } from './useListController';
+import { RaRecord } from '../../types';
+/**
+ * Hook to read the list controller props from the ListContext.
+ *
+ * Used within a <ListContextProvider> (e.g. as a descendent of <List>).
+ *
+ * @returns {ListControllerResult} list controller props
+ *
+ * @see useListController for how it is filled
+ *
+ * @example // custom list view
+ *
+ * import { useListContext } from 'react-admin';
+ *
+ * const MyList = () => {
+ *     const { data, isPending } = useListContext();
+ *     if (isPending) {
+ *         return <>Loading...</>;
+ *     }
+ *     return (
+ *         <ul>
+ *             {data.map(record => (
+ *                 <li key={record.id}>{record.name}</li>
+ *             ))}
+ *         </ul>
+ *     );
+ * }
+ *
+ * @example // custom pagination
+ *
+ * import { useListContext } from 'react-admin';
+ * import { Button, Toolbar } from '@mui/material';
+ * import ChevronLeft from '@mui/icons-material/ChevronLeft';
+ * import ChevronRight from '@mui/icons-material/ChevronRight';
+ *
+ * const PrevNextPagination = () => {
+ *     const { page, perPage, total, setPage } = useListContext();
+ *     const nbPages = Math.ceil(total / perPage) || 1;
+ *     return (
+ *         nbPages > 1 &&
+ *             <Toolbar>
+ *                 {page > 1 &&
+ *                     <Button color="primary" key="prev" onClick={() => setPage(page - 1)}>
+ *                         <ChevronLeft />
+ *                         Prev
+ *                     </Button>
+ *                 }
+ *                 {page !== nbPages &&
+ *                     <Button color="primary" key="next" onClick={() => setPage(page + 1)}>
+ *                         Next
+ *                         <ChevronRight />
+ *                     </Button>
+ *                 }
+ *             </Toolbar>
+ *     );
+ * }
+ */
+export declare const useListContext: <RecordType extends RaRecord = any, ErrorType = Error>() => ListControllerResult<RecordType, ErrorType>;

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

@@ -0,0 +1,65 @@
+import { useContext } from 'react';
+import { ListContext } from './ListContext';
+/**
+ * Hook to read the list controller props from the ListContext.
+ *
+ * Used within a <ListContextProvider> (e.g. as a descendent of <List>).
+ *
+ * @returns {ListControllerResult} list controller props
+ *
+ * @see useListController for how it is filled
+ *
+ * @example // custom list view
+ *
+ * import { useListContext } from 'react-admin';
+ *
+ * const MyList = () => {
+ *     const { data, isPending } = useListContext();
+ *     if (isPending) {
+ *         return <>Loading...</>;
+ *     }
+ *     return (
+ *         <ul>
+ *             {data.map(record => (
+ *                 <li key={record.id}>{record.name}</li>
+ *             ))}
+ *         </ul>
+ *     );
+ * }
+ *
+ * @example // custom pagination
+ *
+ * import { useListContext } from 'react-admin';
+ * import { Button, Toolbar } from '@mui/material';
+ * import ChevronLeft from '@mui/icons-material/ChevronLeft';
+ * import ChevronRight from '@mui/icons-material/ChevronRight';
+ *
+ * const PrevNextPagination = () => {
+ *     const { page, perPage, total, setPage } = useListContext();
+ *     const nbPages = Math.ceil(total / perPage) || 1;
+ *     return (
+ *         nbPages > 1 &&
+ *             <Toolbar>
+ *                 {page > 1 &&
+ *                     <Button color="primary" key="prev" onClick={() => setPage(page - 1)}>
+ *                         <ChevronLeft />
+ *                         Prev
+ *                     </Button>
+ *                 }
+ *                 {page !== nbPages &&
+ *                     <Button color="primary" key="next" onClick={() => setPage(page + 1)}>
+ *                         Next
+ *                         <ChevronRight />
+ *                     </Button>
+ *                 }
+ *             </Toolbar>
+ *     );
+ * }
+ */
+export const useListContext = () => {
+    const context = useContext(ListContext);
+    if (!context) {
+        throw new Error('useListContext must be used inside a ListContextProvider');
+    }
+    return context;
+};

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

@@ -0,0 +1,44 @@
+import { ListControllerResult } from './useListController';
+import { RaRecord } from '../../types';
+/**
+ * Hook to read the list controller props from the ListContext.
+ *
+ * Mostly used within a <ListContext.Provider> (e.g. as a descendent of <List>
+ * or <ListBase>).
+ *
+ * But you can also use it without a <ListContext.Provider>. In this case, it is up to you
+ * to pass all the necessary props (see the list below).
+ *
+ * The given props will take precedence over context values.
+ *
+ * @typedef {Object} ListControllerProps
+ * @prop {Object}   data an array of the list records, e.g. [{ id: 123, title: 'hello world' }, { ... }]
+ * @prop {integer}  total the total number of results for the current filters, excluding pagination. Useful to build the pagination controls. e.g. 23
+ * @prop {boolean}  isFetching boolean that is true on mount, and false once the data was fetched
+ * @prop {boolean}  isLoading boolean that is false until the data is available
+ * @prop {integer}  page the current page. Starts at 1
+ * @prop {Function} setPage a callback to change the page, e.g. setPage(3)
+ * @prop {integer}  perPage the number of results per page. Defaults to 25
+ * @prop {Function} setPerPage a callback to change the number of results per page, e.g. setPerPage(25)
+ * @prop {Object}   sort a sort object { field, order }, e.g. { field: 'date', order: 'DESC' }
+ * @prop {Function} setSort a callback to change the sort, e.g. setSort({ field : 'name', order: 'ASC' })
+ * @prop {Object}   filterValues a dictionary of filter values, e.g. { title: 'lorem', nationality: 'fr' }
+ * @prop {Function} setFilters a callback to update the filters, e.g. setFilters(filters, displayedFilters)
+ * @prop {Object}   displayedFilters a dictionary of the displayed filters, e.g. { title: true, nationality: true }
+ * @prop {Function} showFilter a callback to show one of the filters, e.g. showFilter('title', defaultValue)
+ * @prop {Function} hideFilter a callback to hide one of the filters, e.g. hideFilter('title')
+ * @prop {Array}    selectedIds an array listing the ids of the selected rows, e.g. [123, 456]
+ * @prop {Function} onSelect callback to change the list of selected rows, e.g. onSelect([456, 789])
+ * @prop {Function} onSelectAll callback to select all the records, e.g. onSelectAll({ limit: 50, queryOptions: { meta: { foo: 'bar' } } })
+ * @prop {Function} onToggleItem callback to toggle the selection of a given record based on its id, e.g. onToggleItem(456)
+ * @prop {Function} onUnselectItems callback to clear the selection, e.g. onUnselectItems();
+ * @prop {string}   defaultTitle the translated title based on the resource, e.g. 'Posts'
+ * @prop {string}   resource the resource name, deduced from the location. e.g. 'posts'
+ *
+ * @param {ListControllerProps} props Props passed to the useListContext hook
+ *
+ * @returns {ListControllerResult} list controller props
+ *
+ * @see useListController for how it is filled
+ */
+export declare const useListContextWithProps: <RecordType extends RaRecord = any>(props?: any) => Partial<ListControllerResult<RecordType>>;