@firecms/core 3.0.0-canary.24 → 3.0.0-canary.241

package/src/internal/useBuildSideEntityController.tsx

@@ -1,57 +1,168 @@
 import { useCallback, useEffect, useRef } from "react";
 import {
+    AuthController,
+    CustomizationController,
     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,
+    resolvedSelectedEntityView
+} from "../util";
 import { ADDITIONAL_TAB_WIDTH, CONTAINER_FULL_WIDTH, FORM_CONTAINER_WIDTH } from "./common";
-import { useLargeLayout } from "../hooks";
+import { useCustomizationController, useLargeLayout } from "../hooks";
 import { EntitySidePanel } from "../core/EntitySidePanel";
+import { JSON_TAB_VALUE } from "../core/EntityEditView";
 
-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 {
+export function getEntityViewWidth(props: EntitySidePanelProps<any>, small: boolean, customizationController: CustomizationController, authController: AuthController): 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 {
+        selectedSecondaryForm
+    } = resolvedSelectedEntityView(props.collection?.entityViews, customizationController, props.selectedTab);
+
+    const shouldUseSmallLayout = !props.selectedTab || props.selectedTab === JSON_TAB_VALUE || props.selectedTab === "__history" || Boolean(selectedSecondaryForm);
+
+    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 (!shouldUseSmallLayout) {
+        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, authController);
+        }
+    }
+}
+
+const collectionViewWidthCache: { [key: string]: string } = {};
+
+function calculateCollectionDesiredWidth(collection: EntityCollection<any>, authController: AuthController): string {
+    if (collectionViewWidthCache[collection.id]) {
+        return collectionViewWidthCache[collection.id];
+    }
+    const resolvedCollection = resolveCollection({
+        collection,
+        path: "__ignored",
+        ignoreMissingFields: true,
+        authController
+    });
+
+    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,
-                                             sideDialogsController: SideDialogsController): SideEntityController => {
+                                             sideDialogsController: SideDialogsController,
+                                             authController: AuthController
+): SideEntityController => {
 
     const location = useLocation();
     const initialised = useRef<boolean>(false);
+    const customizationController = useCustomizationController();
 
     const smallLayout = !useLargeLayout();
 
-    // only on initialisation, create panels from URL
     useEffect(() => {
-        if (!navigation.loading && !initialised.current) {
-            console.debug("Initialising side entity controller");
-            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, customizationController, authController));
+                    else
+                        sideDialogsController.open(propsToSidePanel(props, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout, customizationController, authController))
                 }
             }
             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, customizationController, authController);
+                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, customizationController, authController);
+            }
+            return sidePanelProps;
+        });
+        sideDialogsController.setSidePanels(updatedSidePanels);
+    }, [smallLayout]);
 
     const close = useCallback(() => {
         sideDialogsController.close();
@@ -71,12 +182,19 @@ export const useBuildSideEntityController = (navigation: NavigationController,
             }
         );
 
-        sideDialogsController.open(propsToSidePanel({
-            selectedSubPath: defaultSelectedView,
-            ...props,
-        }, navigation, smallLayout));
+        sideDialogsController.open(
+            propsToSidePanel({
+                    selectedTab: defaultSelectedView,
+                    ...props
+                },
+                navigation.buildUrlCollectionPath,
+                navigation.resolveIdsFrom,
+                smallLayout,
+                customizationController,
+                authController
+            ));
 
-    }, [sideDialogsController, navigation, smallLayout]);
+    }, [sideDialogsController, navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, smallLayout, authController.user]);
 
     const replace = useCallback((props: EntitySidePanelProps<any>) => {
 
@@ -84,9 +202,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, customizationController, authController));
 
-    }, [navigation, sideDialogsController, smallLayout]);
+    }, [navigation.buildUrlCollectionPath, navigation.resolveIdsFrom, sideDialogsController, smallLayout, authController.user]);
 
     return {
         close,
@@ -97,12 +215,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];
@@ -111,63 +229,71 @@ 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,
+                // fullIdPath: 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,
+            // fullIdPath: lastCollectionPath,
             copy: false
-        });
+        }
     }
 
-    return sidePanels;
+    return sidePanel ? [sidePanel] : [];
 }
 
-const propsToSidePanel = (props: EntitySidePanelProps<any>, navigation: NavigationController, smallLayout: boolean): SideDialogPanelProps => {
+const propsToSidePanel = (props: EntitySidePanelProps,
+                          buildUrlCollectionPath: (path: string) => string,
+                          resolveIdsFrom: (pathWithAliases: string) => string,
+                          smallLayout: boolean,
+                          customizationController: CustomizationController,
+                          authController: AuthController
+): SideDialogPanelProps => {
 
-        const collectionPath = removeInitialAndTrailingSlashes(props.path);
+    const collectionPath = removeInitialAndTrailingSlashes(props.path);
 
-        const newPath = props.entityId
-            ? navigation.buildUrlCollectionPath(`${collectionPath}/${props.entityId}/${props.selectedSubPath || ""}`)
-            : navigation.buildUrlCollectionPath(`${collectionPath}#${NEW_URL_HASH}`);
-        const resolvedPath = navigation.resolveAliasesFrom(props.path);
+    const newPath = props.entityId
+        ? buildUrlCollectionPath(`${collectionPath}/${props.entityId}${props.selectedTab ? "/" + props.selectedTab : ""}#${SIDE_URL_HASH}`)
+        : buildUrlCollectionPath(`${collectionPath}#${NEW_URL_HASH}`);
 
-        const resolvedPanelProps: EntitySidePanelProps<any> = {
-            ...props,
-            path: resolvedPath
-        };
+    const resolvedPanelProps: EntitySidePanelProps<any> = {
+        ...props,
+        formProps: props.formProps
+    };
 
-        return ({
-            key: `${props.path}/${props.entityId}`,
-            component: <EntitySidePanel {...resolvedPanelProps}/>,
-            urlPath: newPath,
-            parentUrlPath: navigation.buildUrlCollectionPath(collectionPath),
-            width: getEntityViewWidth(props, smallLayout),
-            onClose: props.onClose
-        });
-    }
-;
+    const entityViewWidth = getEntityViewWidth(props, smallLayout, customizationController, authController);
+    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>
-    );
-}