@dashadmin/dash-auto-admin 1.3.24 → 1.3.26

package/src/toolbar/buttons/DashResourceButton.tsx

@@ -0,0 +1,223 @@
+import * as React from 'react';
+import { memo } from 'react';
+import PropTypes from 'prop-types';
+import {DASHAppConstants} from 'dash-constants';
+
+import {
+    useResourceContext,
+    useRecordContext,
+    useRedirect,
+
+} from 'react-admin';
+
+import {
+    RaRecord
+} from 'react-admin/src';
+
+import useVirtualHash from '../../hooks/useVirtualHash';
+import IDashAutoAdminResourceConfig from '../../interfaces/IDashAutoAdminResourceConfig';
+import { IconButton, Tooltip } from '@mui/material';
+
+import { Add, Edit, Visibility, Delete } from '@mui/icons-material'
+import { DeleteWithConfirmButton } from 'react-admin';
+import { useNavigate } from 'react-router';
+const URL_PREFIX = DASHAppConstants.system.URL_PREFIX;
+/* @ts-ignore Expected Cannot use namespace 'RaRecord' as a type.ts(2709) */
+interface Props<RecordType extends RaRecord = any> {
+    label?: string;
+    record?: RecordType;
+    resource?: string;
+    navigate?: (record?: RecordType) => string;
+    navigation?: 'redirect' | 'virtualhash';
+    mode: 'show' | 'create' | 'edit' | 'destroy' | 'custom';
+    size?: 'small' | 'medium' | 'large';
+    scrollToTop?: boolean;
+    resourceConfig?: IDashAutoAdminResourceConfig;
+    children?: React.JSX.Element;
+    showIcon?: boolean;
+    title?: string;
+    icon?: React.JSX.Element;
+}
+/* @ts-ignore Expected Cannot use namespace 'RaRecord' as a type.ts(2709) */
+export type ShowButtonProps<RecordType extends RaRecord = any> =
+    Props<RecordType> /*& ButtonProps*/;
+
+/* @ts-ignore Expected Cannot use namespace 'RaRecord' as a type.ts(2709) */
+export type IQuickButton<RecordType extends RaRecord = any> = ShowButtonProps<RecordType>;
+
+const scrollStates = {
+    true: { _scrollToTop: true },
+    false: {},
+};
+
+const inferModeFromUrl = (url: String) => {
+
+    if (url.includes('create')) return 'create';
+    if (url.includes('edit')) return 'edit';
+    return 'show';
+
+}
+/* @ts-ignore Expected Cannot use namespace 'RaRecord' as a type.ts(2709) */
+const DashResourceButton = <RecordType extends RaRecord = any>(
+    props: IQuickButton<RecordType>,
+) => {
+    const redirect = useRedirect();
+    //const redirect = useNavigate();
+
+    const ComponentType = props.children?.type || IconButton;
+    const componentProps = { ...props, ...props.children?.props };
+
+    let {
+        navigate,
+        scrollToTop,
+        mode,
+        size,
+        navigation,
+        resourceConfig,
+        record: _inputRecord,
+        resource: _inputResource,
+        showIcon = true,
+        title,
+        icon,
+        ...rest
+    } = componentProps;
+
+    const resource = _inputResource || useResourceContext();
+    const record = _inputRecord || useRecordContext();
+    if (!size) { size = 'small' }
+
+    /*if(navigate && !mode) {
+        mode = inferModeFromUrl(navigate(record));
+    } */
+
+    if (!navigation) {
+
+        navigation = resourceConfig?.drawer ?
+            (mode === 'edit' && resourceConfig.drawerOptions?.edit === false) ? 'redirect' :
+                (mode === 'show' && resourceConfig.drawerOptions?.show === false) ? 'redirect' :
+                    (mode === 'create' && resourceConfig.drawerOptions?.create === false) ? 'redirect' :
+                        'virtualhash'
+            : 'redirect';
+    }
+
+    if (!navigate) {
+        navigate = (_record) => {
+            const url = `${URL_PREFIX}${resource}/${navigation === 'virtualhash' ? 'inline' : ''}${mode === 'edit' ? '/' + _record.id + '/edit' : mode === 'show' ? '/' + _record.id + '/show' : mode === 'create' ? '/create' : ''}`;
+            return url;
+        }
+    }
+
+
+    //if (!record) return null;
+
+    const { setVirtualHash } = useVirtualHash();
+
+    const handleOnClick = (e: React.MouseEvent) => {
+
+        e.preventDefault();
+        e.stopPropagation();
+
+        if(componentProps.onClick) {
+          componentProps.onClick(e);
+          return;
+        }
+        if (navigation === 'virtualhash') {
+
+            const vhash = navigate(record);
+            //const vhash = `${URL_PREFIX}${resource}/${navigate ? navigate(record) : record.id}`;
+
+            setVirtualHash(vhash);
+        }
+
+        if (navigation === 'redirect') {
+
+            if (mode === "create") {
+                redirect(mode, resource)
+            } else {
+                redirect(mode, resource, record.id);
+            }
+
+        }
+
+    };
+
+    const _styles = size === 'small' ? {
+        '& .MuiButton-startIcon': { margin: 0 },
+        '& .MuiButton-text': { paddingLeft: '4px' },
+        borderRadius: '50% !important',
+        padding: 0,
+        minWidth: '30px',
+        width: '30px',
+        height: '30px',
+        overflow: 'hidden'
+    } : {}
+
+    const _label = size === 'small' ? '' : props?.label;
+    
+    if (mode === "destroy") {
+        return <Tooltip title={props?.label}><DeleteWithConfirmButton label={_label} sx={{ ..._styles }} size={size} record={record} /></Tooltip>
+    } else if (mode === "custom") {
+        // Remove title prop from rest to avoid conflict with Tooltip
+        const { title, ...restWithoutTitle } = rest as any;
+        return <Tooltip title={props?.label}><ComponentType
+            onClick={(e) => handleOnClick(e)}
+            state={scrollStates[String(scrollToTop)]}
+            size={size}
+            {...restWithoutTitle}
+        /></Tooltip>
+    } else {
+        // If showIcon is false and children are provided, render children with click handler
+        if (!showIcon && props.children) {
+            return React.cloneElement(props.children, {
+                onClick: (e: React.MouseEvent) => handleOnClick(e),
+                ...props.children.props
+            });
+        }
+
+        // For cases with no children, we need to keep the title prop
+        const { title, ...restWithoutTitle } = rest as any;
+        
+        const button = <ComponentType
+            onClick={(e) => handleOnClick(e)}
+            state={scrollStates[String(scrollToTop)]}
+            size={size}
+            title={props.children ? undefined : title} // Keep title only when no children
+            {...restWithoutTitle}
+        >
+            {showIcon && (
+                icon ? icon :
+                mode === 'edit' ? <Edit /> :
+                    mode === 'show' ? <Visibility /> :
+                        mode === 'create' ? <Add /> :
+                            mode
+            )}
+        </ComponentType>
+
+        return <Tooltip title={props?.label || ''}>
+            {button}
+        </Tooltip>;
+    }
+};
+
+DashResourceButton.propTypes = {
+    icon: PropTypes.element,
+    label: PropTypes.string,
+    record: PropTypes.any,
+    scrollToTop: PropTypes.bool,
+    navigate: PropTypes.func,
+    navigation: PropTypes.string,
+    children: PropTypes.element,
+    showIcon: PropTypes.bool,
+};
+
+export default memo(
+    DashResourceButton,
+    (props: ShowButtonProps, nextProps: ShowButtonProps) =>
+        props.resource === nextProps.resource &&
+        (props.record && nextProps.record
+            ? props.record.id === nextProps.record.id
+            : props.record == nextProps.record) && // eslint-disable-line eqeqeq
+        props.label === nextProps.label &&
+        props.showIcon === nextProps.showIcon &&
+        props.icon === nextProps.icon,
+);

