@firecms/core 3.0.0-canary.20 → 3.0.0-canary.200

package/src/internal/useBuildSideEntityController.tsx

@@ -3,24 +3,85 @@ import {
     EntityCollection,
     EntitySidePanelProps,
     NavigationController,
+    ResolvedProperty,
     SideDialogPanelProps,
     SideDialogsController,
     SideEntityController
 } from "../types";
-import { getNavigationEntriesFromPathInternal, NavigationViewInternal } from "../util/navigation_from_path";
+import { getNavigationEntriesFromPath, NavigationViewInternal } from "../util/navigation_from_path";
 import { useLocation } from "react-router-dom";
-import { removeInitialAndTrailingSlashes, resolveDefaultSelectedView } from "../util";
+import { removeInitialAndTrailingSlashes, resolveCollection, resolveDefaultSelectedView } from "../util";
 import { ADDITIONAL_TAB_WIDTH, CONTAINER_FULL_WIDTH, FORM_CONTAINER_WIDTH } from "./common";
 import { useLargeLayout } from "../hooks";
 import { EntitySidePanel } from "../core/EntitySidePanel";
 
-const NEW_URL_HASH = "new";
+const NEW_URL_HASH = "new_side";
+const SIDE_URL_HASH = "side";
 
 export function getEntityViewWidth(props: EntitySidePanelProps<any>, small: boolean): string {
     if (small) return CONTAINER_FULL_WIDTH;
-    const mainViewSelected = !props.selectedSubPath;
-    const resolvedWidth: string | undefined = typeof props.width === "number" ? `${props.width}px` : props.width;
-    return !mainViewSelected ? `calc(${ADDITIONAL_TAB_WIDTH} + ${resolvedWidth ?? FORM_CONTAINER_WIDTH})` : resolvedWidth ?? FORM_CONTAINER_WIDTH
+    const mainViewSelected = !props.selectedTab;
+    let resolvedWidth: string | undefined;
+    if (props.width) {
+        resolvedWidth = typeof props.width === "number" ? `${props.width}px` : props.width;
+    } else if (props.collection?.sideDialogWidth) {
+        resolvedWidth = typeof props.collection.sideDialogWidth === "number" ? `${props.collection.sideDialogWidth}px` : props.collection.sideDialogWidth;
+    }
+
+    if (!mainViewSelected) {
+        return `calc(${ADDITIONAL_TAB_WIDTH} + ${resolvedWidth ?? FORM_CONTAINER_WIDTH})`
+    } else {
+        if (resolvedWidth) {
+            return resolvedWidth
+        } else if (!props.collection) {
+            return FORM_CONTAINER_WIDTH;
+        } else {
+            return calculateCollectionDesiredWidth(props.collection);
+        }
+    }
+}
+
+const collectionViewWidthCache: { [key: string]: string } = {};
+
+function calculateCollectionDesiredWidth(collection: EntityCollection<any>): string {
+    if (collectionViewWidthCache[collection.id]) {
+        return collectionViewWidthCache[collection.id];
+    }
+    const resolvedCollection = resolveCollection({
+        collection,
+        path: "__ignored",
+        ignoreMissingFields: true
+    });
+
+    let result = FORM_CONTAINER_WIDTH
+    if (resolvedCollection?.properties) {
+        const values = Object.values(resolvedCollection.properties).map((p: ResolvedProperty) => getNestedPropertiesDepth(p));
+        const maxDepth = Math.max(...values);
+        if (maxDepth < 3) {
+            result = FORM_CONTAINER_WIDTH;
+        } else {
+            result = 768 + 32 * (maxDepth - 2) + "px";
+        }
+    }
+    collectionViewWidthCache[collection.id] = result;
+    return result;
+}
+
+function getNestedPropertiesDepth(property: ResolvedProperty, accumulator: number = 0): number {
+    if (property.dataType === "map" && property.properties) {
+        const values = Object.values(property.properties).flatMap((property) => getNestedPropertiesDepth(property, accumulator + 1));
+        return Math.max(...values);
+    } else if (property.dataType === "array" && property.oneOf) {
+        return accumulator + 3;
+    } else if (property.dataType === "array" && property.of) {
+        if (Array.isArray(property.of)) {
+            return Math.max(...property.of.map((p) => getNestedPropertiesDepth(p, accumulator + 1)));
+        } else {
+            return getNestedPropertiesDepth(property.of, accumulator + 1);
+        }
+    } else {
+        return accumulator + 1;
+    }
 }
 
 export const useBuildSideEntityController = (navigation: NavigationController,
@@ -33,24 +94,58 @@ export const useBuildSideEntityController = (navigation: NavigationController,
 
     // only on initialisation, create panels from URL
     useEffect(() => {
-        if (!navigation.loading && !initialised.current) {
-            if (navigation.isUrlCollectionPath(location.pathname)) {
-                const newFlag = location.hash === `#${NEW_URL_HASH}`;
+
+        const newFlag = location.hash === `#${NEW_URL_HASH}`;
+        const sideFlag = location.hash === `#${SIDE_URL_HASH}`;
+
+        if (!navigation.loading) {
+            if ((newFlag || sideFlag) && navigation.isUrlCollectionPath(location.pathname)) {
                 const entityOrCollectionPath = navigation.urlPathToDataPath(location.pathname);
                 const panelsFromUrl = buildSidePanelsFromUrl(entityOrCollectionPath, navigation.collections ?? [], newFlag);
                 for (let i = 0; i < panelsFromUrl.length; i++) {
-                    const panel = panelsFromUrl[i];
-                    setTimeout(() => {
-                        if (i === 0)
-                            sideDialogsController.replace(propsToSidePanel(panel, navigation, smallLayout));
-                        else
-                            sideDialogsController.open(propsToSidePanel(panel, navigation, smallLayout))
-                    }, 1);
+                    const props = panelsFromUrl[i];
+                    if (i === 0)
+                        sideDialogsController.replace(propsToSidePanel(props, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout));
+                    else
+                        sideDialogsController.open(propsToSidePanel(props, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout))
                 }
             }
             initialised.current = true;
         }
-    }, [location, navigation, sideDialogsController, smallLayout]);
+    }, [navigation.loading]);
+
+    // sync panels if URL changes with #side
+    const currentPanelKeys = sideDialogsController.sidePanels.map(p => p.key);
+    useEffect(() => {
+        if (initialised.current) {
+            const sideFlag = location.hash === `#${SIDE_URL_HASH}`;
+            if (sideFlag) {
+                const entityOrCollectionPath = navigation.urlPathToDataPath(location.pathname);
+                const panelsFromUrl = buildSidePanelsFromUrl(entityOrCollectionPath, navigation.collections ?? [], false);
+                // if we have more panels than determined by the url, we ignore the url. We might have references open
+                if (panelsFromUrl.length <= currentPanelKeys.length) {
+                    return;
+                }
+                const lastPanel = panelsFromUrl[panelsFromUrl.length - 1];
+                const panelProps = propsToSidePanel(lastPanel, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout);
+                const lastCurrentPanel = currentPanelKeys.length > 0 ? currentPanelKeys[currentPanelKeys.length - 1] : undefined;
+                if (!lastCurrentPanel || lastCurrentPanel !== panelProps.key) {
+                    sideDialogsController.replace(panelProps);
+                }
+            }
+        }
+    }, [location.pathname, location.hash, currentPanelKeys]);
+
+    // update side panels to match browser size
+    useEffect(() => {
+        const updatedSidePanels = sideDialogsController.sidePanels.map(sidePanelProps => {
+            if (sidePanelProps.additional) {
+                return propsToSidePanel(sidePanelProps.additional, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout);
+            }
+            return sidePanelProps;
+        });
+        sideDialogsController.setSidePanels(updatedSidePanels);
+    }, [smallLayout]);
 
     const close = useCallback(() => {
         sideDialogsController.close();
@@ -70,12 +165,17 @@ export const useBuildSideEntityController = (navigation: NavigationController,
             }
         );
 
-        sideDialogsController.open(propsToSidePanel({
-            selectedSubPath: defaultSelectedView,
-            ...props,
-        }, navigation, smallLayout));
+        sideDialogsController.open(
+            propsToSidePanel({
+                    selectedTab: defaultSelectedView,
+                    ...props
+                },
+                navigation.buildUrlCollectionPath,
+                navigation.resolveIdsFrom,
+                smallLayout
+            ));
 
-    }, [sideDialogsController, navigation, smallLayout]);
+    }, [sideDialogsController, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout]);
 
     const replace = useCallback((props: EntitySidePanelProps<any>) => {
 
@@ -83,9 +183,9 @@ export const useBuildSideEntityController = (navigation: NavigationController,
             throw Error("If you want to copy an entity you need to provide an entityId");
         }
 
-        sideDialogsController.replace(propsToSidePanel(props, navigation, smallLayout));
+        sideDialogsController.replace(propsToSidePanel(props, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout));
 
-    }, [navigation, sideDialogsController, smallLayout]);
+    }, [navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, sideDialogsController, smallLayout]);
 
     return {
         close,
@@ -96,12 +196,12 @@ export const useBuildSideEntityController = (navigation: NavigationController,
 
 export function buildSidePanelsFromUrl(path: string, collections: EntityCollection[], newFlag: boolean): EntitySidePanelProps<any>[] {
 
-    const navigationViewsForPath: NavigationViewInternal<any>[] = getNavigationEntriesFromPathInternal({
+    const navigationViewsForPath: NavigationViewInternal<any>[] = getNavigationEntriesFromPath({
         path,
         collections
     });
 
-    const sidePanels: EntitySidePanelProps<any>[] = [];
+    let sidePanel: EntitySidePanelProps<any> | undefined = undefined;
     let lastCollectionPath = "";
     for (let i = 0; i < navigationViewsForPath.length; i++) {
         const navigationEntry = navigationViewsForPath[i];
@@ -110,63 +210,70 @@ export function buildSidePanelsFromUrl(path: string, collections: EntityCollecti
             lastCollectionPath = navigationEntry.path;
         }
 
-        if (i > 0) { // the first collection is handled by the main navigation
-            const previousEntry = navigationViewsForPath[i - 1];
-            if (navigationEntry.type === "entity") {
-                sidePanels.push({
-                        path: navigationEntry.path,
-                        entityId: navigationEntry.entityId,
-                        copy: false
-                    }
-                );
-            } else if (navigationEntry.type === "custom_view") {
-                if (previousEntry.type === "entity") {
-                    const lastSidePanel: EntitySidePanelProps<any> = sidePanels[sidePanels.length - 1];
-                    if (lastSidePanel)
-                        lastSidePanel.selectedSubPath = navigationEntry.view.key;
-                }
-            } else if (navigationEntry.type === "collection") {
-                if (previousEntry.type === "entity") {
-                    const lastSidePanel: EntitySidePanelProps<any> = sidePanels[sidePanels.length - 1];
-                    if (lastSidePanel)
-                        lastSidePanel.selectedSubPath = navigationEntry.collection.id ?? navigationEntry.collection.path;
-                }
+        const previousEntry = navigationViewsForPath[i - 1];
+        if (navigationEntry.type === "entity") {
+            sidePanel = {
+                path: navigationEntry.path,
+                entityId: navigationEntry.entityId,
+                copy: false,
+                width: navigationEntry.parentCollection?.sideDialogWidth
+            };
+        } else if (navigationEntry.type === "custom_view") {
+            if (previousEntry?.type === "entity") {
+                if (sidePanel)
+                    sidePanel.selectedTab = navigationEntry.view.key;
+            }
+        } else if (navigationEntry.type === "collection") {
+            if (previousEntry?.type === "entity") {
+                if (sidePanel)
+                    sidePanel.selectedTab = navigationEntry.collection.id ?? navigationEntry.collection.path;
             }
         }
 
     }
 
     if (newFlag) {
-        sidePanels.push({
+        sidePanel = {
             path: lastCollectionPath,
             copy: false
-        });
+        }
     }
 
-    return sidePanels;
+    return sidePanel ? [sidePanel] : [];
 }
 
-const propsToSidePanel = (props: EntitySidePanelProps<any>, navigation: NavigationController, smallLayout: boolean): SideDialogPanelProps => {
 
-        const collectionPath = removeInitialAndTrailingSlashes(props.path);
+const propsToSidePanel = (props: EntitySidePanelProps,
+                          buildUrlCollectionPath: (path: string) => string,
+                          resolveIdsFrom: (pathWithAliases: string) => string,
+                          smallLayout: boolean): SideDialogPanelProps => {
 
-        const newPath = props.entityId
-            ? navigation.buildUrlCollectionPath(`${collectionPath}/${props.entityId}/${props.selectedSubPath || ""}`)
-            : navigation.buildUrlCollectionPath(`${collectionPath}#${NEW_URL_HASH}`);
-        const resolvedPath = navigation.resolveAliasesFrom(props.path);
+    const collectionPath = removeInitialAndTrailingSlashes(props.path);
 
-        const resolvedPanelProps: EntitySidePanelProps<any> = {
-            ...props,
-            path: resolvedPath
-        };
+    const newPath = props.entityId
+        ? buildUrlCollectionPath(`${collectionPath}/${props.entityId}${props.selectedTab ? "/" + props.selectedTab : ""}#${SIDE_URL_HASH}`)
+        : buildUrlCollectionPath(`${collectionPath}#${NEW_URL_HASH}`);
+    const resolvedPath = resolveIdsFrom(props.path);
 
-        return ({
-            key: `${props.path}/${props.entityId}`,
-            component: <EntitySidePanel {...resolvedPanelProps}/>,
-            urlPath: newPath,
-            parentUrlPath: navigation.buildUrlCollectionPath(collectionPath),
-            width: getEntityViewWidth(props, smallLayout),
-            onClose: props.onClose
-        });
-    }
-;
+    const resolvedPanelProps: EntitySidePanelProps<any> = {
+        ...props,
+        path: resolvedPath,
+        formProps: props.formProps
+    };
+
+    const entityViewWidth = getEntityViewWidth(props, smallLayout);
+
+    return {
+        key: `${props.path}/${props.entityId}`,
+        component: <EntitySidePanel {...resolvedPanelProps}/>,
+        urlPath: newPath,
+        parentUrlPath: buildUrlCollectionPath(collectionPath),
+        width: entityViewWidth,
+        onClose: props.onClose,
+        additional: props
+    };
+}
+
+function isSideUrl(url: string): boolean {
+    return url.endsWith("#" + SIDE_URL_HASH) || url.endsWith("#" + NEW_URL_HASH);
+}

package/src/internal/useUnsavedChangesDialog.tsx

@@ -1,106 +1,142 @@
-import React, { useCallback } from "react";
-import { Blocker, Transition } from "history";
-import { UNSAFE_NavigationContext, useNavigate } from "react-router-dom";
-import { Button, Dialog, DialogActions, DialogContent, Typography } from "@firecms/ui";
+import React, { useCallback, useEffect, useState } from "react";
+import { Button, Dialog, DialogActions, DialogContent, DialogTitle, Typography } from "@firecms/ui";
 
-export function useNavigationUnsavedChangesDialog(when: boolean, onSuccess: () => void):
-    {
-        navigationWasBlocked: boolean,
-        handleCancel: () => void,
-        handleOk: () => void
-    } {
-
-    const [nextLocation, setNextLocation] = React.useState<any | undefined>();
-    const { navigator } = React.useContext(UNSAFE_NavigationContext);
+/**
+ * Type representing a pending navigation action.
+ */
+type PendingNavigation =
+    | {
+    type: "popstate";
+    delta: number;
+}
+    | {
+    type: "link";
+    href: string;
+}
+    | null;
 
-    const navigate = useNavigate();
+/**
+ * Custom hook to handle navigation blocking when there are unsaved changes.
+ *
+ * @param when - Indicates whether to block navigation.
+ * @param onSuccess - Callback invoked when navigation is confirmed.
+ * @returns An object containing the state of navigation blocking and handlers.
+ */
+export function useNavigationUnsavedChangesDialog(
+    when: boolean,
+    onSuccess: () => void
+): {
+    navigationWasBlocked: boolean;
+    handleCancel: () => void;
+    handleOk: () => void;
+} {
+    const [isDialogOpen, setIsDialogOpen] = useState<boolean>(false);
+    const [pendingNavigation, setPendingNavigation] = useState<PendingNavigation>(null);
 
-    const handleCancel = () => {
-        setNextLocation(undefined);
-    };
+    /**
+     * Handler to cancel the navigation attempt.
+     */
+    const handleCancel = useCallback(() => {
+        setIsDialogOpen(false);
+        setPendingNavigation(null);
+    }, []);
 
-    const handleOk = () => {
-        onSuccess();
-        setNextLocation(undefined);
-        navigate(-1);
-    };
+    /**
+     * Handler to confirm and proceed with the navigation.
+     */
+    const handleOk = useCallback(() => {
+        setIsDialogOpen(false);
+        if (pendingNavigation) {
+            onSuccess();
+            if (pendingNavigation.type === "popstate") {
+                window.history.go(pendingNavigation.delta);
+            } else if (pendingNavigation.type === "link") {
+                window.location.href = pendingNavigation.href;
+            }
+            setPendingNavigation(null);
+        }
+    }, [onSuccess, pendingNavigation]);
 
-    const blocker: Blocker = useCallback(({
-                                              action,
-                                              location: nextLocation,
-                                              retry
-                                          }) => {
-        switch (action) {
-            case "REPLACE": {
-                retry();
-                return;
+    /**
+     * Event handler for beforeunload to handle page refresh or tab close.
+     */
+    const handleBeforeUnload = useCallback(
+        (e: BeforeUnloadEvent) => {
+            if (when) {
+                e.preventDefault();
+                e.returnValue = "";
             }
-            case "POP": {
-                setNextLocation(nextLocation);
+        },
+        [when]
+    );
+
+    /**
+     * Event handler for popstate to handle back and forward browser buttons.
+     */
+    const handlePopState = useCallback(
+        (e: PopStateEvent) => {
+            if (when) {
+                e.preventDefault();
+                // Assuming backward navigation; adjust delta as needed
+                setPendingNavigation({
+                    type: "popstate",
+                    delta: -1
+                });
+                setIsDialogOpen(true);
             }
-        }
-    }, []);
+        },
+        [when]
+    );
+
+    /**
+     * Event handler to intercept link clicks within the application.
+     */
+    const handleLinkClick = useCallback(
+        (e: MouseEvent) => {
+            if (!when) return;
 
-    React.useEffect(() => {
-        if (!when) return;
-        if (nextLocation) return;
-        if (!("block" in navigator)) return;
-        const unblock = (navigator as any).block((tx: Transition) => {
-            const autoUnblockingTx = {
-                ...tx,
-                retry() {
-                    unblock();
-                    tx.retry();
+            const target = e.target as HTMLElement;
+            const anchor = target.closest("a[href]") as HTMLAnchorElement | null;
+            if (anchor && anchor.host === window.location.host) {
+                e.preventDefault();
+                const href = anchor.getAttribute("href");
+                if (href) {
+                    setPendingNavigation({
+                        type: "link",
+                        href
+                    });
+                    setIsDialogOpen(true);
                 }
-            };
-            blocker(autoUnblockingTx);
-        });
+            }
+        },
+        [when]
+    );
+
+    /**
+     * Effect hook to add and clean up event listeners based on the `when` condition.
+     */
+    useEffect(() => {
+        if (when) {
+            window.addEventListener("beforeunload", handleBeforeUnload);
+            window.addEventListener("popstate", handlePopState);
+            document.addEventListener("click", handleLinkClick);
+        } else {
+            window.removeEventListener("beforeunload", handleBeforeUnload);
+            window.removeEventListener("popstate", handlePopState);
+            document.removeEventListener("click", handleLinkClick);
+        }
 
-        return unblock;
-    }, [navigator, blocker, when, nextLocation]);
+        // Cleanup on unmount or when `when` changes
+        return () => {
+            window.removeEventListener("beforeunload", handleBeforeUnload);
+            window.removeEventListener("popstate", handlePopState);
+            document.removeEventListener("click", handleLinkClick);
+        };
+    }, [when, handleBeforeUnload, handlePopState, handleLinkClick]);
 
     return {
-        navigationWasBlocked: Boolean(nextLocation),
+        navigationWasBlocked: isDialogOpen,
         handleCancel,
-        handleOk
+        handleOk,
     };
 }
-
-export interface UnsavedChangesDialogProps {
-    open: boolean;
-    body?: React.ReactNode;
-    title?: string;
-    handleOk: () => void;
-    handleCancel: () => void;
-}
-
-export function UnsavedChangesDialog({
-                                         open,
-                                         handleOk,
-                                         handleCancel,
-                                         body,
-                                         title
-                                     }: UnsavedChangesDialogProps) {
-
-    return (
-        <Dialog
-            open={open}
-            onOpenChange={(open) => open ? handleCancel() : handleOk()}
-        >
-            <DialogContent>
-                <Typography variant={"h6"}>{title}</Typography>
-
-                {body}
-
-                <Typography>
-                    Are you sure you want to leave this page?
-                </Typography>
-
-            </DialogContent>
-            <DialogActions>
-                <Button variant="text" onClick={handleCancel} autoFocus> Cancel </Button>
-                <Button onClick={handleOk}> Ok </Button>
-            </DialogActions>
-        </Dialog>
-    );
-}

package/src/preview/PropertyPreview.tsx

@@ -47,17 +47,16 @@ export const PropertyPreview = React.memo(function PropertyPreview<T extends CMS
         size,
         height,
         width,
-        // entity
+        interactive
     } = props;
 
     const property = resolveProperty({
         propertyKey,
         propertyOrBuilder: inputProperty,
-        propertyValue: value,
-        fields: customizationController.propertyConfigs
+        propertyConfigs: customizationController.propertyConfigs
     });
 
-    if (value === undefined || property === null) {
+    if (property === null) {
         content = <EmptyValue/>;
     } else if (property.Preview) {
         content = createElement(property.Preview as React.ComponentType<PropertyPreviewProps>,
@@ -71,12 +70,19 @@ export const PropertyPreview = React.memo(function PropertyPreview<T extends CMS
                 // entity,
                 customProps: property.customProps
             });
-    } else if (value === null) {
+    } else if (value === undefined || value === null) {
         content = <EmptyValue/>;
     } else if (property.dataType === "string") {
         const stringProperty = property as ResolvedStringProperty;
         if (typeof value === "string") {
-            if (stringProperty.url) {
+            if (stringProperty.storage) {
+                const filePath = stringProperty.storage.previewUrl ? stringProperty.storage.previewUrl(value) : value;
+                content = <StorageThumbnail
+                    interactive={interactive}
+                    storeUrl={property.storage?.storeUrl ?? false}
+                    size={props.size}
+                    storagePathOrDownloadUrl={filePath}/>;
+            } else if (stringProperty.url) {
                 if (typeof stringProperty.url === "boolean")
                     content =
                         <UrlComponentPreview size={props.size}
@@ -85,14 +91,10 @@ export const PropertyPreview = React.memo(function PropertyPreview<T extends CMS
                     content =
                         <UrlComponentPreview size={props.size}
                                              url={value}
+                                             interactive={interactive}
                                              previewType={stringProperty.url}/>;
-            } else if (stringProperty.storage) {
-                content = <StorageThumbnail
-                    storeUrl={property.storage?.storeUrl ?? false}
-                    size={props.size}
-                    storagePathOrDownloadUrl={value}/>;
             } else if (stringProperty.markdown) {
-                content = <Markdown source={value}/>;
+                content = <Markdown source={value} size={"small"}/>;
             } else {
                 content = <StringPropertyPreview {...props}
                                                  property={stringProperty}
@@ -113,17 +115,7 @@ export const PropertyPreview = React.memo(function PropertyPreview<T extends CMS
                     content = <ArrayPropertyPreview {...props}
                                                     value={value}
                                                     property={property as ResolvedArrayProperty}/>;
-                }
-                    // else if (arrayProperty.of.dataType === "map") {
-                    //     content =
-                    //         <ArrayOfMapsPreview propertyKey={propertyKey}
-                    //                             property={property as ResolvedArrayProperty}
-                    //                             value={value as Record<string, any>[]} // This might be wrong
-                    //                             entity={entity}
-                    //                             size={size}
-                    //         />;
-                // }
-                else if (arrayProperty.of.dataType === "reference") {
+                } else if (arrayProperty.of.dataType === "reference") {
                     content = <ArrayOfReferencesPreview {...props}
                                                         value={value}
                                                         property={property as ResolvedArrayProperty}/>;
@@ -182,8 +174,9 @@ export const PropertyPreview = React.memo(function PropertyPreview<T extends CMS
                 content = <ReferencePreview
                     disabled={!property.path}
                     previewProperties={property.previewProperties}
+                    includeId={property.includeId}
+                    includeEntityLink={property.includeEntityLink}
                     size={props.size}
-                    // onClick={props.onClick}
                     reference={value as EntityReference}
                 />;
             } else {

package/src/preview/PropertyPreviewProps.tsx

@@ -3,7 +3,7 @@ import { CMSType, Property, ResolvedProperty } from "../types";
 /**
  * @group Preview components
  */
-export type PreviewSize = "medium" | "small" | "tiny";
+export type PreviewSize = "small" | "medium" | "large";
 
 /**
  * @group Preview components
@@ -46,4 +46,10 @@ export interface PropertyPreviewProps<T extends CMSType = any, CustomProps = any
      */
     customProps?: CustomProps;
 
+    /**
+     * If the preview should be interactive or not.
+     * This applies only to videos.
+     */
+    interactive?: boolean;
+
 }