@firecms/core 3.0.0-3.0.0-beta.4.pre.1.0

package/src/components/EntityCollectionView/EntityCollectionViewActions.tsx

@@ -0,0 +1,132 @@
+import React from "react";
+
+import { canCreateEntity, canDeleteEntity, fullPathToCollectionSegments } from "../../util";
+import { useAuthController, useCustomizationController, useFireCMSContext, useLargeLayout } from "../../hooks";
+import { CollectionActionsProps, EntityCollection, EntityTableController, SelectionController } from "../../types";
+import { AddIcon, Button, DeleteIcon, IconButton, Tooltip } from "@firecms/ui";
+import { toArray } from "../../util/arrays";
+import { ErrorBoundary } from "../ErrorBoundary";
+
+export type EntityCollectionViewActionsProps<M extends Record<string, any>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionIds: string[];
+    selectionEnabled: boolean;
+    onNewClick: () => void;
+    onMultipleDeleteClick: () => void;
+    selectionController: SelectionController<M>;
+    tableController: EntityTableController<M>;
+    collectionEntitiesCount: number;
+}
+
+export function EntityCollectionViewActions<M extends Record<string, any>>({
+                                                                               collection,
+                                                                               relativePath,
+                                                                               parentCollectionIds,
+                                                                               onNewClick,
+                                                                               onMultipleDeleteClick,
+                                                                               selectionEnabled,
+                                                                               path,
+                                                                               selectionController,
+                                                                               tableController,
+                                                                               collectionEntitiesCount
+                                                                           }: EntityCollectionViewActionsProps<M>) {
+
+    const context = useFireCMSContext();
+
+    const customizationController = useCustomizationController();
+    const plugins = customizationController.plugins ?? [];
+
+    const authController = useAuthController();
+
+    const largeLayout = useLargeLayout();
+
+    const selectedEntities = selectionController.selectedEntities;
+
+    const addButton = canCreateEntity(collection, authController, path, null) &&
+        onNewClick && (largeLayout
+            ? <Button
+                id={`add_entity_${path}`}
+                onClick={onNewClick}
+                startIcon={<AddIcon/>}
+                variant="filled"
+                color="primary">
+                Add {collection.singularName ?? collection.name}
+            </Button>
+            : <Button
+                id={`add_entity_${path}`}
+                onClick={onNewClick}
+                variant="filled"
+                color="primary"
+            >
+                <AddIcon/>
+            </Button>);
+
+    const multipleDeleteEnabled = canDeleteEntity(collection, authController, path, null);
+
+    let multipleDeleteButton: React.ReactNode | undefined;
+    if (selectionEnabled) {
+        const button = largeLayout
+            ? <Button
+                variant={"text"}
+                disabled={!(selectedEntities?.length) || !multipleDeleteEnabled}
+                startIcon={<DeleteIcon/>}
+                onClick={onMultipleDeleteClick}
+                color={"primary"}
+                className="lg:w-20"
+            >
+                ({selectedEntities?.length})
+            </Button>
+            : <IconButton
+                color={"primary"}
+                disabled={!(selectedEntities?.length) || !multipleDeleteEnabled}
+                onClick={onMultipleDeleteClick}>
+                <DeleteIcon/>
+            </IconButton>;
+        multipleDeleteButton =
+            <Tooltip
+                title={multipleDeleteEnabled ? "Delete" : "You have selected at least one entity you cannot delete"}>
+                {button}
+            </Tooltip>
+    }
+
+    const actionProps: CollectionActionsProps = {
+        path,
+        relativePath,
+        parentCollectionIds,
+        collection,
+        selectionController,
+        context,
+        tableController,
+        collectionEntitiesCount
+    };
+
+    const actions = toArray(collection.Actions)
+        .map((Action, i) => (
+            <ErrorBoundary key={`actions_${i}`}>
+                <Action {...actionProps} />
+            </ErrorBoundary>
+        ));
+
+    if (plugins) {
+        plugins.forEach((plugin, i) => {
+            if (plugin.collectionView?.CollectionActions) {
+                actions.push(...toArray(plugin.collectionView?.CollectionActions)
+                    .map((Action, j) => (
+                        <ErrorBoundary key={`plugin_actions_${i}_${j}`}>
+                            <Action {...actionProps} {...plugin.collectionView?.collectionActionsProps}/>
+                        </ErrorBoundary>
+                    )));
+            }
+        });
+    }
+
+    return (
+        <>
+            {actions}
+            {multipleDeleteButton}
+            {addButton}
+        </>
+    );
+}

