@strato-admin/core 0.1.0 → 0.3.0

package/dist/ra-core/src/controller/button/useBulkDeleteController.js

@@ -0,0 +1,66 @@
+import { useCallback, useMemo } from 'react';
+import { useDeleteMany, } from '../../dataProvider/useDeleteMany';
+import { useRefresh } from '../../dataProvider/useRefresh';
+import { useListContext } from '../list/useListContext';
+import { useNotify } from '../../notification/useNotify';
+import { useResourceContext } from '../../core/useResourceContext';
+import { useTranslate } from '../../i18n/useTranslate';
+export const useBulkDeleteController = (props) => {
+    const { mutationMode = 'undoable', mutationOptions = {}, successMessage, } = props;
+    const { meta: mutationMeta, ...otherMutationOptions } = mutationOptions;
+    const resource = useResourceContext(props);
+    const notify = useNotify();
+    const refresh = useRefresh();
+    const translate = useTranslate();
+    const { selectedIds, onUnselectItems } = useListContext();
+    const [deleteMany, { isPending }] = useDeleteMany(resource, undefined, {
+        onSuccess: () => {
+            notify(successMessage ??
+                `resources.${resource}.notifications.deleted`, {
+                type: 'info',
+                messageArgs: {
+                    smart_count: selectedIds.length,
+                    _: translate("strato.notification.deleted', {
+                        smart_count: selectedIds.length,
+                    }),
+                },
+                undoable: mutationMode === 'undoable',
+            });
+            onUnselectItems(true);
+        },
+        onError: (error) => {
+            notify(typeof error === 'string'
+                ? error
+                : error?.message || "strato.notification.http_error', {
+                type: 'error',
+                messageArgs: {
+                    _: typeof error === 'string'
+                        ? error
+                        : error?.message,
+                },
+            });
+            refresh();
+        },
+    });
+    const handleDelete = useCallback(() => {
+        deleteMany(resource, {
+            ids: selectedIds,
+            meta: mutationMeta,
+        }, {
+            mutationMode,
+            ...otherMutationOptions,
+        });
+    }, [
+        deleteMany,
+        mutationMeta,
+        mutationMode,
+        otherMutationOptions,
+        resource,
+        selectedIds,
+    ]);
+    return useMemo(() => ({
+        isPending,
+        isLoading: isPending,
+        handleDelete,
+    }), [isPending, handleDelete]);
+};

package/dist/ra-core/src/controller/button/useBulkUpdateController.d.ts

@@ -0,0 +1,16 @@
+import { RaRecord, MutationMode } from '../../types';
+import { UseUpdateManyOptions } from '../../dataProvider/useUpdateMany';
+export declare const useBulkUpdateController: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseBulkUpdateControllerParams<RecordType, ErrorType>) => UseBulkUpdateControllerReturn;
+export interface UseBulkUpdateControllerParams<RecordType extends RaRecord = any, MutationOptionsError = unknown> {
+    onSuccess?: () => void;
+    onError?: (error: any) => void;
+    mutationMode?: MutationMode;
+    mutationOptions?: UseUpdateManyOptions<RecordType, MutationOptionsError>;
+    resource?: string;
+    successMessage?: string;
+}
+export interface UseBulkUpdateControllerReturn<RecordType extends RaRecord = any> {
+    isLoading: boolean;
+    isPending: boolean;
+    handleUpdate: (data: Partial<RecordType>) => void;
+}

package/dist/ra-core/src/controller/button/useBulkUpdateController.js

