@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

package/dist/ra-core/src/routing/useRedirect.js

@@ -0,0 +1,66 @@
+import { useCallback } from 'react';
+import { useBasename } from './useBasename';
+import { useCreatePath } from './useCreatePath';
+import { useNavigate } from './useNavigate';
+/**
+ * Hook for Redirection Side Effect
+ *
+ * @example
+ *
+ * const redirect = useRedirect();
+ * // redirect to list view
+ * redirect('list', 'posts');
+ * // redirect to edit view
+ * redirect('edit', 'posts', 123);
+ * // redirect to edit view with state data
+ * redirect('edit', 'comments', 123, {}, { record: { post_id: record.id } });
+ * // do not redirect
+ * redirect(false);
+ * // redirect to the result of a function
+ * redirect((resource, id, data) => ...)
+ * // redirect to an absolute URL
+ * redirect('https://marmelab.com/react-admin');
+ */
+export const useRedirect = () => {
+    const navigate = useNavigate();
+    const basename = useBasename();
+    const createPath = useCreatePath();
+    return useCallback((redirectTo, resource = '', id, data, state = {}) => {
+        if (!redirectTo) {
+            return;
+        }
+        else if (typeof redirectTo === 'function') {
+            const target = redirectTo(resource, id, data);
+            const absoluteTarget = typeof target === 'string'
+                ? `${basename}${target.startsWith('/') ? '' : '/'}${target}`
+                : {
+                    pathname: `${basename}${target.pathname?.startsWith('/') ? '' : '/'}${target.pathname}`,
+                    ...target,
+                };
+            navigate(absoluteTarget, {
+                state: { _scrollToTop: true, ...state },
+            });
+            return;
+        }
+        else if (typeof redirectTo === 'string' &&
+            redirectTo.startsWith('http') &&
+            window) {
+            // redirection to an absolute url
+            // history doesn't handle that case, so we handle it by hand
+            window.location.href = redirectTo;
+            return;
+        }
+        else {
+            // redirection to an internal link
+            navigate(createPath({ resource, id, type: redirectTo }), {
+                state: 
+                // We force the scrollToTop except when navigating to a list
+                // where this is already done by <RestoreScrollPosition> in <Resource>
+                redirectTo === 'list'
+                    ? state
+                    : { _scrollToTop: true, ...state },
+            });
+            return;
+        }
+    }, [navigate, basename, createPath]);
+};

package/dist/ra-core/src/routing/useResetErrorBoundaryOnLocationChange.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A hook to use inside the component passed to FallbackComponent
+ * of react-error-boundary. It resets the error boundary state whenever
+ * the location changes
+ * @param {Function} resetErrorBoundary
+ */
+export declare const useResetErrorBoundaryOnLocationChange: (resetErrorBoundary: () => void) => void;

package/dist/ra-core/src/routing/useResetErrorBoundaryOnLocationChange.js

@@ -0,0 +1,17 @@
+import { useEffect, useRef } from 'react';
+import { useLocation } from './useLocation';
+/**
+ * A hook to use inside the component passed to FallbackComponent
+ * of react-error-boundary. It resets the error boundary state whenever
+ * the location changes
+ * @param {Function} resetErrorBoundary
+ */
+export const useResetErrorBoundaryOnLocationChange = (resetErrorBoundary) => {
+    const { pathname } = useLocation();
+    const originalPathname = useRef(pathname);
+    useEffect(() => {
+        if (pathname !== originalPathname.current) {
+            resetErrorBoundary();
+        }
+    }, [pathname, resetErrorBoundary]);
+};

package/dist/ra-core/src/routing/useRestoreScrollPosition.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A hook that tracks the scroll position and restores it when the component mounts.
+ * @param storeKey The key under which to store the scroll position in the store
+ * @param debounceMs The debounce time in milliseconds
+ *
+ * @example
+ * import { useRestoreScrollPosition } from '@strato-admin/ra-core';
+ *
+ * const MyCustomPage = () => {
+ *   useRestoreScrollPosition('my-list');
+ *
+ *   return (
+ *     <div>
+ *       <h1>My Custom Page</h1>
+ *       <VeryLongContent />
+ *     </div>
+ *   );
+ * };
+ */
+export declare const useRestoreScrollPosition: (storeKey: string, debounceMs?: number) => void;
+/**
+ * A hook that tracks the scroll position and stores it.
+ * @param storeKey The key under which to store the scroll position in the store
+ * @param debounceMs The debounce time in milliseconds
+ *
+ * @example
+ * import { useTrackScrollPosition } from '@strato-admin/ra-core';
+ *
+ * const MyCustomPage = () => {
+ *   useTrackScrollPosition('my-list');
+ *
+ *   return (
+ *     <div>
+ *       <h1>My Custom Page</h1>
+ *       <VeryLongContent />
+ *     </div>
+ *   );
+ * };
+ */
+export declare const useTrackScrollPosition: (storeKey: string, debounceMs?: number) => [number | undefined, (value: number | undefined) => void];

