@strato-admin/core 0.1.0 → 0.3.0

package/dist/ra-core/src/core/useResourceDefinitions.js

@@ -0,0 +1,20 @@
+import { useResourceDefinitionContext } from './useResourceDefinitionContext';
+/**
+ * Get the definition of the all resources
+ *
+ * @example
+ *
+ * const definitions = useResourceDefinitions();
+ * console.log(definitions.posts);
+ * // {
+ * //   name: 'posts',
+ * //   hasList: true,
+ * //   hasEdit: true,
+ * //   hasShow: true,
+ * //   hasCreate: true,
+ * //   options: {},
+ * //   icon: PostIcon,
+ * //   recordRepresentation: 'title',
+ * // }
+ */
+export const useResourceDefinitions = () => useResourceDefinitionContext().definitions;

package/dist/ra-core/src/core/useUserMenu.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A hook to retrieve the user menu context, which provides access to a function for closing the user menu.
+ * @returns {UserMenuContextValue}
+ *
+ * @example
+ * import { Logout, MenuItemLink, UserMenu, useUserMenu } from 'react-admin';
+ *
+ * const ConfigurationMenu = () => {
+ *     const { onClose } = useUserMenu();
+ *     return (
+ *         <MenuItemLink
+ *             to="/configuration"
+ *             primaryText="pos.configuration"
+ *             leftIcon={<SettingsIcon />}
+ *             sidebarIsOpen
+ *             onClick={onClose}
+ *         />
+ *     );
+ * };
+ *
+ * export const MyUserMenu = () => (
+ *     <UserMenu>
+ *         <ConfigurationMenu />
+ *         <Logout />
+ *     </UserMenu>
+ * );
+ */
+export declare const useUserMenu: () => import("@strato-admin/core").UserMenuContextValue | undefined;

package/dist/ra-core/src/core/useUserMenu.js

@@ -0,0 +1,30 @@
+import { useContext } from 'react';
+import { UserMenuContext } from './UserMenuContext';
+/**
+ * A hook to retrieve the user menu context, which provides access to a function for closing the user menu.
+ * @returns {UserMenuContextValue}
+ *
+ * @example
+ * import { Logout, MenuItemLink, UserMenu, useUserMenu } from 'react-admin';
+ *
+ * const ConfigurationMenu = () => {
+ *     const { onClose } = useUserMenu();
+ *     return (
+ *         <MenuItemLink
+ *             to="/configuration"
+ *             primaryText="pos.configuration"
+ *             leftIcon={<SettingsIcon />}
+ *             sidebarIsOpen
+ *             onClick={onClose}
+ *         />
+ *     );
+ * };
+ *
+ * export const MyUserMenu = () => (
+ *     <UserMenu>
+ *         <ConfigurationMenu />
+ *         <Logout />
+ *     </UserMenu>
+ * );
+ */
+export const useUserMenu = () => useContext(UserMenuContext);

package/dist/ra-core/src/core/useWrappedSource.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Get the source prop for a field or input by checking if a source context is available.
+ * @param {string} source The original source prop
+ * @returns {string} The source prop, either the original one or the one modified by the SourceContext.
+ * @example
+ * const MyInput = ({ source, ...props }) => {
+ *   const finalSource = useWrappedSource(source);
+ *   return <input name={finalSource} {...props} />;
+ * };
+ */
+export declare const useWrappedSource: (source: string) => string;

package/dist/ra-core/src/core/useWrappedSource.js

@@ -0,0 +1,15 @@
+import { useSourceContext } from './SourceContext';
+/**
+ * Get the source prop for a field or input by checking if a source context is available.
+ * @param {string} source The original source prop
+ * @returns {string} The source prop, either the original one or the one modified by the SourceContext.
+ * @example
+ * const MyInput = ({ source, ...props }) => {
+ *   const finalSource = useWrappedSource(source);
+ *   return <input name={finalSource} {...props} />;
+ * };
+ */
+export const useWrappedSource = (source) => {
+    const sourceContext = useSourceContext();
+    return sourceContext.getSource(source);
+};

package/dist/ra-core/src/dataProvider/DataProviderContext.d.ts

@@ -0,0 +1,3 @@
+import { DataProvider } from '../types';
+declare const DataProviderContext: import("react").Context<DataProvider | null>;
+export default DataProviderContext;

package/dist/ra-core/src/dataProvider/DataProviderContext.js