@@ -0,0 +1,70 @@
+import { useCallback, useMemo } from 'react';
+import { useRefresh } from '../../dataProvider/useRefresh';
+import { useListContext } from '../list/useListContext';
+import { useNotify } from '../../notification/useNotify';
+import { useResourceContext } from '../../core/useResourceContext';
+import { useTranslate } from '../../i18n/useTranslate';
+import { useUpdateMany, } from '../../dataProvider/useUpdateMany';
+export const useBulkUpdateController = (props) => {
+    const { onSuccess, onError, mutationMode = 'undoable', mutationOptions = {}, successMessage, } = props;
+    const { meta: mutationMeta, ...otherMutationOptions } = mutationOptions;
+    const resource = useResourceContext(props);
+    const notify = useNotify();
+    const refresh = useRefresh();
+    const translate = useTranslate();
+    const { selectedIds, onUnselectItems } = useListContext();
+    const [updateMany, { isPending }] = useUpdateMany(resource, undefined, {
+        onSuccess: onSuccess ??
+            (() => {
+                notify(successMessage ??
+                    `resources.${resource}.notifications.updated`, {
+                    type: 'info',
+                    messageArgs: {
+                        smart_count: selectedIds.length,
+                        _: translate("strato.notification.updated', {
+                            smart_count: selectedIds.length,
+                        }),
+                    },
+                    undoable: mutationMode === 'undoable',
+                });
+                onUnselectItems();
+            }),
+        onError: onError ??
+            ((error) => {
+                notify(typeof error === 'string'
+                    ? error
+                    : error?.message || "strato.notification.http_error', {
+                    type: 'error',
+                    messageArgs: {
+                        _: typeof error === 'string'
+                            ? error
+                            : error?.message,
+                    },
+                });
+                refresh();
+            }),
+        ...otherMutationOptions,
+    });
+    const handleUpdate = useCallback((data) => {
+        updateMany(resource, {
+            data,
+            ids: selectedIds,
+            meta: mutationMeta,
+        }, {
+            mutationMode,
+            ...otherMutationOptions,
+        });
+    }, [
+        updateMany,
+        mutationMeta,
+        mutationMode,
+        otherMutationOptions,
+        resource,
+        selectedIds,
+    ]);
+    return useMemo(() => ({
+        isPending,
+        isLoading: isPending,
+        handleUpdate,
+    }), [isPending, handleUpdate]);
+};

package/dist/ra-core/src/controller/button/useDeleteController.d.ts

@@ -0,0 +1,64 @@
+import { UseDeleteOptions } from '../../dataProvider/useDelete';
+import { RedirectionSideEffect } from '../../routing/useRedirect';
+import { RaRecord, MutationMode } from '../../types';
+/**
+ * Prepare a set of callbacks for a delete button
+ *
+ * @example
+ * const DeleteButton = ({
+ *     redirect,
+ *     ...rest
+ * }) => {
+ *     const {
+ *         isPending,
+ *         handleDelete,
+ *     } = useDeleteController({
+ *         mutationMode: 'pessimistic',
+ *         redirect,
+ *     });
+ *
+ *     const [open, setOpen] = useState(false);
+ *
+ *     return (
+ *         <Fragment>
+ *             <Button
+ *                 onClick={() => setOpen(true)}
+ *                 label="strato.action.delete"
+ *                 {...rest}
+ *             >
+ *                 {icon}
+ *             </Button>
+ *             <Confirm
+ *                 isOpen={open}
+ *                 loading={isPending}
+ *                 title="strato.message.delete_title"
+ *                 content="strato.message.delete_content"
+ *                 titleTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 contentTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 onConfirm={() => handleDelete()}
+ *                 onClose={() => setOpen(false)}
+ *             />
+ *         </Fragment>
+ *     );
+ * };
+ */
+export declare const useDeleteController: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseDeleteControllerParams<RecordType, ErrorType>) => UseDeleteControllerReturn;
+export interface UseDeleteControllerParams<RecordType extends RaRecord = any, MutationOptionsError = unknown> {
+    mutationMode?: MutationMode;
+    mutationOptions?: UseDeleteOptions<RecordType, MutationOptionsError>;
+    record?: RecordType;
+    redirect?: RedirectionSideEffect;
+    resource?: string;
+    successMessage?: string;
+}
+export interface UseDeleteControllerReturn {
+    isLoading: boolean;
+    isPending: boolean;
+    handleDelete: () => void;
+}

package/dist/ra-core/src/controller/button/useDeleteController.js

