@firecms/core 3.0.0-beta.11 → 3.0.0-beta.12

package/src/types/side_entity_controller.tsx

@@ -2,6 +2,7 @@ import { EntityCollection } from "./collections";
 import { ResolvedEntityCollection } from "./resolved_entities";
 import { Entity } from "./entities";
 import { EntityOverrides } from "./entity_overrides";
+import { EntityFormProps } from "../form";
 
 /**
  * Props used to open a side dialog
@@ -28,7 +29,7 @@ export interface EntitySidePanelProps<M extends Record<string, any> = any> {
      * Open the entity with a selected sub-collection view. If the panel for this
      * entity was already open, it is replaced.
      */
-    selectedSubPath?: string;
+    selectedTab?: string;
 
     /**
      * Use this prop to override the width of the form view.
@@ -66,6 +67,10 @@ export interface EntitySidePanelProps<M extends Record<string, any> = any> {
      */
     closeOnSave?: boolean;
 
+    /**
+     * Override some form properties
+     */
+    formProps?: Partial<EntityFormProps<M>>;
 }
 
 /**

package/src/util/builders.ts

@@ -26,8 +26,10 @@ import {
  * @param collection
  * @group Builder
  */
-export function buildCollection<M extends Record<string, any> = any,
-    USER extends User = User>(
+export function buildCollection<
+    M extends Record<string, any> = any,
+    USER extends User = User>
+(
     collection: EntityCollection<M, USER>
 ): EntityCollection<M, USER> {
     return collection;
@@ -39,7 +41,7 @@ export function buildCollection<M extends Record<string, any> = any,
  * @param property
  * @group Builder
  */
-export function buildProperty<T extends CMSType = CMSType, P extends PropertyOrBuilder<T> = PropertyOrBuilder<T>, M extends Record<string, any> = Record<string, any>>(
+export function buildProperty<T extends CMSType = CMSType, P extends PropertyOrBuilder<T> = PropertyOrBuilder<T>, M extends Record<string, any> = any>(
     property: P
 ):
     P extends StringProperty ? StringProperty :

package/src/util/entity_actions.ts

@@ -0,0 +1,28 @@
+import { EntityAction } from "../types";
+
+const reservedKeys = ["edit", "copy", "delete"];
+
+export function mergeEntityActions(currentActions: EntityAction[], newActions: EntityAction[]): EntityAction[] {
+    // given the current actions, replace the ones with the same key
+    // and append the new ones
+    const updatedActions: EntityAction[] = [];
+    currentActions.forEach(action => {
+        const newAction = newActions.find(a => a.key === action.key);
+        if (newAction) {
+            const mergedAction = {
+                ...action,
+                ...newAction
+            }
+            updatedActions.push(mergedAction);
+        } else {
+            updatedActions.push(action);
+        }
+    });
+    newActions.forEach(action => {
+        if (!currentActions.find(a => a.key === action.key) && (!action.key || !reservedKeys.includes(action.key))) {
+            updatedActions.push(action);
+        }
+    });
+    return updatedActions;
+
+}

package/src/util/entity_cache.ts

@@ -0,0 +1,204 @@
+import { EntityReference, GeoPoint, Vector } from "../types";
+
+// Define a unique prefix for entity keys in localStorage to avoid key collisions
+const LOCAL_STORAGE_PREFIX = "entity_cache::";
+
+// In-memory cache to store entities for quick access
+const entityCache: Map<string, object> = new Map();
+
+// Check `localStorage` availability once during initialization
+const isLocalStorageAvailable = typeof localStorage !== "undefined";
+
+// Define custom replacer for JSON.stringify
+function customReplacer(key: string): any {
+
+    // @ts-ignore
+    const value = this[key];
+
+    // Handle Date objects
+    // @ts-ignore
+    if (value instanceof Date) {
+        return { __type: "Date", value: value.toISOString() };
+    }
+
+    // Handle EntityReference
+    // @ts-ignore
+    if (value instanceof EntityReference) {
+        return { __type: "EntityReference", id: value.id, path: value.path };
+    }
+
+    // Handle GeoPoint
+    // @ts-ignore
+    if (value instanceof GeoPoint) {
+        return { __type: "GeoPoint", latitude: value.latitude, longitude: value.longitude };
+    }
+
+    // Handle Vector
+    // @ts-ignore
+    if (value instanceof Vector) {
+        return { __type: "Vector", value: value.value };
+    }
+
+    return value;
+}
+
+// Define custom reviver for JSON.parse
+function customReviver(key: string, value: any): any {
+    if (value && typeof value === "object" && "__type" in value) {
+        switch (value.__type) {
+            case "Date":
+                return new Date(value.value);
+            case "EntityReference":
+                return new EntityReference(value.id, value.path);
+            case "GeoPoint":
+                return new GeoPoint(value.latitude, value.longitude);
+            case "Vector":
+                return new Vector(value.value);
+            default:
+                return value;
+        }
+    }
+    return value;
+}
+
+// Initialize the in-memory cache by loading entities from `localStorage`
+if (isLocalStorageAvailable) {
+    try {
+        // Iterate over all keys in localStorage to find those with the specified prefix
+        for (let i = 0; i < localStorage.length; i++) {
+            const fullKey = localStorage.key(i);
+            if (fullKey && fullKey.startsWith(LOCAL_STORAGE_PREFIX)) {
+                const path = fullKey.substring(LOCAL_STORAGE_PREFIX.length);
+                const entityString = localStorage.getItem(fullKey);
+                if (entityString) {
+                    try {
+                        const entity: object = JSON.parse(entityString, customReviver);
+                        entityCache.set(path, entity);
+                    } catch (parseError) {
+                        console.error(
+                            `Failed to parse entity for path "${path}" from localStorage:`,
+                            parseError
+                        );
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        console.error("Error accessing localStorage during initialization:", error);
+    }
+}
+
+/**
+ * Saves data to the in-memory cache and persists it individually in `localStorage`.
+ * @param path - The unique path/key for the data.
+ * @param data - The data to cache and persist.
+ */
+export function saveEntityToCache(path: string, data: object): void {
+    // Update the in-memory cache
+    entityCache.set(path, data);
+
+    // Persist the data individually in localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const key = LOCAL_STORAGE_PREFIX + path;
+            const entityString = JSON.stringify(data, customReplacer);
+            localStorage.setItem(key, entityString);
+        } catch (error) {
+            console.error(
+                `Failed to save entity for path "${path}" to localStorage:`,
+                error
+            );
+        }
+    }
+}
+
+/**
+ * Retrieves an entity from the in-memory cache or `localStorage`.
+ * If the entity is not in the cache but exists in `localStorage`, it loads it into the cache.
+ * @param path - The unique path/key for the entity.
+ * @returns The cached entity or `undefined` if not found.
+ */
+export function getEntityFromCache(path: string): object | undefined {
+
+    // Attempt to retrieve the entity from the in-memory cache
+    if (entityCache.has(path)) {
+        return entityCache.get(path);
+    }
+
+    // If not in the cache, attempt to load it from localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const key = LOCAL_STORAGE_PREFIX + path;
+            const entityString = localStorage.getItem(key);
+            if (entityString) {
+                const entity: object = JSON.parse(entityString, customReviver);
+                entityCache.set(path, entity); // Update the cache
+                return entity;
+            }
+        } catch (error) {
+            console.error(
+                `Failed to load entity for path "${path}" from localStorage:`,
+                error
+            );
+        }
+    }
+
+    // Entity not found
+    return undefined;
+}
+
+export function hasEntityInCache(path: string): boolean {
+    return entityCache.has(path);
+}
+
+/**
+ * Removes an entity from both the in-memory cache and `localStorage`.
+ * @param path - The unique path/key for the entity to remove.
+ */
+export function removeEntityFromCache(path: string): void {
+
+
+    console.debug("Removing entity from cache", path);
+
+    // Remove from the in-memory cache
+    entityCache.delete(path);
+
+    // Remove from localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const key = LOCAL_STORAGE_PREFIX + path;
+            localStorage.removeItem(key);
+        } catch (error) {
+            console.error(
+                `Failed to remove entity for path "${path}" from localStorage:`,
+                error
+            );
+        }
+    }
+}
+
+/**
+ * Clears the entire in-memory cache and removes all related entities from `localStorage`.
+ */
+export function clearEntityCache(): void {
+    // Clear the in-memory cache
+    entityCache.clear();
+
+    // Remove all entities with the specified prefix from localStorage
+    if (isLocalStorageAvailable) {
+        try {
+            const keysToRemove: string[] = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const fullKey = localStorage.key(i);
+                if (fullKey && fullKey.startsWith(LOCAL_STORAGE_PREFIX)) {
+                    keysToRemove.push(fullKey);
+                }
+            }
+
+            // Remove the keys after collecting them to avoid issues while iterating
+            keysToRemove.forEach((key) => localStorage.removeItem(key));
+        } catch (error) {
+            console.error("Failed to clear entity cache from localStorage:", error);
+        }
+    }
+}