@@ -0,0 +1,4 @@
+import { createContext } from 'react';
+const DataProviderContext = createContext(null);
+DataProviderContext.displayName = 'DataProviderContext';
+export default DataProviderContext;

package/dist/ra-core/src/dataProvider/HttpError.d.ts

@@ -0,0 +1,6 @@
+declare class HttpError extends Error {
+    status: any;
+    body: any;
+    constructor(message: any, status: any, body?: any);
+}
+export default HttpError;

package/dist/ra-core/src/dataProvider/HttpError.js

@@ -0,0 +1,19 @@
+class HttpError extends Error {
+    status;
+    body;
+    constructor(message, status, body = null) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        Object.setPrototypeOf(this, HttpError.prototype);
+        this.name = this.constructor.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        else {
+            this.stack = new Error(message).stack;
+        }
+        this.stack = new Error().stack;
+    }
+}
+export default HttpError;

package/dist/ra-core/src/dataProvider/combineDataProviders.d.ts

@@ -0,0 +1,21 @@
+import { DataProvider } from '../types';
+export type DataProviderMatcher = (resource: string) => DataProvider;
+/**
+ * Combine multiple data providers into one.
+ *
+ * @param dataProviderMatcher A function that returns a data provider for a given resource.
+ *
+ * @example
+ * const dataProvider = combineDataProviders(resource => {
+ *    switch(resource) {
+ *       case 'posts':
+ *       case 'comments':
+ *          return dataProvider1;
+ *       case 'users':
+ *          return dataProvider2;
+ *       default:
+ *         throw new Error('Unknown resource');
+ *    }
+ * });
+ */
+export declare const combineDataProviders: (dataProviderMatcher: DataProviderMatcher) => DataProvider;

package/dist/ra-core/src/dataProvider/combineDataProviders.js

@@ -0,0 +1,32 @@
+import { defaultDataProvider } from './defaultDataProvider';
+/**
+ * Combine multiple data providers into one.
+ *
+ * @param dataProviderMatcher A function that returns a data provider for a given resource.
+ *
+ * @example
+ * const dataProvider = combineDataProviders(resource => {
+ *    switch(resource) {
+ *       case 'posts':
+ *       case 'comments':
+ *          return dataProvider1;
+ *       case 'users':
+ *          return dataProvider2;
+ *       default:
+ *         throw new Error('Unknown resource');
+ *    }
+ * });
+ */
+export const combineDataProviders = (dataProviderMatcher) => new Proxy(defaultDataProvider, {
+    get: (target, name) => {
+        if (name === 'then') {
+            return null;
+        }
+        return (resource, ...params) => {
+            if (typeof name === 'symbol') {
+                return;
+            }
+            return dataProviderMatcher(resource)[name](resource, ...params);
+        };
+    },
+});

package/dist/ra-core/src/dataProvider/convertLegacyDataProvider.d.ts

@@ -0,0 +1,12 @@
+import { LegacyDataProvider, DataProvider } from '../types';
+/**
+ * Turn a function-based dataProvider to an object-based one
+ *
+ * Allows using legacy dataProviders transparently.
+ *
+ * @param {Function} legacyDataProvider A legacy dataProvider (type, resource, params) => Promise<any>
+ *
+ * @returns {Object} A dataProvider that react-admin can use
+ */
+declare const convertLegacyDataProvider: (legacyDataProvider: LegacyDataProvider) => DataProvider;
+export default convertLegacyDataProvider;

package/dist/ra-core/src/dataProvider/convertLegacyDataProvider.js

@@ -0,0 +1,40 @@
+import { CREATE, DELETE, DELETE_MANY, GET_LIST, GET_MANY, GET_MANY_REFERENCE, GET_ONE, UPDATE, UPDATE_MANY, } from './dataFetchActions';
+import { defaultDataProvider } from './defaultDataProvider';
+const fetchMap = {
+    create: CREATE,
+    delete: DELETE,
+    deleteMany: DELETE_MANY,
+    getList: GET_LIST,
+    getMany: GET_MANY,
+    getManyReference: GET_MANY_REFERENCE,
+    getOne: GET_ONE,
+    update: UPDATE,
+    updateMany: UPDATE_MANY,
+};
+/**
+ * Turn a function-based dataProvider to an object-based one
+ *
+ * Allows using legacy dataProviders transparently.
+ *
+ * @param {Function} legacyDataProvider A legacy dataProvider (type, resource, params) => Promise<any>
+ *
+ * @returns {Object} A dataProvider that react-admin can use
+ */
+const convertLegacyDataProvider = (legacyDataProvider) => {
+    const proxy = new Proxy(defaultDataProvider, {
+        get(_, name) {
+            return (resource, params) => {
+                if (Object.keys(fetchMap).includes(name.toString())) {
+                    const fetchType = fetchMap[name.toString()];
+                    return legacyDataProvider(fetchType, resource, params);
+                }
+                return legacyDataProvider(name.toString(), resource, params);
+            };
+        },
+        apply(_, __, args) {
+            return legacyDataProvider.apply(legacyDataProvider, args);
+        },
+    });
+    return proxy;
+};
+export default convertLegacyDataProvider;

