@strato-admin/faker-ecommerce 0.1.1 → 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("./SimpleFormIteratorContext").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("./SimpleFormIteratorItemContext").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/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';

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/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'];
+};