package/src/components/EntityCollectionView/useSelectionController.tsx

@@ -0,0 +1,30 @@
+import { useCallback, useState } from "react";
+import { Entity, SelectionController } from "../../types";
+
+export function useSelectionController<M extends Record<string, any> = any>(
+    onSelectionChange?: (entity: Entity<M>, selected: boolean) => void
+): SelectionController<M> {
+
+    const [selectedEntities, setSelectedEntities] = useState<Entity<M>[]>([]);
+
+    const toggleEntitySelection = useCallback((entity: Entity<M>) => {
+        let newValue;
+        if (selectedEntities.map(e => e.id).includes(entity.id)) {
+            onSelectionChange?.(entity, false);
+            newValue = selectedEntities.filter((item: Entity<M>) => item.id !== entity.id);
+        } else {
+            onSelectionChange?.(entity, true);
+            newValue = [...selectedEntities, entity];
+        }
+        setSelectedEntities(newValue);
+    }, [selectedEntities]);
+
+    const isEntitySelected = useCallback((entity: Entity<M>) => selectedEntities.map(e => e.id).includes(entity.id), [selectedEntities]);
+
+    return {
+        selectedEntities,
+        setSelectedEntities,
+        isEntitySelected,
+        toggleEntitySelection
+    };
+}

package/src/components/EntityPreview.tsx