package/dist/ra-core/src/dataProvider/dataFetchActions.d.ts

@@ -0,0 +1,15 @@
+export declare const GET_LIST = "GET_LIST";
+export declare const GET_ONE = "GET_ONE";
+export declare const GET_MANY = "GET_MANY";
+export declare const GET_MANY_REFERENCE = "GET_MANY_REFERENCE";
+export declare const CREATE = "CREATE";
+export declare const UPDATE = "UPDATE";
+export declare const UPDATE_MANY = "UPDATE_MANY";
+export declare const DELETE = "DELETE";
+export declare const DELETE_MANY = "DELETE_MANY";
+export declare const fetchActionsWithRecordResponse: string[];
+export declare const fetchActionsWithArrayOfIdentifiedRecordsResponse: string[];
+export declare const fetchActionsWithArrayOfRecordsResponse: string[];
+export declare const fetchActionsWithTotalResponse: string[];
+export declare const reactAdminFetchActions: string[];
+export declare const sanitizeFetchType: (fetchType: string) => string;

package/dist/ra-core/src/dataProvider/dataFetchActions.js

@@ -0,0 +1,49 @@
+export const GET_LIST = 'GET_LIST';
+export const GET_ONE = 'GET_ONE';
+export const GET_MANY = 'GET_MANY';
+export const GET_MANY_REFERENCE = 'GET_MANY_REFERENCE';
+export const CREATE = 'CREATE';
+export const UPDATE = 'UPDATE';
+export const UPDATE_MANY = 'UPDATE_MANY';
+export const DELETE = 'DELETE';
+export const DELETE_MANY = 'DELETE_MANY';
+export const fetchActionsWithRecordResponse = ['getOne', 'create', 'update'];
+export const fetchActionsWithArrayOfIdentifiedRecordsResponse = [
+    'getList',
+    'getMany',
+    'getManyReference',
+];
+export const fetchActionsWithArrayOfRecordsResponse = [
+    ...fetchActionsWithArrayOfIdentifiedRecordsResponse,
+    'updateMany',
+    'deleteMany',
+];
+export const fetchActionsWithTotalResponse = ['getList', 'getManyReference'];
+export const reactAdminFetchActions = [
+    ...fetchActionsWithRecordResponse,
+    ...fetchActionsWithArrayOfRecordsResponse,
+];
+export const sanitizeFetchType = (fetchType) => {
+    switch (fetchType) {
+        case GET_LIST:
+            return 'getList';
+        case GET_ONE:
+            return 'getOne';
+        case GET_MANY:
+            return 'getMany';
+        case GET_MANY_REFERENCE:
+            return 'getManyReference';
+        case CREATE:
+            return 'create';
+        case UPDATE:
+            return 'update';
+        case UPDATE_MANY:
+            return 'updateMany';
+        case DELETE:
+            return 'delete';
+        case DELETE_MANY:
+            return 'deleteMany';
+        default:
+            return fetchType;
+    }
+};

package/dist/ra-core/src/dataProvider/defaultDataProvider.d.ts

@@ -0,0 +1,2 @@
+import { DataProvider } from '../types';
+export declare const defaultDataProvider: DataProvider;

package/dist/ra-core/src/dataProvider/defaultDataProvider.js

@@ -0,0 +1,12 @@
+// avoids adding a context in tests
+export const defaultDataProvider = {
+    create: () => Promise.resolve({ data: null }),
+    delete: () => Promise.resolve({ data: null }),
+    deleteMany: () => Promise.resolve({ data: [] }),
+    getList: () => Promise.resolve({ data: [], total: 0 }),
+    getMany: () => Promise.resolve({ data: [] }),
+    getManyReference: () => Promise.resolve({ data: [], total: 0 }),
+    getOne: () => Promise.resolve({ data: null }),
+    update: () => Promise.resolve({ data: null }),
+    updateMany: () => Promise.resolve({ data: [] }),
+};

