@strato-admin/core 0.1.1 → 0.3.0

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

@@ -0,0 +1,68 @@
+import { UseUpdateOptions } from '../../dataProvider/useUpdate';
+import { RedirectionSideEffect } from '../../routing/useRedirect';
+import { RaRecord, MutationMode } from '../../types';
+/**
+ * Prepare a set of callbacks for an update button
+ *
+ * @example
+ * const UpdateButton = ({
+ *     resource,
+ *     record,
+ *     redirect,
+ *     ...rest
+ * }) => {
+ *     const {
+ *         isPending,
+ *         handleUpdate,
+ *     } = useUpdateController({
+ *         mutationMode: 'pessimistic',
+ *         resource,
+ *         record,
+ *         redirect,
+ *     });
+ *
+ *     const [open, setOpen] = useState(false);
+ *
+ *     return (
+ *         <Fragment>
+ *             <Button
+ *                 onClick={() => setOpen(true)}
+ *                 label="strato.action.update"
+ *                 {...rest}
+ *             >
+ *                 {icon}
+ *             </Button>
+ *             <Confirm
+ *                 isOpen={open}
+ *                 loading={isPending}
+ *                 title="strato.message.update_title"
+ *                 content="strato.message.update_content"
+ *                 titleTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 contentTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 onConfirm={() => handleUpdate()}
+ *                 onClose={() => setOpen(false)}
+ *             />
+ *         </Fragment>
+ *     );
+ * };
+ */
+export declare const useUpdateController: <RecordType extends RaRecord = any, ErrorType = Error>(props: UseUpdateControllerParams<RecordType, ErrorType>) => UseUpdateControllerReturn<RecordType>;
+export interface UseUpdateControllerParams<RecordType extends RaRecord = any, MutationOptionsError = unknown> {
+    mutationMode?: MutationMode;
+    mutationOptions?: UseUpdateOptions<RecordType, MutationOptionsError>;
+    record?: RecordType;
+    redirect?: RedirectionSideEffect;
+    resource?: string;
+    successMessage?: string;
+}
+export interface UseUpdateControllerReturn<RecordType extends RaRecord = any> {
+    isLoading: boolean;
+    isPending: boolean;
+    handleUpdate: (data: Partial<RecordType>) => void;
+}

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

@@ -0,0 +1,113 @@
+import { useCallback, useMemo } from 'react';
+import { useUpdate } from '../../dataProvider/useUpdate';
+import { useRedirect } from '../../routing/useRedirect';
+import { useNotify } from '../../notification/useNotify';
+import { useRecordContext } from '../record/useRecordContext';
+import { useResourceContext } from '../../core/useResourceContext';
+import { useTranslate } from '../../i18n/useTranslate';
+/**
+ * Prepare a set of callbacks for an update button
+ *
+ * @example
+ * const UpdateButton = ({
+ *     resource,
+ *     record,
+ *     redirect,
+ *     ...rest
+ * }) => {
+ *     const {
+ *         isPending,
+ *         handleUpdate,
+ *     } = useUpdateController({
+ *         mutationMode: 'pessimistic',
+ *         resource,
+ *         record,
+ *         redirect,
+ *     });
+ *
+ *     const [open, setOpen] = useState(false);
+ *
+ *     return (
+ *         <Fragment>
+ *             <Button
+ *                 onClick={() => setOpen(true)}
+ *                 label="strato.action.update"
+ *                 {...rest}
+ *             >
+ *                 {icon}
+ *             </Button>
+ *             <Confirm
+ *                 isOpen={open}
+ *                 loading={isPending}
+ *                 title="strato.message.update_title"
+ *                 content="strato.message.update_content"
+ *                 titleTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 contentTranslateOptions={{
+ *                     name: resource,
+ *                     id: record.id,
+ *                 }}
+ *                 onConfirm={() => handleUpdate()}
+ *                 onClose={() => setOpen(false)}
+ *             />
+ *         </Fragment>
+ *     );
+ * };
+ */
+export const useUpdateController = (props) => {
+    const { redirect: redirectTo = false, mutationMode = 'undoable', mutationOptions = {}, successMessage, } = props;
+    const { meta: mutationMeta, ...otherMutationOptions } = mutationOptions;
+    const record = useRecordContext(props);
+    const resource = useResourceContext(props);
+    const notify = useNotify();
+    const redirect = useRedirect();
+    const translate = useTranslate();
+    const [updateOne, { isPending }] = useUpdate(resource, undefined, {
+        onSuccess: () => {
+            notify(successMessage ??
+                `resources.${resource}.notifications.updated`, {
+                type: 'info',
+                messageArgs: {
+                    smart_count: 1,
+                    _: translate("strato.notification.updated', {
+                        smart_count: 1,
+                    }),
+                },
+                undoable: mutationMode === 'undoable',
+            });
+            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,
+                },
+            });
+        },
+        mutationMode,
+        ...otherMutationOptions,
+    });
+    const handleUpdate = useCallback((data) => {
+        if (!record) {
+            throw new Error('The record cannot be updated because no record has been passed');
+        }
+        updateOne(resource, {
+            id: record.id,
+            data,
+            previousData: record,
+            meta: mutationMeta,
+        });
+    }, [updateOne, mutationMeta, record, resource]);
+    return useMemo(() => ({
+        isPending,
+        isLoading: isPending,
+        handleUpdate,
+    }), [isPending, handleUpdate]);
+};

