@firecms/core 3.0.0-canary.231 → 3.0.0-canary.233

package/dist/types/collections.d.ts

@@ -97,7 +97,7 @@ export interface EntityCollection<M extends Record<string, any> = any, USER exte
      * `hidden` in the property definition, will be ignored.
      * `propertiesOrder` has precedence over `hidden`.
      *     - For properties use the property key.
-     *     - For additional columns use the column id.
+     *     - For additional fields use the field key.
      *     - If you have subcollections, you get a column for each subcollection,
      *       with the path (or alias) as the subcollection, prefixed with
      *       `subcollection:`. e.g. `subcollection:orders`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@firecms/core",
   "type": "module",
-  "version": "3.0.0-canary.231",
+  "version": "3.0.0-canary.233",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/firecmsco"
@@ -50,9 +50,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@firecms/editor": "^3.0.0-canary.231",
-    "@firecms/formex": "^3.0.0-canary.231",
-    "@firecms/ui": "^3.0.0-canary.231",
+    "@firecms/editor": "^3.0.0-canary.233",
+    "@firecms/formex": "^3.0.0-canary.233",
+    "@firecms/ui": "^3.0.0-canary.233",
     "@hello-pangea/dnd": "^17.0.0",
     "@radix-ui/react-portal": "^1.1.3",
     "clsx": "^2.1.1",
@@ -105,7 +105,7 @@
     "dist",
     "src"
   ],
-  "gitHead": "c38a44b87565537d51e654a0565b0921c933c55e",
+  "gitHead": "783647d996fe38fe8f0b162acc482a6008152e30",
   "publishConfig": {
     "access": "public"
   },

package/src/components/ClearFilterSortButton.tsx

@@ -18,7 +18,7 @@ export function ClearFilterSortButton({
     if ((filterIsSet || sortIsSet) && (tableController.clearFilter || tableController.setSortBy)) {
         let label;
         if (filterIsSet && sortIsSet) {
-            label = "Clear filter and sort";
+            label = "Clear filter/sort";
         } else if (filterIsSet) {
             label = "Clear filter";
         } else {

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

@@ -288,7 +288,7 @@ export function PopupFormFieldInternal<M extends Record<string, any>>({
             underlyingValueHasChanged: false,
             context: formContext,
             partOfArray: false,
-            minimalistView: false,
+            minimalistView: true,
             autoFocus: open
         }
         : undefined;

package/src/form/field_bindings/KeyValueFieldBinding.tsx

@@ -69,6 +69,8 @@ export function KeyValueFieldBinding({
         title={property.name}
         className={"text-text-secondary dark:text-text-secondary-dark"}/>;
 
+
+    console.log("minimalistView", propertyKey, minimalistView)
     return (
         <>
 

package/src/preview/property_previews/MapPropertyPreview.tsx

@@ -128,7 +128,7 @@ export function KeyValuePreview({ value }: { value: any }) {
                         </div>
                         <div
                             className="flex-grow max-w-[75%]">
-                            {childValue && <Typography>
+                            {childValue && typeof childValue !== "object" && <Typography>
                                 <ErrorBoundary>
                                     {childValue.toString()}
                                 </ErrorBoundary>

package/src/types/collections.ts

@@ -112,7 +112,7 @@ export interface EntityCollection<M extends Record<string, any> = any, USER exte
      * `hidden` in the property definition, will be ignored.
      * `propertiesOrder` has precedence over `hidden`.
      *     - For properties use the property key.
-     *     - For additional columns use the column id.
+     *     - For additional fields use the field key.
      *     - If you have subcollections, you get a column for each subcollection,
      *       with the path (or alias) as the subcollection, prefixed with
      *       `subcollection:`. e.g. `subcollection:orders`.

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("/");
 }
 
 /**