package/dist/ra-core/src/dataProvider/fetch.d.ts

@@ -0,0 +1,32 @@
+import { stringify } from 'query-string';
+export interface Options extends RequestInit {
+    user?: {
+        authenticated?: boolean;
+        token?: string;
+    };
+}
+export declare const createHeadersFromOptions: (options: Options) => Headers;
+/**
+ * Utility function to make HTTP calls. It's similar to the HTML5 `fetch()`, except it handles JSON decoding and HTTP error codes automatically.
+ *
+ * @param url the URL to call
+ * @param options the options to pass to the HTTP call
+ * @param options.user the user object, used for the Authorization header
+ * @param options.user.token the token to pass as the Authorization header
+ * @param options.user.authenticated whether the user is authenticated or not (the Authorization header will be set only if this is true)
+ * @param options.headers the headers to pass to the HTTP call
+ *
+ * @returns {Promise} the Promise for a response object containing the following properties:
+ * - status: the HTTP status code
+ * - headers: the HTTP headers
+ * - body: the response body
+ * - json: the response body parsed as JSON
+ */
+export declare const fetchJson: (url: any, options?: Options) => Promise<{
+    status: number;
+    headers: Headers;
+    body: string;
+    json: any;
+}>;
+export declare const queryParameters: typeof stringify;
+export declare const flattenObject: (value: any, path?: string[]) => any;

package/dist/ra-core/src/dataProvider/fetch.js

@@ -0,0 +1,78 @@
+import HttpError from './HttpError';
+import { stringify } from 'query-string';
+export const createHeadersFromOptions = (options) => {
+    const requestHeaders = (options.headers ||
+        new Headers({
+            Accept: 'application/json',
+        }));
+    const hasBody = options && options.body;
+    const isContentTypeSet = requestHeaders.has('Content-Type');
+    const isGetMethod = !options?.method || options?.method === 'GET';
+    const isFormData = options?.body instanceof FormData;
+    const shouldSetContentType = hasBody && !isContentTypeSet && !isGetMethod && !isFormData;
+    if (shouldSetContentType) {
+        requestHeaders.set('Content-Type', 'application/json');
+    }
+    if (options.user && options.user.authenticated && options.user.token) {
+        requestHeaders.set('Authorization', options.user.token);
+    }
+    return requestHeaders;
+};
+/**
+ * Utility function to make HTTP calls. It's similar to the HTML5 `fetch()`, except it handles JSON decoding and HTTP error codes automatically.
+ *
+ * @param url the URL to call
+ * @param options the options to pass to the HTTP call
+ * @param options.user the user object, used for the Authorization header
+ * @param options.user.token the token to pass as the Authorization header
+ * @param options.user.authenticated whether the user is authenticated or not (the Authorization header will be set only if this is true)
+ * @param options.headers the headers to pass to the HTTP call
+ *
+ * @returns {Promise} the Promise for a response object containing the following properties:
+ * - status: the HTTP status code
+ * - headers: the HTTP headers
+ * - body: the response body
+ * - json: the response body parsed as JSON
+ */
+export const fetchJson = (url, options = {}) => {
+    const requestHeaders = createHeadersFromOptions(options);
+    return fetch(url, { ...options, headers: requestHeaders })
+        .then(response => response.text().then(text => ({
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        body: text,
+    })))
+        .then(({ status, statusText, headers, body }) => {
+        let json;
+        try {
+            json = JSON.parse(body);
+        }
+        catch (e) {
+            // not json, no big deal
+        }
+        if (status < 200 || status >= 300) {
+            return Promise.reject(new HttpError((json && json.message) || statusText, status, json));
+        }
+        return Promise.resolve({ status, headers, body, json });
+    });
+};
+export const queryParameters = stringify;
+const isValidObject = value => {
+    if (!value) {
+        return false;
+    }
+    const isArray = Array.isArray(value);
+    const isBuffer = typeof Buffer !== 'undefined' && Buffer.isBuffer(value);
+    const isObject = Object.prototype.toString.call(value) === '[object Object]';
+    const hasKeys = !!Object.keys(value).length;
+    return !isArray && !isBuffer && isObject && hasKeys;
+};
+export const flattenObject = (value, path = []) => {
+    if (isValidObject(value)) {
+        return Object.assign({}, ...Object.keys(value).map(key => flattenObject(value[key], path.concat([key]))));
+    }
+    else {
+        return path.length ? { [path.join('.')]: value } : value;
+    }
+};

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