package/src/toolbar/buttons/ListButtons.tsx

@@ -0,0 +1,137 @@
+import { FC } from 'react';
+import { EditButton } from 'react-admin';
+import { DeleteButton } from 'react-admin';
+import { DeleteWithConfirmButton } from 'react-admin';
+import { WithRecord } from 'react-admin';
+import { ShowButton } from 'react-admin';
+import IToolbarButton from '../../interfaces/IToolbarButton';
+import DashResourceButton from './DashResourceButton';
+/**
+ * Renders a view button for a list of resources, based on the provided resource configuration.
+ * If the resource configuration does not have a `view` property set to `false`, and there is no `listViewButton` property,
+ * a default `ShowButton` component is rendered.
+ * If the `listViewButton` property is enabled, either the custom component specified in `listViewButton.component` is rendered,
+ * or a default `ShowButton` component is rendered with the props specified in `listViewButton.props`.
+ * If the `listViewButton` property is not enabled, `null` is returned.
+ * 
+ * @param props - The props for the `ListViewButton` component.
+ * @param props.resourceConfig - The resource configuration object.
+ * @returns {React.ReactElement} A React component.
+ */
+export const ListViewButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig } = props;
+	let Component = ShowButton;
+	if (!resourceConfig) return <Component/>;
+	if ( resourceConfig.listViewButton) {
+		if ( resourceConfig.listViewButton.component ) Component = resourceConfig.listViewButton.component;
+		if (resourceConfig.listViewButton.enabled === false || resourceConfig?.view === false) return <></>;
+        if(!resourceConfig.listViewButton?.size) { resourceConfig.listViewButton.size = 'small' };
+        
+	}
+
+
+	/*const btnProps = { 
+		...resourceConfig.listViewButton?.props || {}, 
+		...(resourceConfig.drawer === true && resourceConfig.drawerOptions?.view !== false ? {
+			mode: 'show',
+			navigation: 'virtualhash',
+			navigate: (record) => {
+      
+				return 'inline/' + record.id + '/show';
+			},
+		} : {}),
+	};*/
+
+    const btnProps = { 
+        mode: 'show',
+        resourceConfig: resourceConfig,
+		...resourceConfig.listViewButton?.props || {},
+       
+    }
+
+	//if (resourceConfig.drawer === true && resourceConfig.drawerOptions?.view !== false) {
+		//return <DashResourceButton {...btnProps} ><Component /></DashResourceButton>;
+	//}
+    
+	//return <Component {...btnProps} />;
+
+     return <DashResourceButton {...btnProps}  resourceConfig={resourceConfig} {...resourceConfig.listDeleteButton?.props || {}} />;
+
+};
+
+
+/**
+ * Renders an edit button for a list of resources, based on the provided resource configuration.
+ * If the resource configuration does not have an `edit` property set to `false`, and there is no `listEditButton` property,
+ * a default `EditButton` component is rendered.
+ * If the `listEditButton` property is enabled, either the custom component specified in `listEditButton.component` is rendered,
+ * or a default `EditButton` component is rendered with the props specified in `listEditButton.props`.
+ * If the `listEditButton` property is not enabled, `null` is returned.
+ * 
+ * @param props - The props for the `ListEditButton` component.
+ * @param props.resourceConfig - The resource configuration object.
+ * @returns {React.ReactElement} A React component.
+ */
+export const ListEditButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig } = props;
+	let Component = EditButton;
+	
+
+    if (!resourceConfig) {
+        return <Component />;
+    }
+
+
+	if ( resourceConfig.listEditButton) {
+		if ( resourceConfig.listEditButton.component ) Component = resourceConfig.listEditButton.component;
+		if (resourceConfig.listEditButton.enabled === false || resourceConfig?.edit === false) return <></>;
+        if(resourceConfig.listViewButton && !resourceConfig.listViewButton?.size) { resourceConfig.listViewButton.size = 'small' };
+	}
+
+    return <DashResourceButton mode='edit' resourceConfig={resourceConfig} {...resourceConfig.listViewButton?.props || {}} />;
+
+	//if (resourceConfig.drawer === true && resourceConfig.drawerOptions?.edit !== false) {
+		//return <DashResourceButton mode='edit' resourceConfig={resourceConfig} {...resourceConfig.listViewButton?.props || {}} ><Component  /></DashResourceButton>;
+	//}
+
+	//return <Component />;
+};
+
+/**
+ * Renders a delete button for a list of resources, based on the provided resource configuration.
+ * If the resource configuration does not have a `delete` property set to `false`, and there is no `listDeleteButton` property,
+ * a default `DeleteButton` component is rendered.
+ * If the `listDeleteButton` property is enabled, either the custom component specified in `listDeleteButton.component` is rendered,
+ * or a default `DeleteButton` component is rendered with the props specified in `listDeleteButton.props`.
+ * If the `listDeleteButton` property is not enabled, `null` is returned.
+ * If the `listDeleteButton.props.confirm` property is set, a `DeleteWithConfirmButton` component is rendered instead.
+ * 
+ * @param props - The props for the `ListDeleteButton` component.
+ * @param props.resourceConfig - The resource configuration object.
+ * @returns {React.ReactElement} A React component.
+ */
+export const ListDeleteButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig } = props;
+	let Component = DeleteButton;
+	if (!resourceConfig) return <Component/>;
+	if ( resourceConfig.listDeleteButton) {
+		if ( resourceConfig.listDeleteButton.component ) Component = resourceConfig.listDeleteButton.component;
+		if (resourceConfig.listDeleteButton.enabled === false || resourceConfig?.delete === false) return <></>;
+        if(!resourceConfig.listViewButton?.size) { resourceConfig.listViewButton.size = 'small' };
+	}
+
+  
+	/*if (resourceConfig.listDeleteButton?.confirm) {
+		return <WithRecord
+			render={(record) => (
+				<DeleteWithConfirmButton  {...resourceConfig.listDeleteButton?.props || {}} record={record} />
+			)}
+		/>;
+	}
+	return <DeleteButton {...resourceConfig.listDeleteButton?.props || {}} />;*/
+
+    //return <DashResourceButton mode='destroy' resourceConfig={resourceConfig} {...resourceConfig.listDeleteButton?.props || {}} ><Component  /></DashResourceButton>;
+
+    return <DashResourceButton mode='destroy' resourceConfig={resourceConfig} {...resourceConfig.listDeleteButton?.props || {}} />;
+
+};

