@strato-admin/core 0.1.0 → 0.3.0

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

@@ -0,0 +1,102 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useNotify } from '../../notification';
+import { useDataProvider } from '../../dataProvider';
+import { useRecordSelection } from './useRecordSelection';
+import { useResourceContext } from '../../core';
+import { useEvent } from '../../util';
+/**
+ * Get a callback to select all records of a resource (capped by the limit parameter)
+ *
+ * @param {Object} params The hook parameters { resource, sort, filter }
+ * @returns {Function} handleSelectAll A function to select all items of a list
+ *
+ * @example
+ * import { List, Datagrid, BulkActionsToolbar, BulkDeleteButton, useListContext, useSelectAll } from 'react-admin';
+ *
+ * const MySelectAllButton = () => {
+ *   const { sort, filter } = useListContext();
+ *   const handleSelectAll = useSelectAll({ resource: 'posts', sort, filter });
+ *   const handleClick = () => handleSelectAll({
+ *       queryOptions: { meta: { foo: 'bar' } },
+ *       limit: 250,
+ *   });
+ *   return <button onClick={handleClick}>Select All</button>;
+ * };
+ *
+ * const PostBulkActionsToolbar = () => (
+ *     <BulkActionsToolbar actions={<MySelectAllButton/>}>
+ *         <BulkDeleteButton />
+ *     </BulkActionsToolbar>
+ * );
+ *
+ * export const PostList = () => (
+ *     <List>
+ *         <Datagrid bulkActionsToolbar={<PostBulkActionsToolbar />}>
+ *             ...
+ *         </Datagrid>
+ *     </List>
+ * );
+ */
+export const useSelectAll = (params) => {
+    const { sort, filter, storeKey, disableSyncWithStore } = params;
+    const resource = useResourceContext(params);
+    if (!resource) {
+        throw new Error('useSelectAll should be used inside a ResourceContextProvider or passed a resource prop');
+    }
+    const dataProvider = useDataProvider();
+    const queryClient = useQueryClient();
+    const [, { select }] = useRecordSelection({
+        resource,
+        storeKey,
+        disableSyncWithStore,
+    });
+    const notify = useNotify();
+    const handleSelectAll = useEvent(async ({ queryOptions = {}, limit = 250, } = {}) => {
+        const { meta, onSuccess, onError, ...otherQueryOptions } = queryOptions;
+        try {
+            const results = await queryClient.fetchQuery({
+                queryKey: [
+                    resource,
+                    'getList',
+                    {
+                        pagination: { page: 1, perPage: limit },
+                        sort,
+                        filter,
+                        meta,
+                    },
+                ],
+                queryFn: () => dataProvider.getList(resource, {
+                    pagination: {
+                        page: 1,
+                        perPage: limit,
+                    },
+                    sort,
+                    filter,
+                    meta,
+                }),
+                ...otherQueryOptions,
+            });
+            const allIds = results.data?.map(({ id }) => id) || [];
+            select(allIds);
+            if (allIds.length === limit) {
+                notify("strato.message.select_all_limit_reached', {
+                    messageArgs: { max: limit },
+                    type: 'warning',
+                });
+            }
+            if (onSuccess) {
+                onSuccess(results);
+            }
+            return results.data;
+        }
+        catch (error) {
+            if (onError) {
+                onError(error);
+            }
+            else {
+                notify("strato.notification.http_error', { type: 'warning' });
+            }
+        }
+    });
+    return handleSelectAll;
+};

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

@@ -0,0 +1,10 @@
+import { Identifier } from '../../types';
+/**
+ * Hook to Unselect the rows of a datagrid
+ *
+ * @example
+ *
+ * const unselect = useUnselect('posts');
+ * unselect([123, 456]);
+ */
+export declare const useUnselect: (resource?: string, storeKey?: string) => (ids: Identifier[], fromAllStoreKeys?: boolean) => void;

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