@@ -0,0 +1,34 @@
+import convertLegacyDataProvider from './convertLegacyDataProvider';
+import DataProviderContext from './DataProviderContext';
+import HttpError from './HttpError';
+import * as fetchUtils from './fetch';
+import undoableEventEmitter from './undoableEventEmitter';
+export * from './combineDataProviders';
+export * from './dataFetchActions';
+export * from './defaultDataProvider';
+export * from './testDataProvider';
+export * from './withLifecycleCallbacks';
+export * from './useDataProvider';
+export * from './useIsDataLoaded';
+export * from './useLoading';
+export * from './useRefresh';
+export * from './useGetOne';
+export * from './useGetList';
+export * from './useGetMany';
+export * from './useGetManyAggregate';
+export * from './useGetManyReference';
+export * from './useGetRecordId';
+export * from './useCreate';
+export * from './useUpdate';
+export * from './useUpdateMany';
+export * from './useDelete';
+export * from './useDeleteMany';
+export * from './useInfiniteGetList';
+export * from './undo/';
+export * from './useMutationWithMutationMode';
+export type { Options } from './fetch';
+export { convertLegacyDataProvider, DataProviderContext, fetchUtils, HttpError, 
+/**
+ * @deprecated use the useTakeUndoableMutation hook instead
+ */
+undoableEventEmitter, };

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

@@ -0,0 +1,33 @@
+import convertLegacyDataProvider from './convertLegacyDataProvider';
+import DataProviderContext from './DataProviderContext';
+import HttpError from './HttpError';
+import * as fetchUtils from './fetch';
+import undoableEventEmitter from './undoableEventEmitter';
+export * from './combineDataProviders';
+export * from './dataFetchActions';
+export * from './defaultDataProvider';
+export * from './testDataProvider';
+export * from './withLifecycleCallbacks';
+export * from './useDataProvider';
+export * from './useIsDataLoaded';
+export * from './useLoading';
+export * from './useRefresh';
+export * from './useGetOne';
+export * from './useGetList';
+export * from './useGetMany';
+export * from './useGetManyAggregate';
+export * from './useGetManyReference';
+export * from './useGetRecordId';
+export * from './useCreate';
+export * from './useUpdate';
+export * from './useUpdateMany';
+export * from './useDelete';
+export * from './useDeleteMany';
+export * from './useInfiniteGetList';
+export * from './undo/';
+export * from './useMutationWithMutationMode';
+export { convertLegacyDataProvider, DataProviderContext, fetchUtils, HttpError, 
+/**
+ * @deprecated use the useTakeUndoableMutation hook instead
+ */
+undoableEventEmitter, };

package/dist/ra-core/src/dataProvider/populateQueryCache.d.ts

@@ -0,0 +1,22 @@
+import type { QueryClient } from '@tanstack/react-query';
+export type PopulateQueryCacheOptions = {
+    data: Record<string, any[]>;
+    queryClient: QueryClient;
+    staleTime?: number;
+};
+/**
+ * Populate react-query's query cache with a data dictionary
+ *
+ * @example
+ * const data = {
+ *    posts: [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }],
+ *    comments: [{ id: 1, post_id: 1, body: 'Nice post!' }],
+ * };
+ * populateQueryCache({ data, queryClient });
+ * // setQueryData(['posts', 'getOne', { id: '1' }], { id: 1, title: 'Hello, world' });
+ * // setQueryData(['posts', 'getOne', { id: '2' }], { id: 2, title: 'FooBar' });
+ * // setQueryData(['posts', 'getMany', { ids: ['1', '2'] }], [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }]);
+ * // setQueryData(['comments', 'getOne', { id: '1' }], { id: 1, post_id: 1, body: 'Nice post!' });
+ * // setQueryData(['comments', 'getMany', { ids: ['1'] }], [{ id: 1, post_id: 1, body: 'Nice post!' });
+ */
+export declare const populateQueryCache: ({ data, queryClient, staleTime, }: PopulateQueryCacheOptions) => void;

package/dist/ra-core/src/dataProvider/populateQueryCache.js