@@ -0,0 +1,119 @@
+import { useCallback, useMemo } from 'react';
+import { useDelete } from '../../dataProvider/useDelete';
+import { useUnselect } from '../list/useUnselect';
+import { useRecordContext } from '../record/useRecordContext';
+import { useRedirect } from '../../routing/useRedirect';
+import { useNotify } from '../../notification/useNotify';
+import { useResourceContext } from '../../core/useResourceContext';
+import { useTranslate } from '../../i18n/useTranslate';
+/**
+ * Prepare a set of callbacks for a delete button
+ *
+ * @example
+ * const DeleteButton = ({
+ *     redirect,
+ *     ...rest
+ * }) => {
+ *     const {
+ *         isPending,
+ *         handleDelete,
+ *     } = useDeleteController({
+ *         mutationMode: 'pessimistic',
+ *         redirect,
+ *     });
+ *
+ *     const [open, setOpen] = useState(false);
+ *
+ *     return (
+ *         <Fragment>
+ *             <Button
+ *                 onClick={() => setOpen(true)}
+ *                 label="strato.action.delete"
+ *                 {...rest}
+ *             >
+ *                 {icon}
+ *             </Button>
+ *             <Confirm
+ *                 isOpen={open}
+ *                 loading={isPending}
+ *                 title="strato.message.delete_title"
+ *                 content="strato.message.delete_content"
+ *                 titleTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 contentTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 onConfirm={() => handleDelete()}
+ *                 onClose={() => setOpen(false)}
+ *             />
+ *         </Fragment>
+ *     );
+ * };
+ */
+export const useDeleteController = (props) => {
+    const { redirect: redirectTo = 'list', mutationMode = 'undoable', mutationOptions = {}, successMessage, } = props;
+    const { meta: mutationMeta, ...otherMutationOptions } = mutationOptions;
+    const record = useRecordContext(props);
+    const resource = useResourceContext(props);
+    const notify = useNotify();
+    const unselect = useUnselect(resource);
+    const redirect = useRedirect();
+    const translate = useTranslate();
+    const [deleteOne, { isPending }] = useDelete(resource, undefined, {
+        onSuccess: () => {
+            notify(successMessage ??
+                `resources.${resource}.notifications.deleted`, {
+                type: 'info',
+                messageArgs: {
+                    smart_count: 1,
+                    _: translate("strato.notification.deleted', {
+                        smart_count: 1,
+                    }),
+                },
+                undoable: mutationMode === 'undoable',
+            });
+            record && unselect([record.id], true);
+            redirect(redirectTo, resource);
+        },
+        onError: (error) => {
+            notify(typeof error === 'string'
+                ? error
+                : error?.message || "strato.notification.http_error', {
+                type: 'error',
+                messageArgs: {
+                    _: typeof error === 'string'
+                        ? error
+                        : error?.message,
+                },
+            });
+        },
+    });
+    const handleDelete = useCallback(() => {
+        if (!record) {
+            throw new Error('The record cannot be deleted because no record has been passed');
+        }
+        deleteOne(resource, {
+            id: record.id,
+            previousData: record,
+            meta: mutationMeta,
+        }, {
+            mutationMode,
+            ...otherMutationOptions,
+        });
+    }, [
+        deleteOne,
+        mutationMeta,
+        mutationMode,
+        otherMutationOptions,
+        record,
+        resource,
+    ]);
+    return useMemo(() => ({
+        isPending,
+        isLoading: isPending,
+        handleDelete,
+    }), [isPending, handleDelete]);
+};

package/dist/ra-core/src/controller/button/useDeleteWithConfirmController.d.ts

@@ -0,0 +1,69 @@
+import { ReactEventHandler, SyntheticEvent } from 'react';
+import { UseDeleteControllerParams, UseDeleteControllerReturn } from '../';
+import { RaRecord } from '../../types';
+/**
+ * Prepare a set of callbacks for a delete button guarded by confirmation dialog
+ * @deprecated prefer the useDeleteController hook instead
+ *
+ * @example
+ *
+ * const DeleteButton = ({
+ *     resource,
+ *     record,
+ *     redirect,
+ *     onClick,
+ *     ...rest
+ * }) => {
+ *     const {
+ *         open,
+ *         isPending,
+ *         handleDialogOpen,
+ *         handleDialogClose,
+ *         handleDelete,
+ *     } = useDeleteWithConfirmController({
+ *         resource,
+ *         record,
+ *         redirect,
+ *         onClick,
+ *     });
+ *
+ *     return (
+ *         <Fragment>
+ *             <Button
+ *                 onClick={handleDialogOpen}
+ *                 label="strato.action.delete"
+ *                 {...rest}
+ *             >
+ *                 {icon}
+ *             </Button>
+ *             <Confirm
+ *                 isOpen={open}
+ *                 loading={isPending}
+ *                 title="strato.message.delete_title"
+ *                 content="strato.message.delete_content"
+ *                 titleTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 contentTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 onConfirm={handleDelete}
+ *                 onClose={handleDialogClose}
+ *             />
+ *         </Fragment>
+ *     );
+ * };
+ */
+declare const useDeleteWithConfirmController: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseDeleteWithConfirmControllerParams<RecordType, ErrorType>) => UseDeleteWithConfirmControllerReturn;
+export interface UseDeleteWithConfirmControllerParams<RecordType extends RaRecord = any, MutationOptionsError = unknown> extends UseDeleteControllerParams<RecordType, MutationOptionsError> {
+    onClick?: ReactEventHandler<any>;
+}
+export interface UseDeleteWithConfirmControllerReturn extends Omit<UseDeleteControllerReturn, 'handleDelete'> {
+    open: boolean;
+    handleDialogOpen: (e: SyntheticEvent) => void;
+    handleDialogClose: (e: SyntheticEvent) => void;
+    handleDelete: ReactEventHandler<any>;
+}
+export default useDeleteWithConfirmController;