@@ -0,0 +1,218 @@
+import * as React from "react";
+import { useMemo } from "react";
+
+import { Entity, EntityCollection, ResolvedProperty } from "../types";
+
+import {
+    getEntityImagePreviewPropertyKey,
+    getEntityPreviewKeys,
+    getEntityTitlePropertyKey,
+    getValueInPath,
+    resolveCollection
+} from "../util";
+import { cn, defaultBorderMixin, IconButton, KeyboardTabIcon, Skeleton, Tooltip, Typography } from "@firecms/ui";
+import { PreviewSize, PropertyPreview, SkeletonPropertyComponent } from "../preview";
+import { useCustomizationController, useNavigationController, useSideEntityController } from "../hooks";
+import { useAnalyticsController } from "../hooks/useAnalyticsController";
+
+export type EntityPreviewProps = {
+    size: PreviewSize,
+    actions?: React.ReactNode,
+    collection?: EntityCollection,
+    hover?: boolean;
+    previewProperties?: string[],
+    disabled: undefined | boolean,
+    entity: Entity<any>,
+    includeEntityNavigation?: boolean,
+    onClick?: (e: React.SyntheticEvent) => void;
+};
+
+/**
+ * This view is used to display a preview of an entity.
+ * It is used by default in reference fields and whenever a reference is displayed.
+ */
+export function EntityPreview({
+                                  actions,
+                                  disabled,
+                                  hover,
+                                  collection: collectionProp,
+                                  previewProperties,
+                                  onClick,
+                                  size,
+                                  includeEntityNavigation,
+                                  entity
+                              }: EntityPreviewProps) {
+
+    const analyticsController = useAnalyticsController();
+    const sideEntityController = useSideEntityController();
+    const customizationController = useCustomizationController();
+
+    const navigationController = useNavigationController();
+
+    const collection = collectionProp ?? navigationController.getCollection<EntityCollection>(entity.path);
+
+    if (!collection) {
+        throw Error(`Couldn't find the corresponding collection view for the path: ${entity.path}`);
+    }
+
+    const resolvedCollection = React.useMemo(() => resolveCollection({
+        collection,
+        path: entity.path,
+        values: entity.values,
+        fields: customizationController.propertyConfigs
+    }), [collection]);
+
+    const listProperties = useMemo(() => getEntityPreviewKeys(resolvedCollection, customizationController.propertyConfigs, previewProperties, size === "small" || size === "medium" ? 3 : 1),
+        [previewProperties, resolvedCollection, size]);
+
+    const titleProperty = getEntityTitlePropertyKey(resolvedCollection, customizationController.propertyConfigs);
+    const imagePropertyKey = getEntityImagePreviewPropertyKey(resolvedCollection);
+    const imageProperty = imagePropertyKey ? resolvedCollection.properties[imagePropertyKey] : undefined;
+
+    const restProperties = listProperties.filter(p => p !== titleProperty && p !== imagePropertyKey);
+
+    return <EntityPreviewContainer onClick={disabled ? undefined : onClick}
+                                   hover={disabled ? undefined : hover}
+                                   size={size}>
+        {imageProperty && (
+            <div className={cn("w-10 h-10 mr-2 shrink-0 grow-0", size === "tiny" ? "my-0.5" : "m-2 self-start")}>
+                <PropertyPreview property={imageProperty}
+                                 propertyKey={imagePropertyKey as string}
+                                 size={"tiny"}
+                                 value={getValueInPath(entity.values, imagePropertyKey as string)}/>
+            </div>
+        )}
+
+        <div className={"flex flex-col flex-grow w-full m-1"}>
+
+            {size !== "tiny" && (
+                entity
+                    ? <div className={`${
+                        size !== "medium"
+                            ? "block whitespace-nowrap overflow-hidden truncate"
+                            : ""
+                    }`}>
+                        <Typography variant={"caption"}
+                                    color={"disabled"}
+                                    className={"font-mono"}>
+                            {entity.id}
+                        </Typography>
+                    </div>
+                    : <Skeleton/>)}
+
+            {titleProperty && (
+                <div className={"my-0.5 text-sm font-medium"}>
+                    {
+                        entity
+                            ? <PropertyPreview
+                                propertyKey={titleProperty as string}
+                                value={getValueInPath(entity.values, titleProperty)}
+                                property={resolvedCollection.properties[titleProperty as string] as ResolvedProperty}
+                                size={"medium"}/>
+                            : <SkeletonPropertyComponent
+                                property={resolvedCollection.properties[titleProperty as string] as ResolvedProperty}
+                                size={"medium"}/>
+                    }
+                </div>
+            )}
+
+            {restProperties && restProperties.map((key) => {
+                const childProperty = resolvedCollection.properties[key as string];
+                if (!childProperty) return null;
+
+                return (
+                    <div key={"ref_prev_" + key}
+                         className={restProperties.length > 1 ? "my-0.5" : "my-0"}>
+                        {
+                            entity
+                                ? <PropertyPreview
+                                    propertyKey={key as string}
+                                    value={getValueInPath(entity.values, key)}
+                                    property={childProperty as ResolvedProperty}
+                                    size={"tiny"}/>
+                                : <SkeletonPropertyComponent
+                                    property={childProperty as ResolvedProperty}
+                                    size={"tiny"}/>
+                        }
+                    </div>
+                );
+            })}
+
+        </div>
+
+        {entity && includeEntityNavigation &&
+            <Tooltip title={`See details for ${entity.id}`}
+                     className={size !== "tiny" ? "self-start" : ""}>
+                <IconButton
+                    color={"inherit"}
+                    size={"small"}
+                    onClick={(e) => {
+                        e.stopPropagation();
+                        analyticsController.onAnalyticsEvent?.("entity_click_from_reference", {
+                            path: entity.path,
+                            entityId: entity.id
+                        });
+                        sideEntityController.open({
+                            entityId: entity.id,
+                            path: entity.path,
+                            collection,
+                            updateUrl: true
+                        });
+                    }}>
+                    <KeyboardTabIcon size={"small"}/>
+                </IconButton>
+            </Tooltip>}
+
+        {actions}
+
+    </EntityPreviewContainer>;
+}
+
+type EntityPreviewContainerProps = {
+    children: React.ReactNode;
+    hover?: boolean;
+    size: PreviewSize;
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: (e: React.SyntheticEvent) => void;
+};
+
+const EntityPreviewContainerInner = React.forwardRef<HTMLDivElement, EntityPreviewContainerProps>(({
+                                                                                                       children,
+                                                                                                       hover,
+                                                                                                       onClick,
+                                                                                                       size,
+                                                                                                       style,
+                                                                                                       className,
+                                                                                                       ...props
+                                                                                                   }, ref) => {
+    return <div
+        ref={ref}
+        style={{
+            ...style,
+            // @ts-ignore
+            tabindex: 0
+        }}
+        className={cn(
+            "bg-white dark:bg-gray-900",
+            "items-center",
+            hover ? "hover:bg-slate-50 dark:hover:bg-gray-800 group-hover:bg-slate-50 dark:group-hover:bg-gray-800" : "",
+            size === "tiny" ? "p-1" : "p-2",
+            "flex border rounded-lg",
+            onClick ? "cursor-pointer" : "",
+            defaultBorderMixin,
+            className)}
+        onClick={(event) => {
+            if (onClick) {
+                event.preventDefault();
+                onClick(event);
+            }
+        }}
+        {...props}>
+        {children}
+    </div>;
+});
+
+EntityPreviewContainerInner.displayName = "EntityPreviewContainer";
+
+export const EntityPreviewContainer = React.memo(EntityPreviewContainerInner) as React.FC<EntityPreviewContainerProps>;