@@ -0,0 +1,30 @@
+/**
+ * Populate react-query's query cache with a data dictionary
+ *
+ * @example
+ * const data = {
+ *    posts: [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }],
+ *    comments: [{ id: 1, post_id: 1, body: 'Nice post!' }],
+ * };
+ * populateQueryCache({ data, queryClient });
+ * // setQueryData(['posts', 'getOne', { id: '1' }], { id: 1, title: 'Hello, world' });
+ * // setQueryData(['posts', 'getOne', { id: '2' }], { id: 2, title: 'FooBar' });
+ * // setQueryData(['posts', 'getMany', { ids: ['1', '2'] }], [{ id: 1, title: 'Hello, world' }, { id: 2, title: 'FooBar' }]);
+ * // setQueryData(['comments', 'getOne', { id: '1' }], { id: 1, post_id: 1, body: 'Nice post!' });
+ * // setQueryData(['comments', 'getMany', { ids: ['1'] }], [{ id: 1, post_id: 1, body: 'Nice post!' });
+ */
+export const populateQueryCache = ({ data, queryClient, staleTime = 1000, // ms
+ }) => {
+    // setQueryData doesn't accept a stale time option
+    // So we set an updatedAt in the future to make sure the data isn't considered stale
+    const updatedAt = Date.now() + staleTime;
+    Object.keys(data).forEach(resource => {
+        data[resource].forEach(record => {
+            if (!record || record.id == null)
+                return;
+            queryClient.setQueryData([resource, 'getOne', { id: String(record.id) }], record, { updatedAt });
+        });
+        const recordIds = data[resource].map(record => String(record.id));
+        queryClient.setQueryData([resource, 'getMany', { ids: recordIds }], data[resource], { updatedAt });
+    });
+};

package/dist/ra-core/src/dataProvider/testDataProvider.d.ts

@@ -0,0 +1,2 @@
+import { DataProvider } from '../types';
+export declare const testDataProvider: (overrides?: Partial<DataProvider>) => DataProvider;

package/dist/ra-core/src/dataProvider/testDataProvider.js

@@ -0,0 +1,41 @@
+/**
+ * A dataProvider meant to be used in tests only. You can override any of its methods by passing a partial dataProvider.
+ *
+ * @example
+ * const dataProvider = testDataProvider({
+ *    getOne: async () => ({ data: { id: 123, title: 'foo' }})
+ * })
+ */
+const defaultTestDataProvider = {
+    create: async () => {
+        throw new Error('create is not implemented');
+    },
+    delete: async () => {
+        throw new Error('delete not implemented');
+    },
+    deleteMany: async () => {
+        throw new Error('deleteMany is not implemented');
+    },
+    getList: async () => {
+        throw new Error('getList is not implemented');
+    },
+    getMany: async () => {
+        throw new Error('getMany is not implemented');
+    },
+    getManyReference: async () => {
+        throw new Error('getManyReference is not implemented');
+    },
+    getOne: async () => {
+        throw new Error('getOne is not implemented');
+    },
+    update: async () => {
+        throw new Error('update not implemented');
+    },
+    updateMany: async () => {
+        throw new Error('updateMany not implemented');
+    },
+};
+export const testDataProvider = (overrides) => ({
+    ...defaultTestDataProvider,
+    ...overrides,
+});

package/dist/ra-core/src/dataProvider/undo/AddUndoableMutationContext.d.ts

@@ -0,0 +1,2 @@
+import type { UndoableMutation } from './types';
+export declare const AddUndoableMutationContext: import("react").Context<(mutation: UndoableMutation) => void>;

package/dist/ra-core/src/dataProvider/undo/AddUndoableMutationContext.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const AddUndoableMutationContext = createContext(() => { });

package/dist/ra-core/src/dataProvider/undo/TakeUndoableMutationContext.d.ts

@@ -0,0 +1,2 @@
+import type { UndoableMutation } from './types';
+export declare const TakeUndoableMutationContext: import("react").Context<() => UndoableMutation | void>;

package/dist/ra-core/src/dataProvider/undo/TakeUndoableMutationContext.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const TakeUndoableMutationContext = createContext(() => { });

package/dist/ra-core/src/dataProvider/undo/UndoableMutationsContextProvider.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Exposes and manages a queue of undoable mutations
+ *
+ * This context is used in CoreAdminContext so that every react-admin app
+ * can use the useAddUndoableMutation and useTakeUndoableMutation hooks.
+ *
+ * Note: We need a separate queue for mutations (instead of using the
+ * notifications queue) because the mutations are not dequeued when the
+ * notification is displayed, but when it is dismissed.
+ */
+export declare const UndoableMutationsContextProvider: ({ children }: {
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;