@@ -0,0 +1,18 @@
+import { useCallback } from 'react';
+import { useRecordSelection } from './useRecordSelection';
+/**
+ * Hook to Unselect the rows of a datagrid
+ *
+ * @example
+ *
+ * const unselect = useUnselect('posts');
+ * unselect([123, 456]);
+ */
+export const useUnselect = (resource, storeKey) => {
+    const [, { unselect }] = useRecordSelection(resource
+        ? { resource, storeKey }
+        : { disableSyncWithStore: true, storeKey });
+    return useCallback((ids, fromAllStoreKeys = false) => {
+        unselect(ids, fromAllStoreKeys);
+    }, [unselect]);
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Hook to unselect all row of a datagrid
+ *
+ * @example
+ *
+ * const unselectAll = useUnselectAll('posts');
+ * unselectAll();
+ */
+export declare const useUnselectAll: (resource?: string, storeKey?: string) => (fromAllStoreKeys?: boolean) => void;

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

@@ -0,0 +1,18 @@
+import { useCallback } from 'react';
+import { useRecordSelection } from './useRecordSelection';
+/**
+ * Hook to unselect all row of a datagrid
+ *
+ * @example
+ *
+ * const unselectAll = useUnselectAll('posts');
+ * unselectAll();
+ */
+export const useUnselectAll = (resource, storeKey) => {
+    const [, { clearSelection }] = useRecordSelection(resource
+        ? { resource, storeKey }
+        : { disableSyncWithStore: true, storeKey });
+    return useCallback((fromAllStoreKeys) => {
+        clearSelection(fromAllStoreKeys);
+    }, [clearSelection]);
+};

package/dist/ra-core/src/controller/record/OptionalRecordContextProvider.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { RaRecord } from '../../types';
+/**
+ * Wrap children with a RecordContext provider only if the value is defined.
+ *
+ * Allows a component to work outside of a record context.
+ *
+ * @example
+ *
+ * import { OptionalRecordContextProvider, TextField } from 'react-admin';
+ *
+ * const RecordTitle = ({ record }) => (
+ *     <OptionalRecordContextProvider value={record}>
+ *         <TextField source="title" />
+ *     </OptionalRecordContextProvider>
+ * );
+ */
+export declare const OptionalRecordContextProvider: <RecordType extends RaRecord | Omit<RaRecord, "id"> = RaRecord>({ value, children, }: {
+    children: React.ReactNode;
+    value?: RecordType;
+}) => string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;

package/dist/ra-core/src/controller/record/OptionalRecordContextProvider.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RecordContextProvider } from './RecordContext';
+/**
+ * Wrap children with a RecordContext provider only if the value is defined.
+ *
+ * Allows a component to work outside of a record context.
+ *
+ * @example
+ *
+ * import { OptionalRecordContextProvider, TextField } from 'react-admin';
+ *
+ * const RecordTitle = ({ record }) => (
+ *     <OptionalRecordContextProvider value={record}>
+ *         <TextField source="title" />
+ *     </OptionalRecordContextProvider>
+ * );
+ */
+export const OptionalRecordContextProvider = ({ value, children, }) => value ? (_jsx(RecordContextProvider, { value: value, children: children })) : (children);

package/dist/ra-core/src/controller/record/RecordContext.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { RaRecord } from '../../types';
+/**
+ * Context to store a record.
+ *
+ * @see RecordContextProvider
+ * @see useRecordContext
+ */
+export declare const RecordContext: React.Context<RaRecord<import("@strato-admin/core").Identifier> | Omit<RaRecord<import("@strato-admin/core").Identifier>, "id"> | undefined>;
+/**
+ * Provider for the Record Context, to store a record.
+ *
+ * Use the useRecordContext() hook to read the context.
+ * That's what the Edit and Show components do in react-admin.
+ *
+ * Many react-admin components read the RecordContext, including all Field
+ * components.
+ *
+ * @example
+ *
+ * import { useGetOne, RecordContextProvider } from '@strato-admin/ra-core';
+ *
+ * const Show = ({ resource, id }) => {
+ *     const { data } = useGetOne(resource, { id });
+ *     return (
+ *         <RecordContextProvider value={data}>
+ *             ...
+ *         </RecordContextProvider>
+ *     );
+ * };
+ */
+export declare const RecordContextProvider: <RecordType extends RaRecord | Omit<RaRecord, "id"> = RaRecord>({ children, value, }: RecordContextProviderProps<RecordType>) => import("react/jsx-runtime").JSX.Element;
+export interface RecordContextProviderProps<RecordType> {
+    children: ReactNode;
+    value?: RecordType;
+}