package/dist/ra-core/src/controller/checkMinimumRequiredProps.d.ts

@@ -0,0 +1,4 @@
+import { ComponentType } from 'react';
+declare const checkMinimumRequiredProps: (displayName: string, requiredProps: string[]) => (WrappedComponent: ComponentType) => (props: any) => import("react/jsx-runtime").JSX.Element;
+export default checkMinimumRequiredProps;
+export declare const useCheckMinimumRequiredProps: (displayName: string, requiredProps: string[], props: any) => void;

package/dist/ra-core/src/controller/checkMinimumRequiredProps.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const checkMinimumRequiredProps = (displayName, requiredProps) => (WrappedComponent) => (props) => {
+    useCheckMinimumRequiredProps(displayName, requiredProps, props);
+    return _jsx(WrappedComponent, { ...props });
+};
+export default checkMinimumRequiredProps;
+// Not a hook but named that way to avoid conflicts with the old one
+export const useCheckMinimumRequiredProps = (displayName, requiredProps, props) => {
+    const propNames = Object.keys(props);
+    const missingProps = requiredProps.filter(prop => !propNames.includes(prop));
+    if (missingProps.length > 0) {
+        throw new Error(`<${displayName}> component is not properly configured, some essential props are missing.
+Be sure to pass the props from the parent. Example:
+
+const My${displayName} = props => (
+    <${displayName} {...props}></${displayName}>
+);
+
+The missing props are: ${missingProps.join(', ')}`);
+    }
+};

package/dist/ra-core/src/controller/create/CreateBase.d.ts

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+import { CreateControllerProps, CreateControllerResult } from './useCreateController';
+import { Identifier, RaRecord } from '../../types';
+/**
+ * Call useCreateController and put the value in a CreateContext
+ *
+ * Base class for <Create> components, without UI.
+ *
+ * Accepts any props accepted by useCreateController:
+ * - id: The record identifier
+ * - resource: The resource
+ *
+ * @example // Custom edit layout
+ *
+ * const PostCreate = () => (
+ *     <CreateBase>
+ *         <Grid container>
+ *             <Grid item xs={8}>
+ *                 <SimpleForm>
+ *                     ...
+ *                 </SimpleForm>
+ *             </Grid>
+ *             <Grid item xs={4}>
+ *                 Create instructions...
+ *             </Grid>
+ *         </Grid>
+ *         <div>
+ *             Post related links...
+ *         </div>
+ *     </CreateBase>
+ * );
+ */
+export declare const CreateBase: <RecordType extends Omit<RaRecord, "id"> = any, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}, MutationOptionsError = Error>({ children, render, loading, authLoading, ...props }: CreateBaseProps<RecordType, ResultRecordType, MutationOptionsError>) => import("react/jsx-runtime").JSX.Element;
+export interface CreateBaseProps<RecordType extends Omit<RaRecord, 'id'> = any, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}, MutationOptionsError = Error> extends CreateControllerProps<RecordType, MutationOptionsError, ResultRecordType> {
+    children?: ReactNode;
+    render?: (props: CreateControllerResult<RecordType>) => ReactNode;
+    authLoading?: ReactNode;
+    /**
+     * @deprecated use authLoading instead
+     */
+    loading?: ReactNode;
+}

