@firecms/core 3.0.0-alpha.46 → 3.0.0-alpha.47

package/src/ui/ExpandablePanel.tsx

@@ -10,8 +10,9 @@ export function ExpandablePanel({
                                     title,
                                     children,
                                     invisible = false,
-                                    initiallyExpanded: initiallyOpen = true,
+                                    expanded,
                                     onExpandedChange,
+                                    initiallyExpanded = true,
                                     titleClassName,
                                     asField,
                                     className
@@ -19,6 +20,7 @@ export function ExpandablePanel({
     title: React.ReactNode,
     invisible?: boolean,
     initiallyExpanded?: boolean;
+    expanded?: boolean;
     onExpandedChange?: (expanded: boolean) => void,
     titleClassName?: string,
     asField?: boolean,
@@ -54,7 +56,7 @@ export function ExpandablePanel({
   }
 }`);
 
-    const [open, setOpen] = useState(initiallyOpen);
+    const [open, setOpen] = useState(expanded !== undefined ? expanded : initiallyExpanded);
     const [allowOverflow, setAllowOverflow] = useState(open);
 
     useEffect(() => {
@@ -67,6 +69,11 @@ export function ExpandablePanel({
         }
     }, [open]);
 
+    useEffect(() => {
+        if (expanded !== undefined)
+            setOpen(expanded);
+    }, [expanded]);
+
     return (<>
             <Collapsible.Root
                 className={cn(

package/src/util/builders.ts

@@ -4,7 +4,8 @@ import {
     BooleanProperty,
     CMSType,
     DateProperty,
-    EntityCallbacks, EntityCollection,
+    EntityCallbacks,
+    EntityCollection,
     EnumValueConfig,
     EnumValues,
     GeopointProperty,

package/src/util/join_collections.ts

@@ -1,43 +1,67 @@
-import { EntityCollection, MapProperty, PropertiesOrBuilders, Property, PropertyOrBuilder } from "../types";
-import { mergeDeep } from "../util/objects";
-import { sortProperties } from "../util/collections";
-import { isPropertyBuilder } from "../util/entities";
+import {
+    EntityCollection,
+    MapProperty,
+    ModifyCollectionProps,
+    PropertiesOrBuilders,
+    Property,
+    PropertyOrBuilder
+} from "../types";
+import { mergeDeep } from "./objects";
+import { sortProperties } from "./collections";
+import { isPropertyBuilder } from "./entities";
 
 /**
  *
- * @param storedCollections
- * @param codedCollections
  */
-export function joinCollectionLists(storedCollections: EntityCollection[], codedCollections: EntityCollection[] | undefined): EntityCollection[] {
+export function joinCollectionLists(targetCollections: EntityCollection[],
+                                    sourceCollections: EntityCollection[] | undefined,
+                                    parentPaths: string[] = [],
+                                    modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | undefined): EntityCollection[] {
 
     // merge collections that are in both lists
-    const updatedCollections = (codedCollections ?? [])
+    const updatedCollections = (sourceCollections ?? [])
         .map((codedCollection) => {
-            const storedCollection = storedCollections?.find((collection) => {
-                return collection.path === codedCollection.path || (collection.alias && codedCollection.alias && collection.alias === codedCollection.alias);
+            const storedCollection = targetCollections?.find((collection) => {
+                return collection.id === codedCollection.id;
+                // return collection.path === codedCollection.path || collection.id && codedCollection.id;
             });
             if (!storedCollection) {
                 return codedCollection;
             } else {
-                return mergeCollection(storedCollection, codedCollection);
+                return mergeCollection(storedCollection, codedCollection, parentPaths, modifyCollection);
             }
         });
 
     // fetched collections that are not in the base collections
-    const resultStoredCollections = storedCollections
-        .filter((col) => !updatedCollections.map(c => c.path).includes(col.path) || !updatedCollections.map(c => c.alias).includes(col.alias));
+    const resultStoredCollections = targetCollections
+        .filter((col) => !updatedCollections.map(c => c.id).includes(col.id))
+        .map((col) => {
+            if (modifyCollection) {
+                const modified = modifyCollection({ collection: col, parentPaths });
+                return modified ?? col;
+            } else {
+                return col;
+            }
+        });
 
     return [...updatedCollections, ...resultStoredCollections];
 }
 
 /**
  *
- * @param target
- * @param source
  */
-export function mergeCollection(target: EntityCollection, source: EntityCollection): EntityCollection {
+export function mergeCollection(target: EntityCollection,
+                                source: EntityCollection,
+                                parentPaths: string[] = [],
+                                modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | undefined
+): EntityCollection {
 
-    const subcollectionsMerged = joinCollectionLists(target?.subcollections ?? [], source?.subcollections ?? []);
+    const subcollectionsMerged = joinCollectionLists(
+        target?.subcollections ?? [],
+        source?.subcollections ?? [],
+        [...parentPaths, target.path],
+        modifyCollection
+    );
 
     const propertiesMerged: PropertiesOrBuilders = { ...target.properties } as PropertiesOrBuilders;
     Object.keys(source.properties).forEach((key) => {
@@ -51,16 +75,22 @@ export function mergeCollection(target: EntityCollection, source: EntityCollecti
     const mergedCollection = mergeDeep(target, source);
     const targetPropertiesOrder = getCollectionKeys(target);
     const sourcePropertiesOrder = getCollectionKeys(source);
-    const mergedPropertiesOrder = [...new Set([...targetPropertiesOrder, ...sourcePropertiesOrder])];
+    const mergedPropertiesOrder = [...new Set([...sourcePropertiesOrder, ...targetPropertiesOrder])];
     const mergedEntityViews = [...new Set([...(target.entityViews ?? []), ...(source.entityViews ?? [])])];
 
-    return {
+    let resultCollection: EntityCollection = {
         ...mergedCollection,
         subcollections: subcollectionsMerged,
         properties: sortProperties(propertiesMerged, mergedPropertiesOrder),
         propertiesOrder: mergedPropertiesOrder,
         entityViews: mergedEntityViews
+    };
+    if (modifyCollection) {
+        const modifiedCollection = modifyCollection({ collection: resultCollection, parentPaths });
+        if (modifiedCollection)
+            resultCollection = modifiedCollection;
     }
+    return resultCollection
 }
 
 function mergePropertyOrBuilder(target: Property, source: PropertyOrBuilder): PropertyOrBuilder {

package/src/util/navigation_from_path.ts

@@ -46,10 +46,10 @@ export function getNavigationEntriesFromPathInternal(props: {
     for (let i = 0; i < subpathCombinations.length; i++) {
         const subpathCombination = subpathCombinations[i];
 
-        const collection: EntityCollection<any> | undefined = collections && collections.find((entry) => entry.alias === subpathCombination || entry.path === subpathCombination);
+        const collection: EntityCollection<any> | undefined = collections && collections.find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
 
         if (collection) {
-            const pathOrAlias = collection.alias ?? collection.path;
+            const pathOrAlias = collection.id ?? collection.path;
             const collectionPath = currentFullPath && currentFullPath.length > 0
                 ? (currentFullPath + "/" + pathOrAlias)
                 : pathOrAlias;

package/src/util/navigation_utils.ts

@@ -54,7 +54,7 @@ export function resolveCollectionPathAliases(path: string, allCollections: Entit
         throw Error(`Collection paths must have an odd number of segments: ${path}`);
     }
 
-    const aliasedCollection = allCollections.find((col) => col.alias === subpaths[0]);
+    const aliasedCollection = allCollections.find((col) => col.id === subpaths[0]);
     let resolvedAliased;
     if (aliasedCollection) {
         resolvedAliased = aliasedCollection.path;
@@ -90,8 +90,8 @@ export function getCollectionByPathOrAlias(pathOrAlias: string, collections: Ent
     for (let i = 0; i < subpathCombinations.length; i++) {
         const subpathCombination = subpathCombinations[i];
         const navigationEntry = collections && collections
-            .sort((a, b) => (a.alias ?? "").localeCompare(b.alias ?? ""))
-            .find((entry) => entry.alias === subpathCombination || entry.path === subpathCombination);
+            .sort((a, b) => (a.id ?? "").localeCompare(b.id ?? ""))
+            .find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
 
         if (navigationEntry) {
 

package/src/util/parent_references_from_path.ts

@@ -20,10 +20,10 @@ export function getParentReferencesFromPath(props: {
     for (let i = 0; i < subpathCombinations.length; i++) {
         const subpathCombination = subpathCombinations[i];
 
-        const collection: EntityCollection<any> | undefined = collections && collections.find((entry) => entry.alias === subpathCombination || entry.path === subpathCombination);
+        const collection: EntityCollection<any> | undefined = collections && collections.find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
 
         if (collection) {
-            const pathOrAlias = collection.alias ?? collection.path;
+            const pathOrAlias = collection.id ?? collection.path;
             const collectionPath = currentFullPath && currentFullPath.length > 0
                 ? (currentFullPath + "/" + pathOrAlias)
                 : pathOrAlias;

package/src/util/property_utils.tsx

@@ -1,12 +1,6 @@
 import React from "react";
 
-import {
-    EntityCollection,
-    PropertiesOrBuilders,
-    PropertyConfig,
-    PropertyOrBuilder,
-    ResolvedProperty
-} from "../types";
+import { EntityCollection, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedProperty } from "../types";
 import { isPropertyBuilder } from "./entities";
 import { resolveProperty } from "./resolutions";
 import { CircleIcon, FunctionsIcon } from "../icons";