package/dist/ra-core/src/controller/record/RecordContext.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext } from 'react';
+/**
+ * Context to store a record.
+ *
+ * @see RecordContextProvider
+ * @see useRecordContext
+ */
+export const RecordContext = createContext(undefined);
+RecordContext.displayName = 'RecordContext';
+/**
+ * Provider for the Record Context, to store a record.
+ *
+ * Use the useRecordContext() hook to read the context.
+ * That's what the Edit and Show components do in react-admin.
+ *
+ * Many react-admin components read the RecordContext, including all Field
+ * components.
+ *
+ * @example
+ *
+ * import { useGetOne, RecordContextProvider } from '@strato-admin/ra-core';
+ *
+ * const Show = ({ resource, id }) => {
+ *     const { data } = useGetOne(resource, { id });
+ *     return (
+ *         <RecordContextProvider value={data}>
+ *             ...
+ *         </RecordContextProvider>
+ *     );
+ * };
+ */
+export const RecordContextProvider = ({ children, value, }) => (_jsx(RecordContext.Provider, { value: value, children: children }));

package/dist/ra-core/src/controller/record/RecordRepresentation.d.ts

@@ -0,0 +1,11 @@
+import { RaRecord } from '../../types';
+/**
+ * Render the record representation as specified on its parent <Resource>.
+ * @param props The component props
+ * @param {string} props.resource The resource name
+ * @param {RaRecord} props.record The record to render
+ */
+export declare const RecordRepresentation: (props: {
+    record?: RaRecord;
+    resource?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ra-core/src/controller/record/RecordRepresentation.js

@@ -0,0 +1,15 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useGetRecordRepresentation, useResourceContext } from '../../core';
+import { useRecordContext } from './useRecordContext';
+/**
+ * Render the record representation as specified on its parent <Resource>.
+ * @param props The component props
+ * @param {string} props.resource The resource name
+ * @param {RaRecord} props.record The record to render
+ */
+export const RecordRepresentation = (props) => {
+    const record = useRecordContext(props);
+    const resource = useResourceContext(props);
+    const getRecordRepresentation = useGetRecordRepresentation(resource);
+    return _jsx(_Fragment, { children: getRecordRepresentation(record) });
+};

package/dist/ra-core/src/controller/record/WithRecord.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+/**
+ * Render prop version of useRecordContext
+ *
+ * @example
+ * const BookShow = () => (
+ *    <Show>
+ *       <SimpleShowLayout>
+ *          <WithRecord render={record => <span>{record.title}</span>} />
+ *      </SimpleShowLayout>
+ *   </Show>
+ * );
+ */
+export declare const WithRecord: <RecordType extends Record<string, any> = any>({ render, empty, }: WithRecordProps<RecordType>) => string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
+export interface WithRecordProps<RecordType extends Record<string, any> = any> {
+    render: (record: RecordType) => ReactNode;
+    empty?: ReactNode;
+    label?: string;
+}

package/dist/ra-core/src/controller/record/WithRecord.js

@@ -0,0 +1,18 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useRecordContext } from './useRecordContext';
+/**
+ * Render prop version of useRecordContext
+ *
+ * @example
+ * const BookShow = () => (
+ *    <Show>
+ *       <SimpleShowLayout>
+ *          <WithRecord render={record => <span>{record.title}</span>} />
+ *      </SimpleShowLayout>
+ *   </Show>
+ * );
+ */
+export const WithRecord = ({ render, empty = null, }) => {
+    const record = useRecordContext();
+    return record ? _jsx(_Fragment, { children: render(record) }) : empty;
+};

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

@@ -0,0 +1,5 @@
+export * from './RecordContext';
+export * from './useRecordContext';
+export * from './WithRecord';
+export * from './OptionalRecordContextProvider';
+export * from './RecordRepresentation';

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

@@ -0,0 +1,5 @@
+export * from './RecordContext';
+export * from './useRecordContext';
+export * from './WithRecord';
+export * from './OptionalRecordContextProvider';
+export * from './RecordRepresentation';

package/dist/ra-core/src/controller/record/useRecordContext.d.ts