package/src/util/index.ts

@@ -7,6 +7,7 @@ export * from "./objects";
 export * from "./paths";
 export * from "./regexp";
 export * from "./navigation_utils";
+export * from "./entity_actions";
 export * from "./useDebouncedCallback";
 export * from "./property_utils";
 export * from "./resolutions";

package/src/util/join_collections.ts

@@ -115,6 +115,9 @@ export function mergeCollection(target: EntityCollection,
         if (modifiedCollection)
             resultCollection = modifiedCollection;
     }
+
+    // @ts-ignore
+    resultCollection["merged"] = true;
     return resultCollection
 }
 

package/src/util/navigation_from_path.ts

@@ -11,22 +11,27 @@ export interface NavigationViewEntityInternal<M extends Record<string, any>> {
     type: "entity";
     entityId: string;
     path: string;
+    fullPath: string;
     parentCollection: EntityCollection<M>;
 }
 
 export interface NavigationViewCollectionInternal<M extends Record<string, any>> {
     type: "collection";
+    id: string;
     path: string;
+    fullPath: string;
     collection: EntityCollection<M>;
 }
 
 export interface NavigationViewEntityCustomInternal<M extends Record<string, any>> {
     type: "custom_view";
     path: string;
+    fullPath: string;
+    entityId: string;
     view: EntityCustomView<M>;
 }
 