package/src/components/EntityView.tsx

@@ -0,0 +1,84 @@
+import React, { useMemo } from "react";
+import { PropertyPreview } from "../preview";
+import { Entity, EntityCollection, ResolvedEntityCollection, ResolvedProperties } from "../types";
+import { resolveCollection } from "../util";
+import { cn, defaultBorderMixin, IconButton, OpenInNewIcon } from "@firecms/ui";
+import { CustomizationController } from "../types/customization_controller";
+import { useCustomizationController } from "../hooks/useCustomizationController";
+
+/**
+ * @group Components
+ */
+export interface EntityViewProps<M extends Record<string, any>> {
+    entity: Entity<M>;
+    collection: EntityCollection<M>;
+    path: string;
+    className?: string;
+}
+
+export function EntityView<M extends Record<string, any>>(
+    {
+        entity,
+        collection,
+        path,
+        className
+    }: EntityViewProps<M>) {
+
+    const customizationController: CustomizationController = useCustomizationController();
+    const resolvedCollection: ResolvedEntityCollection<M> = useMemo(() => resolveCollection<M>({
+        collection,
+        path,
+        entityId: entity.id,
+        values: entity.values,
+        fields: customizationController.propertyConfigs
+    }), [collection, path, entity]);
+
+    const properties: ResolvedProperties = resolvedCollection.properties;
+
+    return (
+        <div className={"w-full " + className}>
+            <div className={"w-full mb-4"}>
+                <div className={cn(defaultBorderMixin, "flex justify-between py-2 border-b last:border-b-0")}>
+                    <div className="flex items-center w-1/4">
+                        <span className="pl-2 text-sm text-gray-600">Id</span>
+                    </div>
+                    <div
+                        className="flex-grow p-2 ml-2 w-3/4 text-gray-900 dark:text-white min-h-[56px] flex items-center">
+                        <span className="flex-grow mr-2">{entity.id}</span>
+                        {customizationController?.entityLinkBuilder &&
+                            <a href={customizationController.entityLinkBuilder({ entity })}
+                               rel="noopener noreferrer"
+                               target="_blank">
+                                <IconButton>
+                                    <OpenInNewIcon
+                                        size={"small"}/>
+                                </IconButton>
+                            </a>}
+                    </div>
+                </div>
+                {Object.entries(properties)
+                    .map(([key, property]) => {
+                        const value = (entity.values)[key];
+                        return (
+                            <div
+                                key={`reference_previews_${key}`}
+                                className={cn(defaultBorderMixin, "flex justify-between py-2 border-b last:border-b-0")}>
+                                <div className="flex items-center w-1/4">
+                                    <span className="pl-2 text-sm text-gray-600">{property.name}</span>
+                                </div>
+                                <div
+                                    className="flex-grow p-2 ml-2 w-3/4 text-gray-900 dark:text-white min-h-[56px] flex items-center">
+                                    <PropertyPreview
+                                        propertyKey={key}
+                                        value={value}
+                                        // entity={entity}
+                                        property={property}
+                                        size={"medium"}/>
+                                </div>
+                            </div>
+                        )
+                    })}
+            </div>
+        </div>
+    );
+}