@@ -0,0 +1,34 @@
+import { RaRecord } from '../../types';
+/**
+ * Hook to read the record from a RecordContext.
+ *
+ * Must be used within a <RecordContext> such as provided by the <EditContextProvider>
+ * (e.g. as a descendent of <Edit> or <EditBase>) or within a <ShowContextProvider>
+ * (e.g. as a descendent of <Show> or <ShowBase>)
+ *
+ * @example // basic usage
+ *
+ * import { useRecordContext } from '@strato-admin/ra-core';
+ *
+ * const TitleField = () => {
+ *     const record = useRecordContext();
+ *     return <span>{record && record.title}</span>;
+ * };
+ *
+ * @example // allow record override via props
+ *
+ * import { useRecordContext } from '@strato-admin/ra-core';
+ *
+ * const TitleField = (props) => {
+ *     const record = useRecordContext(props);
+ *     return <span>{record && record.title}</span>;
+ * };
+ * render(<TextField record={record} />);
+ *
+ * @returns {RaRecord} A record object
+ */
+export declare const useRecordContext: <RecordType extends RaRecord | Omit<RaRecord, "id"> = RaRecord>(props?: UseRecordContextParams<RecordType>) => RecordType | undefined;
+export interface UseRecordContextParams<RecordType extends RaRecord | Omit<RaRecord, 'id'> = RaRecord> {
+    record?: RecordType;
+    [key: string]: any;
+}

package/dist/ra-core/src/controller/record/useRecordContext.js

@@ -0,0 +1,36 @@
+import { useContext } from 'react';
+import { RecordContext } from './RecordContext';
+/**
+ * Hook to read the record from a RecordContext.
+ *
+ * Must be used within a <RecordContext> such as provided by the <EditContextProvider>
+ * (e.g. as a descendent of <Edit> or <EditBase>) or within a <ShowContextProvider>
+ * (e.g. as a descendent of <Show> or <ShowBase>)
+ *
+ * @example // basic usage
+ *
+ * import { useRecordContext } from '@strato-admin/ra-core';
+ *
+ * const TitleField = () => {
+ *     const record = useRecordContext();
+ *     return <span>{record && record.title}</span>;
+ * };
+ *
+ * @example // allow record override via props
+ *
+ * import { useRecordContext } from '@strato-admin/ra-core';
+ *
+ * const TitleField = (props) => {
+ *     const record = useRecordContext(props);
+ *     return <span>{record && record.title}</span>;
+ * };
+ * render(<TextField record={record} />);
+ *
+ * @returns {RaRecord} A record object
+ */
+export const useRecordContext = (props) => {
+    // Can't find a way to specify the RecordType when CreateContext is declared
+    // @ts-ignore
+    const context = useContext(RecordContext);
+    return (props && props.record) || context;
+};

package/dist/ra-core/src/controller/saveContext/SaveContext.d.ts

@@ -0,0 +1,20 @@
+import { RaRecord, OnError, OnSuccess, TransformData, MutationMode } from '../../types';
+import { Middleware } from './useMutationMiddlewares';
+export interface SaveContextValue<RecordType extends RaRecord = any, MutateFunc extends (...args: any[]) => any = (...args: any[]) => any> {
+    save?: SaveHandler<RecordType>;
+    /**
+     * @deprecated. Rely on the form isSubmitting value instead
+     */
+    saving?: boolean;
+    mutationMode?: MutationMode;
+    registerMutationMiddleware?: (callback: Middleware<MutateFunc>) => void;
+    unregisterMutationMiddleware?: (callback: Middleware<MutateFunc>) => void;
+}
+export type SaveHandler<RecordType> = (record: Partial<RecordType>, callbacks?: SaveHandlerCallbacks) => Promise<void | RecordType> | Record<string, string>;
+export type SaveHandlerCallbacks = {
+    onSuccess?: OnSuccess;
+    onError?: OnError;
+    transform?: TransformData;
+    meta?: any;
+};
+export declare const SaveContext: import("react").Context<SaveContextValue<any, (...args: any[]) => any>>;

package/dist/ra-core/src/controller/saveContext/SaveContext.js

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

package/dist/ra-core/src/controller/saveContext/SaveContextProvider.d.ts