package/dist/ra-core/src/controller/button/useDeleteWithConfirmController.js

@@ -0,0 +1,139 @@
+import { useState } from 'react';
+import { useDeleteController, useUnselect, } from '../';
+import { useRedirect } from '../../routing';
+import { useNotify } from '../../notification';
+import { useResourceContext } from '../../core';
+import { useTranslate } from '../../i18n';
+import { useEvent } from '../../util';
+/**
+ * Prepare a set of callbacks for a delete button guarded by confirmation dialog
+ * @deprecated prefer the useDeleteController hook instead
+ *
+ * @example
+ *
+ * const DeleteButton = ({
+ *     resource,
+ *     record,
+ *     redirect,
+ *     onClick,
+ *     ...rest
+ * }) => {
+ *     const {
+ *         open,
+ *         isPending,
+ *         handleDialogOpen,
+ *         handleDialogClose,
+ *         handleDelete,
+ *     } = useDeleteWithConfirmController({
+ *         resource,
+ *         record,
+ *         redirect,
+ *         onClick,
+ *     });
+ *
+ *     return (
+ *         <Fragment>
+ *             <Button
+ *                 onClick={handleDialogOpen}
+ *                 label="strato.action.delete"
+ *                 {...rest}
+ *             >
+ *                 {icon}
+ *             </Button>
+ *             <Confirm
+ *                 isOpen={open}
+ *                 loading={isPending}
+ *                 title="strato.message.delete_title"
+ *                 content="strato.message.delete_content"
+ *                 titleTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 contentTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 onConfirm={handleDelete}
+ *                 onClose={handleDialogClose}
+ *             />
+ *         </Fragment>
+ *     );
+ * };
+ */
+const useDeleteWithConfirmController = (props) => {
+    const { mutationMode, onClick, record, redirect: redirectTo = 'list', successMessage, mutationOptions = {}, ...rest } = props;
+    const [open, setOpen] = useState(false);
+    const resource = useResourceContext(props);
+    const notify = useNotify();
+    const unselect = useUnselect(resource);
+    const redirect = useRedirect();
+    const translate = useTranslate();
+    const { isPending, handleDelete: controllerHandleDelete } = useDeleteController({
+        mutationMode,
+        mutationOptions: {
+            onSuccess: () => {
+                setOpen(false);
+                notify(successMessage ??
+                    `resources.${resource}.notifications.deleted`, {
+                    type: 'info',
+                    messageArgs: {
+                        smart_count: 1,
+                        _: translate("strato.notification.deleted', {
+                            smart_count: 1,
+                        }),
+                    },
+                    undoable: mutationMode === 'undoable',
+                });
+                record && unselect([record.id], true);
+                redirect(redirectTo, resource);
+            },
+            onError: error => {
+                setOpen(false);
+                notify(typeof error === 'string'
+                    ? error
+                    : error?.message ||
+                        "strato.notification.http_error', {
+                    type: 'error',
+                    messageArgs: {
+                        _: typeof error === 'string'
+                            ? error
+                            : error?.message
+                                ? error.message
+                                : undefined,
+                    },
+                });
+            },
+            ...mutationOptions,
+        },
+        record,
+        redirect: redirectTo,
+        successMessage,
+        ...rest,
+    });
+    const handleDialogOpen = useEvent((e) => {
+        e.stopPropagation();
+        setOpen(true);
+    });
+    const handleDialogClose = useEvent((e) => {
+        e.stopPropagation();
+        setOpen(false);
+    });
+    const handleDelete = useEvent((event) => {
+        if (event && event.stopPropagation) {
+            event.stopPropagation();
+        }
+        controllerHandleDelete();
+        if (typeof onClick === 'function') {
+            onClick(event);
+        }
+    });
+    return {
+        open,
+        isPending,
+        isLoading: isPending,
+        handleDialogOpen,
+        handleDialogClose,
+        handleDelete,
+    };
+};
+export default useDeleteWithConfirmController;