package/src/toolbar/buttons/ToolbarButtons.tsx

@@ -0,0 +1,186 @@
+import { CreateButton } from 'react-admin';
+import { FC } from 'react';
+import { ExportButton } from 'react-admin';
+import { ListButton } from 'react-admin';
+import { EditButton } from 'react-admin';
+import { DeleteButton } from 'react-admin';
+import DashAutoAdminSaveButton from '../../DashAutoAdminSaveButton';
+import { DeleteWithConfirmButton } from 'react-admin';
+import { WithRecord } from 'react-admin';
+import { SaveButton } from 'react-admin';
+import IToolbarButton from '../../interfaces/IToolbarButton';
+import IAutoGridButton from '../../interfaces/IDashAutoGridButton';
+
+/**
+ * Checks if the current mode enables the display of a button.
+ *
+ * @param modes - An optional object that specifies which modes should enable the button.
+ * @param mode - The current mode of the application.
+ * @returns `true` if the button should be displayed, `false` otherwise.
+ */
+const checkIfModeEnablesButton = (modes?:IAutoGridButton['modes'], mode?:IToolbarButton['mode']) => {
+	if (!modes) return true;
+	if (!mode) return true;
+	if (modes[mode] === false) return false;
+	return true;
+};
+
+
+/**
+ * Renders a toolbar save button based on the provided resource configuration.
+ * 
+ * The button is only rendered if the `toolbarSaveButton` property is defined and enabled.
+ * The button is further conditionally rendered based on the current mode and the `modes` property of the `toolbarSaveButton`.
+ * 
+ * If the `toolbarSaveButton` is enabled and the current mode allows it, the button can either be a custom component or a default `AutoAdminSaveButton` component.
+ *
+ * @param props - The component props, including the `resourceConfig` and the current `mode`.
+ * @returns The rendered toolbar save button or `null` if the button should not be rendered.
+ */
+export const ToolbarSaveButton:FC<IToolbarButton> = (props) => {
+
+	const { resourceConfig, mode } = props;
+
+	if (!resourceConfig) { return <SaveButton/>; }
+    if(!resourceConfig.toolbarSaveButton) { return <SaveButton/>; }
+	
+		if (resourceConfig.toolbarSaveButton?.enabled) {
+			if (checkIfModeEnablesButton(resourceConfig.toolbarSaveButton.modes, mode)) {
+				const buttonProps = {
+					...(resourceConfig.toolbarSaveButton?.props || {}),
+					alwaysEnable: resourceConfig?.saveButtonAlwaysEnabled === true ? true : false,
+				};
+				return resourceConfig.toolbarSaveButton?.component ? <resourceConfig.toolbarSaveButton.component {...buttonProps} />  : <DashAutoAdminSaveButton {...buttonProps} />;
+			}
+		}
+	
+	return null;
+};
+
+/**
+ * Renders a toolbar list button based on the provided resource configuration.
+ * 
+ * The button is only rendered if the `list` property in the resource configuration is not `false` and the `toolbarListButton` property is defined.
+ * The button is further conditionally rendered based on the current mode and the `modes` property of the `toolbarListButton`.
+ * 
+ * If the `toolbarListButton` is enabled and the current mode allows it, the button can either be a custom component or a default `ListButton` component.
+ *
+ * @param props - The component props, including the `resourceConfig` and the current `mode`.
+ * @returns The rendered toolbar list button or `null` if the button should not be rendered.
+ */
+export const ToolbarListButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig, mode } = props;
+	if (!resourceConfig) return <ListButton/>;
+	if (!!(resourceConfig?.list !== false) && (resourceConfig?.toolbarListButton && !!(resourceConfig?.toolbarListButton.enabled !== false))) {
+		return checkIfModeEnablesButton(resourceConfig.toolbarListButton.modes, mode) ? <ListButton/> : null;
+	} else if (resourceConfig.toolbarListButton?.enabled) {
+		if (checkIfModeEnablesButton(resourceConfig.toolbarEditButton.modes, mode)) {
+			return resourceConfig.toolbarListButton?.component ? <resourceConfig.toolbarListButton.component {...resourceConfig.toolbarListButton?.props || {}} />  : <ListButton {...resourceConfig.toolbarListButton?.props || {}} />;
+		}
+	}
+	return null;
+};
+
+/**
+ * Renders a toolbar edit button based on the provided resource configuration.
+ * 
+ * The button is only rendered if the `edit` property in the resource configuration is not `false` and the `toolbarEditButton` property is defined.
+ * The button is further conditionally rendered based on the current mode and the `modes` property of the `toolbarEditButton`.
+ * 
+ * If the `toolbarEditButton` is enabled and the current mode allows it, the button can either be a custom component or a default `EditButton` component.
+ *
+ * @param props - The component props, including the `resourceConfig` and the current `mode`.
+ * @returns The rendered toolbar edit button or `null` if the button should not be rendered.
+ */
+export const ToolbarEditButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig, mode } = props;
+	if (!resourceConfig) return <EditButton/>;
+	if (!!(resourceConfig?.edit !== false) && (resourceConfig?.toolbarEditButton && !!(resourceConfig?.toolbarEditButton.enabled !== false))) {
+		return checkIfModeEnablesButton(resourceConfig.toolbarEditButton.modes, mode) ? <EditButton/> : null;
+	} else if (resourceConfig.toolbarEditButton?.enabled) {
+		if (checkIfModeEnablesButton(resourceConfig.toolbarEditButton.modes, mode)) {
+			return resourceConfig.toolbarEditButton?.component ? <resourceConfig.toolbarEditButton.component {...resourceConfig.toolbarEditButton?.props || {}} />  : <EditButton {...resourceConfig.toolbarEditButton?.props || {}} />;
+		}
+	}
+	return null;
+};
+
+/**
+ * Renders a toolbar create button based on the provided resource configuration.
+ * 
+ * The button is only rendered if the `create` property in the resource configuration is not `false` and the `toolbarCreateButton` property is defined.
+ * The button is further conditionally rendered based on the current mode and the `modes` property of the `toolbarCreateButton`.
+ * 
+ * If the `toolbarCreateButton` is enabled and the current mode allows it, the button can either be a custom component or a default `CreateButton` component.
+ *
+ * @param props - The component props, including the `resourceConfig` and the current `mode`.
+ * @returns The rendered toolbar create button or `null` if the button should not be rendered.
+ */
+export const ToolbarCreateButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig, mode } = props;
+	if (!resourceConfig) return <CreateButton/>;
+	if (!!(resourceConfig?.create !== false) && (resourceConfig?.toolbarCreateButton && !!(resourceConfig?.toolbarCreateButton.enabled !== false))) {
+		return checkIfModeEnablesButton(resourceConfig.toolbarCreateButton.modes, mode) ? <CreateButton/> : null;
+	} else if (resourceConfig.toolbarCreateButton?.enabled) {
+		if (checkIfModeEnablesButton(resourceConfig.toolbarCreateButton.modes, mode)) {
+			return resourceConfig.toolbarCreateButton?.component ? <resourceConfig.toolbarCreateButton.component {...resourceConfig.toolbarCreateButton?.props || {}} />  : <CreateButton {...resourceConfig.toolbarCreateButton?.props || {}} />;
+		}
+	}
+	return null;
+};
+
+/**
+ * Renders a toolbar delete button based on the provided resource configuration.
+ * 
+ * The button is only rendered if the `delete` property in the resource configuration is not `false` and the `toolbarDeleteButton` property is defined.
+ * The button is further conditionally rendered based on the current mode and the `modes` property of the `toolbarDeleteButton`.
+ * 
+ * If the `toolbarDeleteButton` is enabled and the current mode allows it, the button can either be a custom component or a default `DeleteButton` component.
+ * If the `toolbarDeleteButton` has a `confirm` property, the button will be rendered with a confirmation dialog.
+ * 
+ * @param props - The component props, including the `resourceConfig` and the current `mode`.
+ * @returns The rendered toolbar delete button or `null` if the button should not be rendered.
+ */
+export const ToolbarDeleteButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig, mode } = props;
+	if (!resourceConfig) return  <DeleteButton/>;
+	if (!!(resourceConfig?.delete !== false) && !!resourceConfig?.toolbarDeleteButton) {
+		return checkIfModeEnablesButton(resourceConfig.toolbarDeleteButton.modes, mode) ? <DeleteButton/> : null;
+	} else if (!!resourceConfig?.toolbarDeleteButton && !!(resourceConfig?.toolbarDeleteButton.enabled !== false)) {
+		if (checkIfModeEnablesButton(resourceConfig.toolbarCreateButton.modes, mode)) {
+			if (!!resourceConfig.toolbarDeleteButton?.props && resourceConfig.toolbarDeleteButton.props?.confirm) {
+				return <WithRecord
+					render={(record) => (
+						<DeleteWithConfirmButton record={record} />
+					)}
+				/>;
+			}
+		}
+		return resourceConfig.toolbarDeleteButton?.component ? <resourceConfig.toolbarDeleteButton.component {...resourceConfig.toolbarDeleteButton?.props || {}} />  : <DeleteButton {...resourceConfig.toolbarDeleteButton?.props || {}} />;
+	}
+	return null;
+};
+
+/**
+ * Renders a toolbar export button based on the provided resource configuration.
+ * 
+ * The button is only rendered if the `exporter` property in the resource configuration is not `false` and the `toolbarExportButton` property is defined.
+ * The button is further conditionally rendered based on the current mode and the `modes` property of the `toolbarExportButton`.
+ * 
+ * If the `toolbarExportButton` is enabled and the current mode allows it, the button can either be a custom component or a default `ExportButton` component.
+ * 
+ * @param props - The component props, including the `resourceConfig` and the current `mode`.
+ * @returns The rendered toolbar export button or `null` if the button should not be rendered.
+ */
+export const ToolbarExportButton:FC<IToolbarButton> = (props) => {
+	const { resourceConfig, mode } = props;
+	if (!resourceConfig) return <ExportButton/>;
+	if (!!(resourceConfig?.exporter !== false) && (resourceConfig?.toolbarExportButton && !!(resourceConfig?.toolbarExportButton.enabled !== false))) {
+		return checkIfModeEnablesButton(resourceConfig.toolbarExportButton.modes, mode) ? <ExportButton/> : null;
+	} else if (resourceConfig.toolbarExportButton?.enabled) {
+		if (checkIfModeEnablesButton(resourceConfig.toolbarExportButton.modes, mode)) {
+			return resourceConfig.toolbarExportButton?.component ? <resourceConfig.toolbarExportButton.component {...resourceConfig.toolbarExportButton?.props || {}} />  : <ExportButton {...resourceConfig.toolbarExportButton?.props || {}} />;
+		}
+	}
+	return null;
+};