package/dist/ra-core/src/routing/useRestoreScrollPosition.js

@@ -0,0 +1,70 @@
+import { useEffect } from 'react';
+import debounce from 'lodash/debounce.js';
+import { useStore } from '../store';
+import { useLocation } from './useLocation';
+/**
+ * A hook that tracks the scroll position and restores it when the component mounts.
+ * @param storeKey The key under which to store the scroll position in the store
+ * @param debounceMs The debounce time in milliseconds
+ *
+ * @example
+ * import { useRestoreScrollPosition } from '@strato-admin/ra-core';
+ *
+ * const MyCustomPage = () => {
+ *   useRestoreScrollPosition('my-list');
+ *
+ *   return (
+ *     <div>
+ *       <h1>My Custom Page</h1>
+ *       <VeryLongContent />
+ *     </div>
+ *   );
+ * };
+ */
+export const useRestoreScrollPosition = (storeKey, debounceMs = 250) => {
+    const [position, setPosition] = useTrackScrollPosition(storeKey, debounceMs);
+    const location = useLocation();
+    useEffect(() => {
+        if (position != null && location.state?._scrollToTop !== true) {
+            setPosition(undefined);
+            window.scrollTo(0, position);
+        }
+        // We only want to run this effect on mount
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+};
+/**
+ * A hook that tracks the scroll position and stores it.
+ * @param storeKey The key under which to store the scroll position in the store
+ * @param debounceMs The debounce time in milliseconds
+ *
+ * @example
+ * import { useTrackScrollPosition } from '@strato-admin/ra-core';
+ *
+ * const MyCustomPage = () => {
+ *   useTrackScrollPosition('my-list');
+ *
+ *   return (
+ *     <div>
+ *       <h1>My Custom Page</h1>
+ *       <VeryLongContent />
+ *     </div>
+ *   );
+ * };
+ */
+export const useTrackScrollPosition = (storeKey, debounceMs = 250) => {
+    const [position, setPosition] = useStore(storeKey);
+    useEffect(() => {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const handleScroll = debounce(() => {
+            setPosition(window.scrollY);
+        }, debounceMs);
+        window.addEventListener('scroll', handleScroll);
+        return () => {
+            window.removeEventListener('scroll', handleScroll);
+        };
+    }, [debounceMs, setPosition]);
+    return [position, setPosition];
+};

package/dist/ra-core/src/routing/useSplatPathBase.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Utility hook to get the base path of a splat path.
+ * Compatible both with react-router v6 and v7.
+ *
+ * Example:
+ * If a splat path is defined as `/posts/:id/show/*`,
+ * and the current location is `/posts/12/show/3`,
+ * this hook will return `/posts/12/show`.
+ *
+ * Solution inspired by
+ * https://github.com/remix-run/react-router/issues/11052#issuecomment-1828470203
+ */
+export declare const useSplatPathBase: () => string;

package/dist/ra-core/src/routing/useSplatPathBase.js

@@ -0,0 +1,21 @@
+import { useLocation } from './useLocation';
+import { useParams } from './useParams';
+/**
+ * Utility hook to get the base path of a splat path.
+ * Compatible both with react-router v6 and v7.
+ *
+ * Example:
+ * If a splat path is defined as `/posts/:id/show/*`,
+ * and the current location is `/posts/12/show/3`,
+ * this hook will return `/posts/12/show`.
+ *
+ * Solution inspired by
+ * https://github.com/remix-run/react-router/issues/11052#issuecomment-1828470203
+ */
+export const useSplatPathBase = () => {
+    const location = useLocation();
+    const params = useParams();
+    const splatPathRelativePart = params['*'];
+    const splatPathBase = location.pathname.replace(new RegExp(`/${splatPathRelativePart}$`), '');
+    return splatPathBase;
+};

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

@@ -0,0 +1,11 @@
+export * from './localStorageStore';
+export * from './memoryStore';
+export * from './StoreContext';
+export * from './StoreContextProvider';
+export * from './StoreSetter';
+export * from './types';
+export * from './useStore';
+export * from './useStoreContext';
+export * from './useRemoveFromStore';
+export * from './useRemoveItemsFromStore';
+export * from './useResetStore';

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

@@ -0,0 +1,11 @@
+export * from './localStorageStore';
+export * from './memoryStore';
+export * from './StoreContext';
+export * from './StoreContextProvider';
+export * from './StoreSetter';
+export * from './types';
+export * from './useStore';
+export * from './useStoreContext';
+export * from './useRemoveFromStore';
+export * from './useRemoveItemsFromStore';
+export * from './useResetStore';

package/dist/ra-core/src/store/localStorageStore.d.ts

@@ -0,0 +1,27 @@
+import { Store } from './types';
+/**
+ * Store using localStorage, or memory storage in incognito mode
+ *
+ * @example
+ *
+ * import { localStorageStore } from 'react-admin';
+ *
+ * const App = () => (
+ *    <Admin store={localStorageStore()}>
+ *       ...
+ *   </Admin>
+ * );
+ */
+export declare const localStorageStore: (version?: string, appKey?: string) => Store;
+declare class LocalStorageShim {
+    valuesMap: any;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    removeItems(keyPrefix: string): void;
+    clear(): void;
+    key(i: any): string;
+    get length(): any;
+}
+export declare const getStorage: () => LocalStorageShim | Storage;
+export {};

package/dist/ra-core/src/store/localStorageStore.js

@@ -0,0 +1,198 @@
+const RA_STORE = 'RaStore';
+// localStorage isn't available in incognito mode. We need to detect it
+const testLocalStorage = () => {
+    // eslint-disable-next-line eqeqeq
+    if (typeof window === 'undefined' || window.localStorage == undefined) {
+        return false;
+    }
+    try {
+        window.localStorage.setItem('test', 'test');
+        window.localStorage.removeItem('test');
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const localStorageAvailable = testLocalStorage();
+/**
+ * Store using localStorage, or memory storage in incognito mode
+ *
+ * @example
+ *
+ * import { localStorageStore } from 'react-admin';
+ *
+ * const App = () => (
+ *    <Admin store={localStorageStore()}>
+ *       ...
+ *   </Admin>
+ * );
+ */
+export const localStorageStore = (version = '1', appKey = '') => {
+    const prefix = `${RA_STORE}${appKey}`;
+    const prefixLength = prefix.length;
+    const subscriptions = {};
+    const publish = (key, value) => {
+        Object.keys(subscriptions).forEach(id => {
+            if (!subscriptions[id])
+                return; // may happen if a component unmounts after a first subscriber was notified
+            if (subscriptions[id].key === key) {
+                subscriptions[id].callback(value);
+            }
+        });
+    };
+    // Whenever the local storage changes in another document, look for matching subscribers.
+    // This allows to synchronize state across tabs
+    const onLocalStorageChange = (event) => {
+        if (event.key?.substring(0, prefixLength) !== prefix) {
+            return;
+        }
+        const key = event.key.substring(prefixLength + 1);
+        const value = event.newValue ? tryParse(event.newValue) : undefined;
+        Object.keys(subscriptions).forEach(id => {
+            if (!subscriptions[id])
+                return; // may happen if a component unmounts after a first subscriber was notified
+            if (subscriptions[id].key === key) {
+                if (value === null) {
+                    // an event with a null value is sent when the key is deleted.
+                    // to enable default value, we need to call setValue(undefined) instead of setValue(null)
+                    subscriptions[id].callback(undefined);
+                }
+                else {
+                    subscriptions[id].callback(value == null ? undefined : value);
+                }
+            }
+        });
+    };
+    return {
+        setup: () => {
+            if (localStorageAvailable) {
+                const storedVersion = getStorage().getItem(`${prefix}.version`);
+                if (storedVersion && storedVersion !== version) {
+                    const storage = getStorage();
+                    Object.keys(storage).forEach(key => {
+                        if (key.startsWith(prefix)) {
+                            storage.removeItem(key);
+                        }
+                    });
+                }
+                getStorage().setItem(`${prefix}.version`, version);
+                window.addEventListener('storage', onLocalStorageChange);
+            }
+        },
+        teardown: () => {
+            if (localStorageAvailable) {
+                window.removeEventListener('storage', onLocalStorageChange);
+            }
+        },
+        getItem(key, defaultValue) {
+            const valueFromStorage = getStorage().getItem(`${prefix}.${key}`);
+            return valueFromStorage == null
+                ? defaultValue
+                : tryParse(valueFromStorage);
+        },
+        setItem(key, value) {
+            if (value === undefined) {
+                getStorage().removeItem(`${prefix}.${key}`);
+            }
+            else {
+                getStorage().setItem(`${prefix}.${key}`, JSON.stringify(value));
+            }
+            publish(key, value);
+        },
+        removeItem(key) {
+            getStorage().removeItem(`${prefix}.${key}`);
+            publish(key, undefined);
+        },
+        removeItems(keyPrefix) {
+            const storage = getStorage();
+            Object.keys(storage).forEach(key => {
+                if (key.startsWith(`${prefix}.${keyPrefix}`)) {
+                    storage.removeItem(key);
+                    const publishKey = key.substring(prefixLength + 1);
+                    publish(publishKey, undefined);
+                }
+            });
+        },
+        reset() {
+            const storage = getStorage();
+            Object.keys(storage).forEach(key => {
+                if (key.startsWith(prefix)) {
+                    storage.removeItem(key);
+                    const publishKey = key.substring(prefixLength + 1);
+                    publish(publishKey, undefined);
+                }
+            });
+        },
+        subscribe: (key, callback) => {
+            const id = Math.random().toString();
+            subscriptions[id] = {
+                key,
+                callback,
+            };
+            return () => {
+                delete subscriptions[id];
+            };
+        },
+        listItems: (keyPrefix) => {
+            const storage = getStorage();
+            const fullPrefix = `${prefix}.${keyPrefix != null ? keyPrefix : ''}`;
+            return Object.entries(storage).reduce((acc, [key, value]) => {
+                if (
+                // version is considered internal
+                key !== `${prefix}.version` &&
+                    key.startsWith(fullPrefix)) {
+                    acc[key.substring(prefix.length + 1)] = tryParse(value);
+                }
+                return acc;
+            }, {});
+        },
+    };
+};
+const tryParse = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        return value;
+    }
+};
+class LocalStorageShim {
+    valuesMap = new Map();
+    getItem(key) {
+        if (this.valuesMap.has(key)) {
+            return String(this.valuesMap.get(key));
+        }
+        return null;
+    }
+    setItem(key, value) {
+        this.valuesMap.set(key, value);
+    }
+    removeItem(key) {
+        this.valuesMap.delete(key);
+    }
+    removeItems(keyPrefix) {
+        this.valuesMap.forEach((value, key) => {
+            if (key.startsWith(keyPrefix)) {
+                this.valuesMap.delete(key);
+            }
+        });
+    }
+    clear() {
+        this.valuesMap.clear();
+    }
+    key(i) {
+        if (arguments.length === 0) {
+            throw new TypeError("Failed to execute 'key' on 'Storage': 1 argument required, but only 0 present."); // this is a TypeError implemented on Chrome, Firefox throws Not enough arguments to Storage.key.
+        }
+        const arr = Array.from(this.valuesMap.keys());
+        return arr[i];
+    }
+    get length() {
+        return this.valuesMap.size;
+    }
+}
+const memoryStorage = new LocalStorageShim();
+export const getStorage = () => {
+    return localStorageAvailable ? window.localStorage : memoryStorage;
+};

package/dist/ra-core/src/store/types.d.ts

@@ -0,0 +1,11 @@
+export interface Store {
+    setup: () => void;
+    teardown: () => void;
+    getItem: <T = any>(key: string, defaultValue?: T) => T | undefined;
+    setItem: <T = any>(key: string, value: T) => void;
+    removeItem: (key: string) => void;
+    removeItems: (keyPrefix: string) => void;
+    reset: () => void;
+    subscribe: (key: string, callback: (value: any) => void) => () => void;
+    listItems?: (keyPrefix?: string) => Record<string, unknown>;
+}

package/dist/ra-core/src/store/types.js

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

package/dist/ra-core/src/store/useRemoveFromStore.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get a callback to remove an item from the store
+ *
+ * @example
+ * import { useRemoveFromStore } from 'react-admin';
+ *
+ * const ResetDatagridPrefs = () {
+ *    const removeItem = useRemoveFromStore();
+ *
+ *    const handleClick = () => {
+ *        removeItem('datagrid.prefs');
+ *    };
+ *
+ *    return <Button onClick={hancleClick}>Reset datagrid preferences</Button>;
+ * }
+ */
+export declare const useRemoveFromStore: (hookTimeKey?: string) => (key?: string) => any;

package/dist/ra-core/src/store/useRemoveFromStore.js

@@ -0,0 +1,29 @@
+import { useCallback } from 'react';
+import { useStoreContext } from './useStoreContext';
+/**
+ * Get a callback to remove an item from the store
+ *
+ * @example
+ * import { useRemoveFromStore } from 'react-admin';
+ *
+ * const ResetDatagridPrefs = () {
+ *    const removeItem = useRemoveFromStore();
+ *
+ *    const handleClick = () => {
+ *        removeItem('datagrid.prefs');
+ *    };
+ *
+ *    return <Button onClick={hancleClick}>Reset datagrid preferences</Button>;
+ * }
+ */
+export const useRemoveFromStore = (hookTimeKey) => {
+    const { removeItem } = useStoreContext();
+    return useCallback((key) => {
+        if (typeof key === 'undefined' &&
+            typeof hookTimeKey === 'undefined') {
+            throw new Error('You must provide a key to remove an item from the store');
+        }
+        // @ts-ignore
+        return removeItem(key ?? hookTimeKey);
+    }, [removeItem, hookTimeKey]);
+};

package/dist/ra-core/src/store/useRemoveItemsFromStore.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get a callback to remove all item with a certain key prefix from the store
+ *
+ * @example
+ * import { useRemoveItemsFromStore } from 'react-admin';
+ *
+ * const ResetDatagridPrefs = () {
+ *    const removeItems = useRemoveItemsFromStore();
+ *
+ *    const handleClick = () => {
+ *        removeItems('datagrid.prefs');
+ *    };
+ *
+ *    return <Button onClick={hancleClick}>Reset datagrid preferences</Button>;
+ * }
+ */
+export declare const useRemoveItemsFromStore: (hookTimeKeyPrefix?: string | null) => (keyPrefix?: string) => any;

package/dist/ra-core/src/store/useRemoveItemsFromStore.js

@@ -0,0 +1,29 @@
+import { useCallback } from 'react';
+import { useStoreContext } from './useStoreContext';
+/**
+ * Get a callback to remove all item with a certain key prefix from the store
+ *
+ * @example
+ * import { useRemoveItemsFromStore } from 'react-admin';
+ *
+ * const ResetDatagridPrefs = () {
+ *    const removeItems = useRemoveItemsFromStore();
+ *
+ *    const handleClick = () => {
+ *        removeItems('datagrid.prefs');
+ *    };
+ *
+ *    return <Button onClick={hancleClick}>Reset datagrid preferences</Button>;
+ * }
+ */
+export const useRemoveItemsFromStore = (hookTimeKeyPrefix) => {
+    const { removeItems } = useStoreContext();
+    return useCallback((keyPrefix) => {
+        if (typeof keyPrefix === 'undefined' &&
+            typeof hookTimeKeyPrefix === 'undefined') {
+            throw new Error('You must provide a key to remove an item from the store');
+        }
+        // @ts-ignore
+        return removeItems(keyPrefix ?? hookTimeKeyPrefix);
+    }, [removeItems, hookTimeKeyPrefix]);
+};

package/dist/ra-core/src/store/useResetStore.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get a callback to remove all items from the store
+ *
+ * @example
+ * import { useResetStore } from 'react-admin';
+ *
+ * const ResetPrefs = () {
+ *    const reset = useResetStore();
+ *
+ *    const handleClick = () => {
+ *        reset();
+ *    };
+ *
+ *    return <Button onClick={handleClick}>Reset preferences</Button>;
+ * }
+ */
+export declare const useResetStore: () => any;

package/dist/ra-core/src/store/useResetStore.js

@@ -0,0 +1,21 @@
+import { useStoreContext } from './useStoreContext';
+/**
+ * Get a callback to remove all items from the store
+ *
+ * @example
+ * import { useResetStore } from 'react-admin';
+ *
+ * const ResetPrefs = () {
+ *    const reset = useResetStore();
+ *
+ *    const handleClick = () => {
+ *        reset();
+ *    };
+ *
+ *    return <Button onClick={handleClick}>Reset preferences</Button>;
+ * }
+ */
+export const useResetStore = () => {
+    const { reset } = useStoreContext();
+    return reset;
+};