@@ -0,0 +1,4 @@
+export declare const SaveContextProvider: ({ children, value }: {
+    children: any;
+    value: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ra-core/src/controller/saveContext/SaveContextProvider.js

@@ -0,0 +1,3 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { SaveContext } from './SaveContext';
+export const SaveContextProvider = ({ children, value }) => (_jsx(SaveContext.Provider, { value: value, children: children }));

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

@@ -0,0 +1,6 @@
+export * from './SaveContext';
+export * from './SaveContextProvider';
+export * from './usePickSaveContext';
+export * from './useSaveContext';
+export * from './useMutationMiddlewares';
+export * from './useRegisterMutationMiddleware';

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

@@ -0,0 +1,6 @@
+export * from './SaveContext';
+export * from './SaveContextProvider';
+export * from './usePickSaveContext';
+export * from './useSaveContext';
+export * from './useMutationMiddlewares';
+export * from './useRegisterMutationMiddleware';

package/dist/ra-core/src/controller/saveContext/useMutationMiddlewares.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Internal hook used to handle mutation middlewares.
+ *
+ * @example
+ * // We have a form creating an order for a new customer.
+ * // The form contains the customer fields in addition to the order fields
+ * // but they should be saved as a new customer resource record
+ * // and the order should only reference this new customer
+ * type Order = { id: string; reference: string };
+ * type OrderCreateFormData = { id: string; reference: string; customer: Customer };
+ * type Customer = { id: string; email: string; firstName: string; lastName: string };
+ *
+ * const CustomerForm = props => {
+ *     const [createCustomer] = useCreate<Customer>();
+ *     const middleware: Middleware<UseCreateResult<OrderCreateFormData>[0]> = useCallback(async (resource, params, next) => {
+ *         const { data } = params;
+ *         const { user, ...orderData } = data;
+ *         const { data = newCustomer } = await createCustomer('customers', { data: user });
+ *         const orderDataWithCustomer = { ...orderData, customerId: newCustomer.id };
+ *         next(resource, { data: orderDataWithCustomer });
+ *     }, [createCustomer]);
+ *     useRegisterMutationMiddleware(middleware);
+ *
+ *     return (
+ *         <>
+ *             <TextInput source="user.email" />
+ *             <TextInput source="user.firstName" />
+ *             <TextInput source="user.lastName" />
+ *         </>
+ *     );
+ * }
+ */
+export declare const useMutationMiddlewares: <MutateFunc extends (...args: any[]) => any = (...args: any[]) => any>() => UseMutationMiddlewaresResult<MutateFunc>;
+export interface UseMutationMiddlewaresResult<MutateFunc extends (...args: any[]) => any = (...args: any[]) => any> {
+    registerMutationMiddleware: (callback: Middleware<MutateFunc>) => void;
+    getMutateWithMiddlewares: (mutate: MutateFunc) => (...args: Parameters<MutateFunc>) => ReturnType<MutateFunc>;
+    unregisterMutationMiddleware: (callback: Middleware<MutateFunc>) => void;
+}
+export type Middleware<MutateFunc = (...args: any[]) => any> = MutateFunc extends (...a: any[]) => infer R ? (...a: [...U: Parameters<MutateFunc>, next: MutateFunc]) => R : never;

package/dist/ra-core/src/controller/saveContext/useMutationMiddlewares.js

@@ -0,0 +1,79 @@
+import { useCallback, useMemo, useRef } from 'react';
+/**
+ * Internal hook used to handle mutation middlewares.
+ *
+ * @example
+ * // We have a form creating an order for a new customer.
+ * // The form contains the customer fields in addition to the order fields
+ * // but they should be saved as a new customer resource record
+ * // and the order should only reference this new customer
+ * type Order = { id: string; reference: string };
+ * type OrderCreateFormData = { id: string; reference: string; customer: Customer };
+ * type Customer = { id: string; email: string; firstName: string; lastName: string };
+ *
+ * const CustomerForm = props => {
+ *     const [createCustomer] = useCreate<Customer>();
+ *     const middleware: Middleware<UseCreateResult<OrderCreateFormData>[0]> = useCallback(async (resource, params, next) => {
+ *         const { data } = params;
+ *         const { user, ...orderData } = data;
+ *         const { data = newCustomer } = await createCustomer('customers', { data: user });
+ *         const orderDataWithCustomer = { ...orderData, customerId: newCustomer.id };
+ *         next(resource, { data: orderDataWithCustomer });
+ *     }, [createCustomer]);
+ *     useRegisterMutationMiddleware(middleware);
+ *
+ *     return (
+ *         <>
+ *             <TextInput source="user.email" />
+ *             <TextInput source="user.firstName" />
+ *             <TextInput source="user.lastName" />
+ *         </>
+ *     );
+ * }
+ */
+export const useMutationMiddlewares = () => {
+    const callbacks = useRef([]);
+    const registerMutationMiddleware = useCallback((callback) => {
+        callbacks.current.push(callback);
+    }, []);
+    const unregisterMutationMiddleware = useCallback((callback) => {
+        callbacks.current = callbacks.current.filter(cb => cb !== callback);
+    }, []);
+    const getMutateWithMiddlewares = useCallback((fn) => {
+        // Stores the current callbacks in a closure to avoid losing them if the calling component is unmounted
+        const currentCallbacks = [...callbacks.current];
+        return (...args) => {
+            let index = currentCallbacks.length - 1;
+            // Called by middlewares to call the next middleware function
+            // Should take the same arguments as the original mutation function
+            const next = (...newArgs) => {
+                // Decrement the middlewares counter so that when next is called again, we
+                // call the next middleware
+                index--;
+                // If there are no more middlewares, we call the original mutation function
+                if (index >= 0) {
+                    return currentCallbacks[index](...newArgs, next);
+                }
+                else {
+                    return fn(...newArgs);
+                }
+            };
+            if (currentCallbacks.length > 0) {
+                // Call the first middleware with the same args as the original mutation function
+                // with an additional next function
+                return currentCallbacks[index](...args, next);
+            }
+            return fn(...args);
+        };
+    }, []);
+    const functions = useMemo(() => ({
+        registerMutationMiddleware,
+        getMutateWithMiddlewares,
+        unregisterMutationMiddleware,
+    }), [
+        registerMutationMiddleware,
+        getMutateWithMiddlewares,
+        unregisterMutationMiddleware,
+    ]);
+    return functions;
+};

package/dist/ra-core/src/controller/saveContext/usePickSaveContext.d.ts

@@ -0,0 +1,5 @@
+import { SaveContextValue } from './SaveContext';
+/**
+ * This hook extracts the `save`, `saving` and mutationMode properties from either the `CreateContext` or `EditContext`. This ensures the `SaveContext` doesn't rerender when those two contexts have other properties changes.
+ */
+export declare const usePickSaveContext: <ContextType extends SaveContextValue = SaveContextValue>(context: ContextType) => SaveContextValue;

package/dist/ra-core/src/controller/saveContext/usePickSaveContext.js

@@ -0,0 +1,25 @@
+import { useMemo } from 'react';
+import pick from 'lodash/pick.js';
+/**
+ * This hook extracts the `save`, `saving` and mutationMode properties from either the `CreateContext` or `EditContext`. This ensures the `SaveContext` doesn't rerender when those two contexts have other properties changes.
+ */
+export const usePickSaveContext = (context) => {
+    const value = useMemo(() => pick(context, [
+        'save',
+        'saving',
+        'mutationMode',
+        'registerMutationMiddleware',
+        'unregisterMutationMiddleware',
+    ]), 
+    /* eslint-disable react-hooks/exhaustive-deps */
+    [
+        context.save,
+        context.saving,
+        context.mutationMode,
+        context.registerMutationMiddleware,
+        context.unregisterMutationMiddleware,
+    ]
+    /* eslint-enable react-hooks/exhaustive-deps */
+    );
+    return value;
+};

package/dist/ra-core/src/controller/saveContext/useRegisterMutationMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { Middleware } from './useMutationMiddlewares';
+/**
+ * Internal hook that registers a middleware for the save function in the current SaveContext.
+ * @param callback The middleware function.
+ */
+export declare const useRegisterMutationMiddleware: <MutateFunc extends (...args: any[]) => any = (...args: any[]) => any>(callback: Middleware<MutateFunc>) => void;