@firecms/core 3.0.0-beta.13 → 3.0.0-beta.15

package/src/util/icons.tsx

@@ -4,13 +4,28 @@ import { coolIconKeys, Icon, IconColor, iconKeys } from "@firecms/ui";
 import { slugify } from "./strings";
 import equal from "react-fast-compare"
 
-export function getIcon(iconKey?: string, className?: string, color?:IconColor): React.ReactElement | undefined {
+export function getIcon(iconKey?: string | React.ReactNode,
+                        className?: string,
+                        color?: IconColor,
+                        size?: "smallest" | "small" | "medium" | "large" | number,): React.ReactElement | undefined {
+
+    if (React.isValidElement(iconKey)) {
+        return iconKey;
+    }
+
     if (!iconKey) return undefined;
-    iconKey = slugify(iconKey);
-    if (!(iconKey in iconKeysMap)) {
-        return undefined;
+    if (typeof iconKey === "string") {
+
+        const usedIconKey = slugify(iconKey);
+        if (!(usedIconKey in iconKeysMap)) {
+            return undefined;
+        }
+        return usedIconKey in iconKeysMap ?
+            <Icon iconKey={usedIconKey} size={size} className={className} color={color}/> : undefined;
     }
-    return iconKey in iconKeysMap ? <Icon iconKey={iconKey} size={"medium"} className={className} color={color}/> : undefined;
+
+    console.warn("Invalid icon key provided:", iconKey);
+    return undefined;
 }
 
 export type IconViewProps = {
@@ -18,7 +33,7 @@ export type IconViewProps = {
     name: string;
     singularName?: string;
     group?: string;
-    icon?: string;
+    icon?: string | React.ReactNode;
 }
 
 export const IconForView = React.memo(
@@ -34,7 +49,7 @@ export const IconForView = React.memo(
         size?: "smallest" | "small" | "medium" | "large" | number,
     }): React.ReactElement {
         if (!collectionOrView) return <></>;
-        const icon = getIcon(collectionOrView.icon, className, color);
+        const icon = getIcon(collectionOrView.icon, className, color, size);
         if (collectionOrView?.icon && icon)
             return icon;
 

package/src/util/index.ts

@@ -23,3 +23,4 @@ export * from "./join_collections";
 export * from "./builders";
 export * from "./useTraceUpdate";
 export * from "./storage";
+export * from "./callbacks";

package/src/util/join_collections.ts

@@ -100,13 +100,15 @@ export function mergeCollection(target: EntityCollection,
     const sourcePropertiesOrder = getCollectionKeys(source);
     const mergedPropertiesOrder = [...new Set([...sourcePropertiesOrder, ...targetPropertiesOrder])];
     const mergedEntityViews = [...new Set([...(target.entityViews ?? []), ...(source.entityViews ?? [])])];
+    const mergedEntityActions = [...new Set([...(target.entityActions ?? []), ...(source.entityActions ?? [])])];
 
     let resultCollection: EntityCollection = {
         ...mergedCollection,
         subcollections: subcollectionsMerged,
         properties: sortProperties(propertiesMerged, mergedPropertiesOrder),
         propertiesOrder: mergedPropertiesOrder,
-        entityViews: mergedEntityViews
+        entityViews: mergedEntityViews,
+        entityActions: mergedEntityActions,
     };
     if (modifyCollection) {
         const modifiedCollection = modifyCollection({

package/src/util/navigation_from_path.ts

@@ -11,6 +11,7 @@ export interface NavigationViewEntityInternal<M extends Record<string, any>> {
     type: "entity";
     entityId: string;
     path: string;
+    fullIdPath: string;
     fullPath: string;
     parentCollection: EntityCollection<M>;
 }
@@ -19,6 +20,7 @@ export interface NavigationViewCollectionInternal<M extends Record<string, any>>
     type: "collection";
     id: string;
     path: string;
+    fullIdPath: string;
     fullPath: string;
     collection: EntityCollection<M>;
 }
@@ -26,6 +28,7 @@ export interface NavigationViewCollectionInternal<M extends Record<string, any>>
 export interface NavigationViewEntityCustomInternal<M extends Record<string, any>> {
     type: "custom_view";
     path: string;
+    fullIdPath: string;
     fullPath: string;
     entityId: string;
     view: EntityCustomView<M>;
@@ -35,13 +38,15 @@ export function getNavigationEntriesFromPath(props: {
     path: string,
     collections: EntityCollection[] | undefined,
     currentFullPath?: string,
+    currentFullIdPath?: string,
     contextEntityViews?: EntityCustomView<any>[]
 }): NavigationViewInternal [] {
 
     const {
         path,
         collections = [],
-        currentFullPath
+        currentFullPath,
+        currentFullIdPath
     } = props;
 
     const subpaths = removeInitialAndTrailingSlashes(path).split("/");
@@ -58,16 +63,18 @@ export function getNavigationEntriesFromPath(props: {
         }
 
         if (collection) {
-            const pathOrAlias = collection.id ?? collection.path;
             const collectionPath = currentFullPath && currentFullPath.length > 0
-                ? (currentFullPath + "/" + pathOrAlias)
-                : pathOrAlias;
-
+                ? (currentFullPath + "/" + collection.path)
+                : collection.path;
+            const fullIdPath = currentFullIdPath && currentFullIdPath.length > 0
+                ? (currentFullIdPath + "/" + collection.id)
+                : collection.id;
             result.push({
                 type: "collection",
                 id: collection.id,
                 path: collectionPath,
                 fullPath: collectionPath,
+                fullIdPath,
                 collection
             });
             const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
@@ -79,6 +86,7 @@ export function getNavigationEntriesFromPath(props: {
                     type: "entity",
                     entityId,
                     path: collectionPath,
+                    fullIdPath,
                     fullPath: fullPath,
                     parentCollection: collection
                 });
@@ -97,6 +105,7 @@ export function getNavigationEntriesFromPath(props: {
                             type: "custom_view",
                             path: collectionPath,
                             entityId: entityId,
+                            fullIdPath,
                             fullPath: fullPath + "/" + customView.key,
                             view: customView
                         });
@@ -105,6 +114,7 @@ export function getNavigationEntriesFromPath(props: {
                             path: newPath,
                             collections: collection.subcollections,
                             currentFullPath: fullPath,
+                            currentFullIdPath: fullIdPath,
                             contextEntityViews: props.contextEntityViews
                         }));
                     }

package/src/util/navigation_utils.ts

@@ -32,75 +32,90 @@ export function getLastSegment(path: string) {
 }
 
 export function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string {
-    const cleanPath = removeInitialAndTrailingSlashes(path);
-    const subpaths = cleanPath.split("/");
-
-    if (subpaths.length % 2 === 0) {
-        throw Error(`resolveCollectionPathIds: Collection paths must have an odd number of segments: ${path}`);
-    }
-
-    // Check if the path exactly matches a collection path
-    const exactMatch = allCollections.find(col => col.path === cleanPath);
-    if (exactMatch) {
-        return exactMatch.path;
+    let remainingPath = removeInitialAndTrailingSlashes(path);
+    if (!remainingPath) {
+        return "";
     }
 
-    if (subpaths.length === 1) {
-        // Find collection by ID and return its path
-        const aliasedCollection = allCollections.find((col) => col.id === subpaths[0]);
-        return aliasedCollection?.path ?? subpaths[0];
-    }
+    let currentCollections: EntityCollection[] | undefined = allCollections;
+    const resolvedPathParts: string[] = [];
 
-    // Try to match a multi-segment collection path
-    let matchingCollection: EntityCollection | undefined;
-    let entityIndex = 1;
-
-    // Check if the path starts with a multi-segment collection path
-    for (const collection of allCollections) {
-        const pathSegments = collection.path.split("/");
-        if (pathSegments.length > 1 &&
-            subpaths.slice(0, pathSegments.length).join("/") === collection.path) {
-            matchingCollection = collection;
-            entityIndex = pathSegments.length;
+    while (remainingPath.length > 0) {
+        if (!currentCollections || currentCollections.length === 0) {
+            // We have remaining path segments but no more collections to match against
+            console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+            resolvedPathParts.push(remainingPath);
+            remainingPath = ""; // Stop processing
             break;
         }
-    }
-
-    // If no multi-segment match, fall back to single segment matching
-    if (!matchingCollection) {
-        const matchingCollections = allCollections.filter(col =>
-            col.id === subpaths[0] || col.path === subpaths[0]
-        );
 
-        if (!matchingCollections.length) {
-            return cleanPath;
-        }
+        let foundMatch = false;
+        // Sort potential matches by length descending to prioritize longer matches (e.g., "a/b" over "a")
+        const potentialMatches: { col: EntityCollection; match: string; }[] = currentCollections
+            .flatMap(col => [{
+                col,
+                match: col.path
+            }, {
+                col,
+                match: col.id
+            }])
+            .filter(p => p.match && remainingPath.startsWith(p.match))
+            .sort((a, b) => b.match.length - a.match.length);
+
+        if (potentialMatches.length > 0) {
+            const {
+                col: foundCollection,
+                match: matchString
+            } = potentialMatches[0];
+
+            resolvedPathParts.push(foundCollection.path); // Use the defined path
+            remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
+
+            // Check if we are at the end of the path
+            if (remainingPath.length === 0) {
+                foundMatch = true;
+                break; // Path ends with a collection segment
+            }
 
-        matchingCollection = matchingCollections[0];
-    }
+            // The next segment must be an entity ID
+            const idSeparatorIndex = remainingPath.indexOf("/");
+            let entityId: string;
+            if (idSeparatorIndex > -1) {
+                entityId = remainingPath.substring(0, idSeparatorIndex);
+                remainingPath = remainingPath.substring(idSeparatorIndex + 1);
+            } else {
+                // This should not happen if the original path is valid (odd segments)
+                // but handle it defensively: assume the rest is the ID
+                entityId = remainingPath;
+                remainingPath = "";
+                console.warn(`resolveCollectionPathIds: Path seems to end with an entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
+                // Even if it ends here, we still need to push the ID
+            }
 
-    const entityId = subpaths[entityIndex];
-    const remainingPath = subpaths.slice(entityIndex + 1);
+            resolvedPathParts.push(entityId); // Append entity ID
+            currentCollections = foundCollection.subcollections; // Move to subcollections
+            foundMatch = true;
 
-    // If we have a subcollection ID, try to resolve it
-    if (remainingPath.length > 0) {
-        const subcollectionId = remainingPath[0];
-        const subcollection = matchingCollection.subcollections?.find(
-            subcol => subcol.id === subcollectionId
-        );
+            if (!currentCollections && remainingPath.length > 0) {
+                // Warn if the path continues but no subcollections were defined
+                console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.path}" in path "${path}". Appending remaining original path.`);
+                resolvedPathParts.push(remainingPath); // Append the rest
+                remainingPath = ""; // Stop processing
+                break;
+            }
 
-        if (subcollection) {
-            return `${matchingCollection.path}/${entityId}/${subcollection.path}`;
         }
-    }
 
-    // If there are no remaining path segments, just return the collection path with entity ID
-    if (remainingPath.length === 0) {
-        return `${matchingCollection.path}/${entityId}`;
+        if (!foundMatch) {
+            // Collection definition not found for the start of the remaining path
+            console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+            resolvedPathParts.push(remainingPath); // Append the rest
+            remainingPath = ""; // Stop processing
+            break;
+        }
     }
 
-    // Default case - couldn't match subcollection
-    return `${matchingCollection.path}/${entityId}/${remainingPath.join("/")}`;
+    return resolvedPathParts.join("/");
 }
 
 /**
@@ -186,8 +201,8 @@ export function navigateToEntity({
 
         sideEntityController.open({
             entityId,
-            path: fullIdPath ?? path,
-            // fullIdPath,
+            path,
+            fullIdPath,
             copy,
             selectedTab,
             collection,

package/src/util/objects.ts

@@ -12,32 +12,65 @@ export function isObject(item: any) {
     return item && typeof item === "object" && !Array.isArray(item);
 }
 
-export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(target: T, source: U, ignoreUndefined: boolean = false): T & U {
-    const targetIsObject = isObject(target);
-    const output = targetIsObject ? { ...target } : target;
-    if (targetIsObject && isObject(source)) {
-        Object.keys(source).forEach(key => {
-            const sourceElement = source[key];
-            // Skip undefined values when ignoreUndefined is true
-            if (ignoreUndefined && sourceElement === undefined) {
-                return;
+export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(
+    target: T,
+    source: U,
+    ignoreUndefined: boolean = false
+): T & U {
+    // If target is not a true object (e.g., null, array, primitive), return target itself.
+    if (!isObject(target)) {
+        return target as T & U;
+    }
+
+    // Create a shallow copy of the target to avoid modifying the original object.
+    const output = { ...target };
+
+    // If source is not a true object, there's nothing to merge from it.
+    // Return the shallow copy of target.
+    if (!isObject(source)) {
+        return output as T & U;
+    }
+
+    // Iterate over keys in the source object.
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const outputValue = (output as any)[key]; // Current value in our merged object (originating from target)
+
+            // Skip if source value is undefined and ignoreUndefined is true.
+            // This handles both not adding new undefined properties and not overwriting existing properties with undefined.
+            if (ignoreUndefined && sourceValue === undefined) {
+                continue;
             }
-            if (sourceElement instanceof Date) {
-                // Assign a new Date instance with the same time value
-                Object.assign(output, { [key]: new Date(sourceElement.getTime()) });
-            } else if (isObject(sourceElement)) {
-                if (!(key in target))
-                    Object.assign(output, { [key]: sourceElement });
-                else
-                    (output as any)[key] = mergeDeep((target as any)[key], sourceElement);
+
+            if ((sourceValue as any) instanceof Date) {
+                // If source value is a Date, create a new Date instance.
+                (output as any)[key] = new Date(sourceValue.getTime());
+            } else if (Array.isArray(sourceValue)) {
+                // If source value is an array, create a shallow copy of the array.
+                (output as any)[key] = [...sourceValue];
+            } else if (isObject(sourceValue)) {
+                // If source value is an object:
+                if (isObject(outputValue)) {
+                    // If the corresponding value in output (from target) is also an object, recurse.
+                    // Ensure the ignoreUndefined flag is passed down.
+                    (output as any)[key] = mergeDeep(outputValue, sourceValue, ignoreUndefined);
+                } else {
+                    // If output's value (from target) is not an object (e.g., null, primitive, or key didn't exist in original target),
+                    // overwrite with the source object.
+                    (output as any)[key] = sourceValue;
+                }
             } else {
-                Object.assign(output, { [key]: sourceElement });
+                // If source value is a primitive, null, or undefined (and not ignored).
+                (output as any)[key] = sourceValue;
             }
-        });
+        }
     }
-    return output as T;
+
+    return output as T & U;
 }
 
+
 export function getValueInPath(o: object | undefined, path: string): any {
     if (!o) return undefined;
     if (typeof o === "object") {

package/src/util/resolutions.ts

@@ -3,6 +3,7 @@ import {
     AuthController,
     CMSType,
     CustomizationController,
+    EntityAction,
     EntityCollection,
     EntityCustomView,
     EntityValues,
@@ -438,6 +439,17 @@ export function resolveEntityView(entityView: string | EntityCustomView<any>, co
     }
 }
 
+export function resolveEntityAction<M extends Record<string, any>>(
+    entityAction: string | EntityAction<M>,
+    contextEntityActions?: EntityAction<M>[]
+): EntityAction<M> | undefined {
+    if (typeof entityAction === "string") {
+        return contextEntityActions?.find((entry) => entry.key === entityAction);
+    } else {
+        return entityAction;
+    }
+}
+
 export function resolvedSelectedEntityView<M extends Record<string, any>>(
     customViews: (string | EntityCustomView<M>)[] | undefined,
     customizationController: CustomizationController,
@@ -447,7 +459,7 @@ export function resolvedSelectedEntityView<M extends Record<string, any>>(
     const resolvedEntityViews = customViews ? customViews
             .map(e => resolveEntityView(e, customizationController.entityViews))
             .filter((e): e is EntityCustomView<M> => Boolean(e))
-            // .filter((e) => canEdit || !e.includeActions)
+        // .filter((e) => canEdit || !e.includeActions)
         : [];
 
     const selectedEntityView = resolvedEntityViews.find(e => e.key === selectedTab);

package/dist/components/EntityCollectionTable/internal/popup_field/ElementResizeListener.d.ts

@@ -1,5 +0,0 @@
-interface Props {
-    onResize: (event: Event) => void;
-}
-export declare const ElementResizeListener: React.FC<Props>;
-export {};

package/src/components/EntityCollectionTable/internal/popup_field/ElementResizeListener.tsx

@@ -1,59 +0,0 @@
-import { RefObject, useCallback, useEffect, useRef } from "react";
-
-interface Props {
-    onResize: (event: Event) => void;
-}
-
-export const ElementResizeListener: React.FC<Props> = ({ onResize }) => {
-    const rafRef = useRef(0);
-    const objectRef: RefObject<HTMLObjectElement> = useRef(null);
-    const onResizeRef = useRef(onResize);
-
-    onResizeRef.current = onResize;
-
-    const _onResize = useCallback((e: Event) => {
-        if (rafRef.current) {
-            cancelAnimationFrame(rafRef.current);
-        }
-        rafRef.current = requestAnimationFrame(() => {
-            onResizeRef.current(e);
-        });
-    }, []);
-
-    const onLoad = useCallback(() => {
-        const obj = objectRef.current;
-        if (obj && obj.contentDocument && obj.contentDocument.defaultView) {
-            obj.contentDocument.defaultView.addEventListener("resize", _onResize);
-        }
-    }, [_onResize]);
-
-    useEffect(() => {
-        const obj = objectRef.current;
-        return () => {
-            if (obj && obj.contentDocument && obj.contentDocument.defaultView) {
-                obj.contentDocument.defaultView.removeEventListener("resize", _onResize);
-            }
-        };
-    }, [_onResize]);
-
-    return (
-        <object
-            onLoad={onLoad}
-            ref={objectRef}
-            tabIndex={-1}
-            type={"text/html"}
-            data={"about:blank"}
-            title={""}
-            style={{
-                position: "absolute",
-                top: 0,
-                left: 0,
-                height: "100%",
-                width: "100%",
-                pointerEvents: "none",
-                zIndex: -1,
-                opacity: 0
-            }}
-        />
-    );
-};