package/src/utils/SimpleLogger.tsx

@@ -0,0 +1,46 @@
+export class SimpleLogger {
+	private loggerID = Math.random().toString(32).slice(2, 6);
+
+	constructor(private prefix: string, private debug: boolean) {}
+
+	private getLogString() {
+		return `ReactAutoAdmin | ${this.prefix} [${this.loggerID}]`;
+	}
+
+	public get log() {
+		if (!this.debug) {
+			return () => {};
+		}
+		const boundLogFn: (...any) => void = console.log.bind(
+			console,
+			`⚪ ${this.getLogString()}`,
+		);
+		return boundLogFn;
+	}
+
+	public get warn() {
+		if (!this.debug) {
+			return () => {};
+		}
+		const boundLogFn: (...any) => void = console.warn.bind(
+			console,
+			`🟡 ${this.getLogString()}`,
+		);
+		return boundLogFn;
+	}
+
+	public get error() {
+		if (!this.debug) {
+			return () => {};
+		}
+		const boundLogFn: (...any) => void = console.error.bind(
+			console,
+			`🔴 ${this.getLogString()}`,
+		);
+		return boundLogFn;
+	}
+
+	setEnabled(logging: boolean) {
+		this.debug = logging;
+	}
+}

package/src/utils/enumToChoices.tsx