package/dist/ra-core/src/controller/button/useDeleteWithUndoController.d.ts

@@ -0,0 +1,46 @@
+import type { ReactEventHandler } from 'react';
+import { type UseDeleteControllerParams, type UseDeleteControllerReturn } from './useDeleteController';
+import type { RaRecord } from '../../types';
+/**
+ * Prepare callback for a Delete button with undo support
+ * @deprecated prefer the useDeleteController hook instead
+ * @example
+ *
+ * import React from 'react';
+ * import ActionDelete from '@mui/icons-material/Delete';
+ * import { Button, useDeleteWithUndoController } from 'react-admin';
+ *
+ * const DeleteButton = ({
+ *     resource,
+ *     record,
+ *     redirect,
+ *     onClick,
+ *     ...rest
+ * }) => {
+ *     const { isPending, handleDelete } = useDeleteWithUndoController({
+ *         resource,
+ *         record,
+ *         redirect,
+ *         onClick,
+ *     });
+ *
+ *     return (
+ *         <Button
+ *             onClick={handleDelete}
+ *             disabled={isPending}
+ *             label="strato.action.delete"
+ *             {...rest}
+ *         >
+ *             <ActionDelete />
+ *         </Button>
+ *     );
+ * };
+ */
+declare const useDeleteWithUndoController: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseDeleteWithUndoControllerParams<RecordType, ErrorType>) => UseDeleteWithUndoControllerReturn;
+export interface UseDeleteWithUndoControllerParams<RecordType extends RaRecord = any, MutationOptionsError = unknown> extends Omit<UseDeleteControllerParams<RecordType, MutationOptionsError>, 'mutationMode'> {
+    onClick?: ReactEventHandler<any>;
+}
+export interface UseDeleteWithUndoControllerReturn extends Omit<UseDeleteControllerReturn, 'handleDelete'> {
+    handleDelete: ReactEventHandler<any>;
+}
+export default useDeleteWithUndoController;

package/dist/ra-core/src/controller/button/useDeleteWithUndoController.js

@@ -0,0 +1,52 @@
+import { useDeleteController, } from './useDeleteController';
+import { useEvent } from '../../util';
+/**
+ * Prepare callback for a Delete button with undo support
+ * @deprecated prefer the useDeleteController hook instead
+ * @example
+ *
+ * import React from 'react';
+ * import ActionDelete from '@mui/icons-material/Delete';
+ * import { Button, useDeleteWithUndoController } from 'react-admin';
+ *
+ * const DeleteButton = ({
+ *     resource,
+ *     record,
+ *     redirect,
+ *     onClick,
+ *     ...rest
+ * }) => {
+ *     const { isPending, handleDelete } = useDeleteWithUndoController({
+ *         resource,
+ *         record,
+ *         redirect,
+ *         onClick,
+ *     });
+ *
+ *     return (
+ *         <Button
+ *             onClick={handleDelete}
+ *             disabled={isPending}
+ *             label="strato.action.delete"
+ *             {...rest}
+ *         >
+ *             <ActionDelete />
+ *         </Button>
+ *     );
+ * };
+ */
+const useDeleteWithUndoController = (props) => {
+    const { onClick } = props;
+    const { isPending, handleDelete: controllerHandleDelete } = useDeleteController({ ...props, mutationMode: 'undoable' });
+    const handleDelete = useEvent((event) => {
+        if (event && event.stopPropagation) {
+            event.stopPropagation();
+        }
+        controllerHandleDelete();
+        if (typeof onClick === 'function') {
+            onClick(event);
+        }
+    });
+    return { isPending, isLoading: isPending, handleDelete };
+};
+export default useDeleteWithUndoController;