package/dist/ra-core/src/controller/create/CreateBase.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCreateController, } from './useCreateController';
+import { CreateContextProvider } from './CreateContextProvider';
+import { OptionalResourceContextProvider } from '../../core';
+import { useIsAuthPending } from '../../auth';
+/**
+ * Call useCreateController and put the value in a CreateContext
+ *
+ * Base class for <Create> components, without UI.
+ *
+ * Accepts any props accepted by useCreateController:
+ * - id: The record identifier
+ * - resource: The resource
+ *
+ * @example // Custom edit layout
+ *
+ * const PostCreate = () => (
+ *     <CreateBase>
+ *         <Grid container>
+ *             <Grid item xs={8}>
+ *                 <SimpleForm>
+ *                     ...
+ *                 </SimpleForm>
+ *             </Grid>
+ *             <Grid item xs={4}>
+ *                 Create instructions...
+ *             </Grid>
+ *         </Grid>
+ *         <div>
+ *             Post related links...
+ *         </div>
+ *     </CreateBase>
+ * );
+ */
+export const CreateBase = ({ children, render, loading, authLoading = loading, ...props }) => {
+    const controllerProps = useCreateController(props);
+    const isAuthPending = useIsAuthPending({
+        resource: controllerProps.resource,
+        action: 'create',
+    });
+    if (!render && !children) {
+        throw new Error('<CreateBase> requires either a `render` prop or `children` prop');
+    }
+    const showAuthLoading = isAuthPending &&
+        !props.disableAuthentication &&
+        authLoading !== false &&
+        authLoading !== undefined;
+    return (
+    // We pass props.resource here as we don't need to create a new ResourceContext if the props is not provided
+    _jsx(OptionalResourceContextProvider, { value: props.resource, children: _jsx(CreateContextProvider, { value: controllerProps, children: showAuthLoading
+                ? authLoading
+                : render
+                    ? render(controllerProps)
+                    : children }) }));
+};

package/dist/ra-core/src/controller/create/CreateContext.d.ts

@@ -0,0 +1,20 @@
+import { CreateControllerResult } from './useCreateController';
+/**
+ * Context to store the result of the useCreateController() hook.
+ *
+ * Use the useCreateContext() hook to read the context. That's what the Create components do in react-admin.
+ *
+ * @example
+ *
+ * import { useCreateController, CreateContextProvider } from '@strato-admin/ra-core';
+ *
+ * const Create = props => {
+ *     const controllerProps = useCreateController(props);
+ *     return (
+ *         <CreateContextProvider value={controllerProps}>
+ *             ...
+ *         </CreateContextProvider>
+ *     );
+ * };
+ */
+export declare const CreateContext: import("react").Context<CreateControllerResult<any> | null>;

package/dist/ra-core/src/controller/create/CreateContext.js

@@ -0,0 +1,21 @@
+import { createContext } from 'react';
+/**
+ * Context to store the result of the useCreateController() hook.
+ *
+ * Use the useCreateContext() hook to read the context. That's what the Create components do in react-admin.
+ *
+ * @example
+ *
+ * import { useCreateController, CreateContextProvider } from '@strato-admin/ra-core';
+ *
+ * const Create = props => {
+ *     const controllerProps = useCreateController(props);
+ *     return (
+ *         <CreateContextProvider value={controllerProps}>
+ *             ...
+ *         </CreateContextProvider>
+ *     );
+ * };
+ */
+export const CreateContext = createContext(null);
+CreateContext.displayName = 'CreateContext';