@@ -0,0 +1,3 @@
+const enumToChoices = (e: any) =>
+	Object.keys(e).map((key: string) => ({ id: e[key], name: key }));
+export default enumToChoices;

package/src/utils/evalActionPermission.tsx

@@ -0,0 +1,14 @@
+import IDashAutoAdminResourceConfig from '../interfaces/IDashAutoAdminResourceConfig';
+
+const evalActionPermission = (
+	resourceConfig: IDashAutoAdminResourceConfig,
+	action?: any,
+): boolean => {
+	let result = true;
+	if (action === null || action === undefined) return true;
+	if (!action) return false;
+	if (typeof action === 'function') result = action(resourceConfig);
+	return result;
+};
+
+export default evalActionPermission;

package/src/utils/groupByTabs.tsx

@@ -0,0 +1,23 @@
+import IDashAutoAdminAttribute from '../interfaces/IDashAutoAdminAttribute';
+
+const groupByTabs = (
+	schema: IDashAutoAdminAttribute[],
+): IDashAutoAdminAttribute[][] => {
+	const tabs: IDashAutoAdminAttribute[][] = [];
+	schema.forEach((attribute) => {
+		let added = false;
+		tabs.forEach((tab) => {
+			const name = tab[0].tab;
+			if (name === attribute.tab) {
+				tab.push(attribute);
+				added = true;
+			}
+		});
+		if (!added) {
+			tabs.push([attribute]);
+		}
+	});
+	return tabs;
+};
+
+export default groupByTabs;