package/src/components/ErrorBoundary.tsx

@@ -0,0 +1,40 @@
+import React, { ErrorInfo, PropsWithChildren } from "react";
+
+import { ErrorIcon, Typography } from "@firecms/ui";
+
+export class ErrorBoundary extends React.Component<PropsWithChildren<Record<string, unknown>>, {
+    error: Error | null
+}> {
+    constructor(props: any) {
+        super(props);
+        this.state = { error: null };
+    }
+
+    // eslint-disable-next-line n/handle-callback-err
+    static getDerivedStateFromError(error: Error) {
+        return { error };
+    }
+
+    componentDidCatch(error: Error, errorInfo: ErrorInfo) {
+        console.error(error);
+        // logErrorToMyService(error, errorInfo);
+    }
+
+    render() {
+        if (this.state.error) {
+            return (
+                <div className="flex flex-col m-2">
+                    <div className="flex items-center m-2">
+                        <ErrorIcon color={"error"} size={"small"}/>
+                        <div className="ml-4">Error</div>
+                    </div>
+                    <Typography variant={"caption"}>
+                        {this.state.error?.message ?? "See the error in the console"}
+                    </Typography>
+                </div>
+            );
+        }
+
+        return this.props.children;
+    }
+}

package/src/components/ErrorTooltip.tsx

@@ -0,0 +1,11 @@
+import React from "react";
+import { Tooltip, TooltipProps } from "@firecms/ui";
+
+export function ErrorTooltip(props: TooltipProps) {
+    return (
+        <Tooltip {...props}
+                 tooltipClassName={"!text-red-500 bg-red-50"}>
+            {props.children}
+        </Tooltip>
+    );
+}

package/src/components/ErrorView.tsx

@@ -0,0 +1,52 @@
+import React from "react";
+import { ErrorTooltip } from "./ErrorTooltip";
+import { ErrorIcon, Typography } from "@firecms/ui";
+
+/**
+ * @group Components
+ */
+export interface ErrorViewProps {
+    title?: string;
+    error: Error | React.ReactElement | string,
+    tooltip?: string
+}
+
+/**
+ * Generic error view. Displayed for example when an unexpected value comes
+ * from the datasource in a collection view.
+ * @param title
+ * @param error
+ * @param tooltip
+ * @constructor
+ * @group Components
+ */
+export function ErrorView({
+                              title,
+                              error,
+                              tooltip
+                          }: ErrorViewProps): React.ReactElement {
+    const component = error instanceof Error ? error.message : error;
+    console.error("ErrorView", error)
+
+    const body = (
+        <div
+            className="flex items-center m-2">
+            <ErrorIcon size={"small"} color={"error"}/>
+            <div className="pl-2">
+                {title && <Typography
+                    variant={"body2"}
+                    className="font-medium">{title}</Typography>}
+                <Typography variant={"body2"}>{component}</Typography>
+            </div>
+        </div>
+    );
+
+    if (tooltip) {
+        return (
+            <ErrorTooltip title={tooltip}>
+                {body}
+            </ErrorTooltip>
+        );
+    }
+    return body;
+}

package/src/components/FieldCaption.tsx

@@ -0,0 +1,13 @@
+import { Typography } from "@firecms/ui";
+
+export function FieldCaption({
+                                    error,
+                                    children
+                                }: { error?: boolean, children?: React.ReactNode }) {
+    if (!children) return null;
+    return (
+        <Typography variant={"caption"} color={error ? "error" : "secondary"} className={"ml-3.5 mt-0.5"}>
+            {children}
+        </Typography>
+    );
+}