package/dist/ra-core/src/controller/create/CreateContextProvider.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+import { CreateControllerResult } from './useCreateController';
+/**
+ * Create a Create Context.
+ *
+ * @example
+ *
+ * const MyCreate = (props) => {
+ *     const controllerProps = useCreateController(props);
+ *     return (
+ *         <CreateContextProvider value={controllerProps}>
+ *             <MyCreateView>
+ *         </CreateContextProvider>
+ *     );
+ * };
+ *
+ * const MyCreateView = () => {
+ *     const record = useRecordContext();
+ *     // or, to rerender only when the save operation change but not data
+ *     const { saving } = useCreateContext();
+ * }
+ *
+ * @see CreateContext
+ * @see RecordContext
+ */
+export declare const CreateContextProvider: ({ children, value, }: {
+    children: ReactNode;
+    value: CreateControllerResult;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/ra-core/src/controller/create/CreateContextProvider.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { RecordContextProvider } from '../record/RecordContext';
+import { CreateContext } from './CreateContext';
+import { SaveContextProvider, usePickSaveContext } from '../saveContext';
+/**
+ * Create a Create Context.
+ *
+ * @example
+ *
+ * const MyCreate = (props) => {
+ *     const controllerProps = useCreateController(props);
+ *     return (
+ *         <CreateContextProvider value={controllerProps}>
+ *             <MyCreateView>
+ *         </CreateContextProvider>
+ *     );
+ * };
+ *
+ * const MyCreateView = () => {
+ *     const record = useRecordContext();
+ *     // or, to rerender only when the save operation change but not data
+ *     const { saving } = useCreateContext();
+ * }
+ *
+ * @see CreateContext
+ * @see RecordContext
+ */
+export const CreateContextProvider = ({ children, value, }) => (_jsx(CreateContext.Provider, { value: value, children: _jsx(SaveContextProvider, { value: {
+            ...usePickSaveContext(value),
+            mutationMode: 'pessimistic',
+        }, children: _jsx(RecordContextProvider, { value: value && value.record, children: children }) }) }));

package/dist/ra-core/src/controller/create/CreateController.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { CreateControllerProps, CreateControllerResult } from './useCreateController';
+import { RaRecord } from '../../types';
+/**
+ * Render prop version of the useCreateController hook
+ *
+ * @see useCreateController
+ * @example
+ *
+ * const CreateView = () => <div>...</div>
+ * const MyCreate = props => (
+ *     <CreateController {...props}>
+ *         {controllerProps => <CreateView {...controllerProps} {...props} />}
+ *     </CreateController>
+ * );
+ */
+export declare const CreateController: <RecordType extends Omit<RaRecord, "id"> = any, MutationOptionsError = Error>({ children, ...props }: {
+    children: (params: CreateControllerResult<RecordType>) => ReactNode;
+} & CreateControllerProps<RecordType, MutationOptionsError>) => ReactNode;

package/dist/ra-core/src/controller/create/CreateController.js

@@ -0,0 +1,18 @@
+import { useCreateController, } from './useCreateController';
+/**
+ * Render prop version of the useCreateController hook
+ *
+ * @see useCreateController
+ * @example
+ *
+ * const CreateView = () => <div>...</div>
+ * const MyCreate = props => (
+ *     <CreateController {...props}>
+ *         {controllerProps => <CreateView {...controllerProps} {...props} />}
+ *     </CreateController>
+ * );
+ */
+export const CreateController = ({ children, ...props }) => {
+    const controllerProps = useCreateController(props);
+    return children(controllerProps);
+};

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

@@ -0,0 +1,6 @@
+export * from './CreateBase';
+export * from './CreateContext';
+export * from './CreateContextProvider';
+export * from './CreateController';
+export * from './useCreateContext';
+export * from './useCreateController';

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

@@ -0,0 +1,6 @@
+export * from './CreateBase';
+export * from './CreateContext';
+export * from './CreateContextProvider';
+export * from './CreateController';
+export * from './useCreateContext';
+export * from './useCreateController';

package/dist/ra-core/src/controller/create/useCreateContext.d.ts

@@ -0,0 +1,12 @@
+import { RaRecord } from '../../types';
+import { CreateControllerResult } from './useCreateController';
+/**
+ * Hook to read the create controller props from the CreateContext.
+ *
+ * Used within a <CreateContextProvider> (e.g. as a descendent of <Create>).
+ *
+ * @returns {CreateControllerResult} create controller props
+ *
+ * @see useCreateController for how it is filled
+ */
+export declare const useCreateContext: <RecordType extends RaRecord = RaRecord>() => CreateControllerResult<RecordType>;

package/dist/ra-core/src/controller/create/useCreateContext.js

@@ -0,0 +1,18 @@
+import { useContext } from 'react';
+import { CreateContext } from './CreateContext';
+/**
+ * Hook to read the create controller props from the CreateContext.
+ *
+ * Used within a <CreateContextProvider> (e.g. as a descendent of <Create>).
+ *
+ * @returns {CreateControllerResult} create controller props
+ *
+ * @see useCreateController for how it is filled
+ */
+export const useCreateContext = () => {
+    const context = useContext(CreateContext);
+    if (!context) {
+        throw new Error('useCreateContext must be used inside a CreateContextProvider');
+    }
+    return context;
+};

package/dist/ra-core/src/controller/create/useCreateController.d.ts

@@ -0,0 +1,50 @@
+import { UseMutationOptions } from '@tanstack/react-query';
+import { UseCreateMutateParams } from '../../dataProvider';
+import { RedirectionSideEffect } from '../../routing';
+import { SaveContextValue } from '../saveContext';
+import { Identifier, MutationMode, RaRecord, TransformData } from '../../types';
+/**
+ * Prepare data for the Create view
+ *
+ * @param {Object} props The props passed to the Create component.
+ *
+ * @return {Object} controllerProps Fetched data and callbacks for the Create view
+ *
+ * @example
+ *
+ * import { useCreateController } from 'react-admin';
+ * import CreateView from './CreateView';
+ *
+ * const MyCreate = props => {
+ *     const controllerProps = useCreateController(props);
+ *     return <CreateView {...controllerProps} {...props} />;
+ * }
+ */
+export declare const useCreateController: <RecordType extends Omit<RaRecord, "id"> = any, MutationOptionsError = Error, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}>(props?: CreateControllerProps<RecordType, MutationOptionsError, ResultRecordType>) => CreateControllerResult<RecordType>;
+export interface CreateControllerProps<RecordType extends Omit<RaRecord, 'id'> = any, MutationOptionsError = Error, ResultRecordType extends RaRecord = RecordType & {
+    id: Identifier;
+}> {
+    disableAuthentication?: boolean;
+    hasEdit?: boolean;
+    hasShow?: boolean;
+    record?: Partial<RecordType>;
+    redirect?: RedirectionSideEffect;
+    resource?: string;
+    mutationMode?: MutationMode;
+    mutationOptions?: UseMutationOptions<ResultRecordType, MutationOptionsError, UseCreateMutateParams<RecordType>> & {
+        meta?: any;
+    };
+    transform?: TransformData;
+}
+export interface CreateControllerResult<RecordType extends Omit<RaRecord, 'id'> = any> extends SaveContextValue {
+    defaultTitle?: string;
+    isFetching: boolean;
+    isPending: boolean;
+    isLoading: boolean;
+    record?: Partial<RecordType>;
+    redirect: RedirectionSideEffect;
+    resource: string;
+    saving: boolean;
+}