package/src/utils/hashedGroupByTabs.tsx

@@ -0,0 +1,16 @@
+import IDashAutoAdminAttribute from '../interfaces/IDashAutoAdminAttribute';
+
+const hasehdGroupByTabs = (
+	schema: IDashAutoAdminAttribute[],
+): Array<{ [key: string]: IDashAutoAdminAttribute[] }> => {
+	const tabs: Array<{ [key: string]: IDashAutoAdminAttribute[] }> = [];
+	const availabletabs = [...new Set(schema.map((item) => item.tab))];
+
+	availabletabs.forEach((tab) => {
+		tabs[tab] = schema.filter((item) => item.tab === tab);
+	});
+
+	return tabs;
+};
+
+export default hasehdGroupByTabs;

package/src/utils/invertMap.tsx

@@ -0,0 +1,10 @@
+const invertMap = (map: any) => {
+	if (!map) {
+		return false;
+	}
+	const invertedMap: any = {};
+	Object.keys(map).forEach((key) => (invertedMap[map[key]] = key));
+	return invertedMap;
+};
+
+export default invertMap;

package/src/utils/isClassComponent.tsx

@@ -0,0 +1,9 @@
+const isClassComponent = (Component) => {
+	return !!(
+		typeof Component === 'function' &&
+		Component.prototype &&
+		Component.prototype.isReactComponent
+	);
+};
+
+export default isClassComponent;