-export function getNavigationEntriesFromPathInternal(props: {
+export function getNavigationEntriesFromPath(props: {
     path: string,
     collections: EntityCollection[] | undefined,
     currentFullPath?: string,
@@ -56,7 +61,9 @@ export function getNavigationEntriesFromPathInternal(props: {
 
             result.push({
                 type: "collection",
+                id: collection.id,
                 path: collectionPath,
+                fullPath: collectionPath,
                 collection
             });
             const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
@@ -68,6 +75,7 @@ export function getNavigationEntriesFromPathInternal(props: {
                     type: "entity",
                     entityId,
                     path: collectionPath,
+                    fullPath: fullPath,
                     parentCollection: collection
                 });
                 if (nextSegments.length > 1) {
@@ -81,16 +89,15 @@ export function getNavigationEntriesFromPathInternal(props: {
                         .filter(Boolean)
                         .find((entry) => entry!.key === newPath);
                     if (customView) {
-                        const path = currentFullPath && currentFullPath.length > 0
-                            ? (currentFullPath + "/" + customView.key)
-                            : customView.key;
                         result.push({
                             type: "custom_view",
-                            path,
+                            path: collectionPath,
+                            entityId: entityId,
+                            fullPath: fullPath + "/" + customView.key,
                             view: customView
                         });
                     } else if (collection.subcollections) {
-                        result.push(...getNavigationEntriesFromPathInternal({
+                        result.push(...getNavigationEntriesFromPath({
                             path: newPath,
                             collections: collection.subcollections,
                             currentFullPath: fullPath,

package/src/util/navigation_utils.ts

@@ -1,4 +1,4 @@
-import { EntityCollection } from "../types";
+import { EntityCollection, NavigationController, SideEntityController } from "../types";
 
 export function removeInitialAndTrailingSlashes(s: string): string {
     return removeInitialSlash(removeTrailingSlash(s));
@@ -109,3 +109,55 @@ export function getCollectionPathsCombinations(subpaths: string[]): string[] {
     return result;
 
 }
+
+export function navigateToEntity({
+                                     openEntityMode,
+                                     collection,
+                                     entityId,
+                                     copy,
+                                     path,
+                                     selectedTab,
+                                     sideEntityController,
+                                     onClose,
+                                     navigation
+                                 }:
+
+                                 {
+                                     openEntityMode: "side_panel" | "full_screen";
+                                     collection?: EntityCollection;
+                                     entityId?: string;
+                                     selectedTab?: string;
+                                     copy?: boolean;
+                                     path: string;
+                                     sideEntityController: SideEntityController;
+                                     onClose?: () => void;
+                                     navigation: NavigationController
+                                 }) {
+
+    if (openEntityMode === "side_panel") {
+
+        sideEntityController.open({
+            entityId,
+            path,
+            copy,
+            selectedTab,
+            collection,
+            updateUrl: true,
+            onClose
+        });
+
+    } else {
+        let to = navigation.buildUrlCollectionPath(entityId ? `${path}/${entityId}` : path);
+        if (entityId && selectedTab) {
+            to += `/${selectedTab}`;
+        }
+        if (!entityId) {
+            to += "#new";
+        }
+        if (copy) {
+            to += "#copy";
+        }
+        navigation.navigate(to);
+    }
+
+}

package/src/util/objects.ts

@@ -18,7 +18,10 @@ export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>
     if (targetIsObject && isObject(source)) {
         Object.keys(source).forEach(key => {
             const sourceElement = source[key];
-            if (isObject(sourceElement)) {
+            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

package/src/util/parent_references_from_path.ts

@@ -22,11 +22,11 @@ export function getParentReferencesFromPath(props: {
 
         const collection: EntityCollection<any> | undefined = collections && collections.find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
 
+        // If we find a collection, we add the reference and continue
         if (collection) {
-            const pathOrAlias = collection.id ?? collection.path;
             const collectionPath = currentFullPath && currentFullPath.length > 0
-                ? (currentFullPath + "/" + pathOrAlias)
-                : pathOrAlias;
+                ? (currentFullPath + "/" + collection.path)
+                : collection.path;
 
             const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
             const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];

package/src/util/resolutions.ts

@@ -1,6 +1,7 @@
 import {
     ArrayProperty,
     CMSType,
+    CustomizationController,
     EntityCollection,
     EntityCustomView,
     EntityValues,
@@ -218,11 +219,11 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
 }
 
 export function getArrayResolvedProperties<M>({
-                                           propertyKey,
-                                           propertyValue,
-                                           property,
-                                           ...props
-                                       }: {
+                                                  propertyKey,
+                                                  propertyValue,
+                                                  property,
+                                                  ...props
+                                              }: {
     propertyValue: any,
     propertyKey?: string,
     property: ArrayProperty<any> | ResolvedArrayProperty<any>,
@@ -430,3 +431,23 @@ export function resolveEntityView(entityView: string | EntityCustomView<any>, co
         return entityView;
     }
 }
+
+export function resolvedSelectedEntityView<M extends Record<string, any>>(
+    customViews: (string | EntityCustomView<M>)[] | undefined,
+    customizationController: CustomizationController,
+    selectedTab?: string
+) {
+    const resolvedEntityViews = customViews ? customViews
+            .map(e => resolveEntityView(e, customizationController.entityViews))
+            .filter(Boolean) as EntityCustomView[]
+        : [];
+
+    const selectedEntityView = resolvedEntityViews.find(e => e.key === selectedTab);
+    const selectedSecondaryForm = customViews
+        && resolvedEntityViews.filter(e => e.includeActions).find(e => e.key === selectedTab);
+    return {
+        resolvedEntityViews,
+        selectedEntityView,
+        selectedSecondaryForm
+    };
+}

package/src/util/useStorageUploadController.tsx

@@ -34,6 +34,7 @@ export interface StorageFieldItem {
     size: PreviewSize
 }
 
+
 export function useStorageUploadController<M extends object>({
                                                                  entityId,
                                                                  entityValues,
@@ -45,17 +46,17 @@ export function useStorageUploadController<M extends object>({
                                                                  disabled,
                                                                  onChange
                                                              }:
-                                                                 {
-                                                                     entityId: string,
-                                                                     entityValues: EntityValues<M>,
-                                                                     value: string | string[] | null;
-                                                                     path?: string,
-                                                                     propertyKey: string,
-                                                                     property: StringProperty | ArrayProperty<string[]> | ResolvedStringProperty | ResolvedArrayProperty<string[]>,
-                                                                     storageSource: StorageSource,
-                                                                     disabled: boolean,
-                                                                     onChange: (value: string | string[] | null) => void
-                                                                 }) {
+                                                             {
+                                                                 entityId: string,
+                                                                 entityValues: EntityValues<M>,
+                                                                 value: string | string[] | null;
+                                                                 path?: string,
+                                                                 propertyKey: string,
+                                                                 property: StringProperty | ArrayProperty<string[]> | ResolvedStringProperty | ResolvedArrayProperty<string[]>,
+                                                                 storageSource: StorageSource,
+                                                                 disabled: boolean,
+                                                                 onChange: (value: string | string[] | null) => void
+                                                             }) {
 
     const storage: StorageConfig | undefined = property.dataType === "string"
         ? property.storage
@@ -75,16 +76,7 @@ export function useStorageUploadController<M extends object>({
     const compression: ImageCompression | undefined = storage?.imageCompression;
 
     const internalInitialValue: StorageFieldItem[] =
-        (multipleFilesSupported
-            ? (value ?? []) as string[]
-            : value ? [value as string] : []).map(entry => (
-            {
-                id: getRandomId(),
-                storagePathOrDownloadUrl: entry,
-                metadata,
-                size
-            }
-        ));
+        getInternalInitialValue(multipleFilesSupported, value, metadata, size);
 
     const [initialValue, setInitialValue] = useState<string | string[] | null>(value);
     const [internalValue, setInternalValue] = useState<StorageFieldItem[]>(internalInitialValue);
@@ -226,6 +218,32 @@ export function useStorageUploadController<M extends object>({
     }
 }
 
+function getInternalInitialValue(multipleFilesSupported: boolean,
+                                 value: string | string[] | null,
+                                 metadata: Record<string, any> | undefined,
+                                 size: PreviewSize): StorageFieldItem[] {
+    let strings: string[] = [];
+    if (multipleFilesSupported) {
+        if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+            strings = (value ?? []) as string[];
+        }
+    } else {
+        if (typeof value === "string") {
+            strings = value ? [value as string] : [];
+        }
+    }
+
+    return strings
+        .map(entry => (
+            {
+                id: getRandomId(),
+                storagePathOrDownloadUrl: entry,
+                metadata,
+                size
+            }
+        ));
+}
+
 function removeDuplicates(items: StorageFieldItem[]) {
     return items.filter(
         (item, i) => {