@firecms/core 3.0.0-canary.21 → 3.0.0-canary.211

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";
@@ -21,3 +22,4 @@ export * from "./make_properties_editable";
 export * from "./join_collections";
 export * from "./builders";
 export * from "./useTraceUpdate";
+export * from "./storage";

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/make_properties_editable.ts

@@ -4,9 +4,11 @@ import { isPropertyBuilder } from "./entities";
 export function makePropertiesEditable(properties: Properties) {
     Object.keys(properties).forEach((key) => {
         const property = properties[key];
-        property.editable = true;
-        if (property.dataType === "map" && property.properties) {
-            makePropertiesEditable(property.properties as Properties);
+        if (property) {
+            property.editable = true;
+            if (property.dataType === "map" && property.properties) {
+                makePropertiesEditable(property.properties as Properties);
+            }
         }
     });
     return properties;
@@ -15,13 +17,19 @@ export function makePropertiesEditable(properties: Properties) {
 export function makePropertiesNonEditable(properties: PropertiesOrBuilders): PropertiesOrBuilders {
     return Object.entries(properties).reduce((acc, [key, property]) => {
         if (!isPropertyBuilder(property) && property.dataType === "map" && property.properties) {
-            const updated = { ...property, properties: makePropertiesNonEditable(property.properties as PropertiesOrBuilders) };
+            const updated = {
+                ...property,
+                properties: makePropertiesNonEditable(property.properties as PropertiesOrBuilders)
+            };
             acc[key] = updated;
         }
         if (isPropertyBuilder(property)) {
             acc[key] = property;
         } else {
-            acc[key] = { ...property, editable: false };
+            acc[key] = {
+                ...property,
+                editable: false
+            };
         }
         return acc;
     }, {} as PropertiesOrBuilders);

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));
@@ -60,14 +60,14 @@ export function resolveCollectionPathIds(path: string, allCollections: EntityCol
 /**
  * Find the corresponding view at any depth for a given path.
  * Note that path or segments of the paths can be collection aliases.
- * @param pathOrAlias
+ * @param pathOrId
  * @param collections
  */
-export function getCollectionByPathOrId(pathOrAlias: string, collections: EntityCollection[]): EntityCollection | undefined {
+export function getCollectionByPathOrId(pathOrId: string, collections: EntityCollection[]): EntityCollection | undefined {
 
-    const subpaths = removeInitialAndTrailingSlashes(pathOrAlias).split("/");
+    const subpaths = removeInitialAndTrailingSlashes(pathOrId).split("/");
     if (subpaths.length % 2 === 0) {
-        throw Error(`getCollectionByPathOrAlias: Collection paths must have an odd number of segments: ${pathOrAlias}`);
+        throw Error(`getCollectionByPathOrId: Collection paths must have an odd number of segments: ${pathOrId}`);
     }
 
     const subpathCombinations = getCollectionPathsCombinations(subpaths);
@@ -80,10 +80,10 @@ export function getCollectionByPathOrId(pathOrAlias: string, collections: Entity
 
         if (navigationEntry) {
 
-            if (subpathCombination === pathOrAlias) {
+            if (subpathCombination === pathOrId) {
                 result = navigationEntry;
             } else if (navigationEntry.subcollections) {
-                const newPath = pathOrAlias.replace(subpathCombination, "").split("/").slice(2).join("/");
+                const newPath = pathOrId.replace(subpathCombination, "").split("/").slice(2).join("/");
                 if (newPath.length > 0)
                     result = getCollectionByPathOrId(newPath, navigationEntry.subcollections);
             }
@@ -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

@@ -12,38 +12,28 @@ export function isObject(item: any) {
     return item && typeof item === "object" && !Array.isArray(item);
 }
 
-export function mergeDeep<T extends object>(target: T, source: any): T {
+export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(target: T, source: U): T & U {
     const targetIsObject = isObject(target);
-    const output: T = targetIsObject ? { ...target } : target;
+    const output = targetIsObject ? { ...target } : target;
     if (targetIsObject && isObject(source)) {
         Object.keys(source).forEach(key => {
-            if (isObject(source[key])) {
+            const sourceElement = source[key];
+            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]: source[key] });
+                    Object.assign(output, { [key]: sourceElement });
                 else
-                    (output as any)[key] = mergeDeep((target as any)[key], source[key]);
+                    (output as any)[key] = mergeDeep((target as any)[key], sourceElement);
             } else {
-                Object.assign(output, { [key]: source[key] });
+                Object.assign(output, { [key]: sourceElement });
             }
         });
     }
-    return output;
+    return output as T;
 }
 
-// export function getValueInPath(o: object | undefined, path: string): any {
-//     if (!o) return undefined;
-//     if (typeof o === "object") {
-//         if (path in o) {
-//             return (o as any)[path];
-//         }
-//         if (path.includes(".")) {
-//             const pathSegments = path.split(".");
-//             return getValueInPath((o as any)[pathSegments[0]], pathSegments.slice(1).join("."))
-//         }
-//     }
-//     return undefined;
-// }
-
 export function getValueInPath(o: object | undefined, path: string): any {
     if (!o) return undefined;
     if (typeof o === "object") {
@@ -138,6 +128,26 @@ export function removeUndefined(value: any, removeEmptyStrings?: boolean): any {
     return value;
 }
 
+export function removeNulls(value: any): any {
+    if (typeof value === "function") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v: any) => removeNulls(v));
+    }
+    if (typeof value === "object") {
+        const res: object = {};
+        if (value === null)
+            return value;
+        Object.keys(value).forEach((key) => {
+            if (value[key] !== null)
+                (res as any)[key] = removeNulls(value[key]);
+        });
+        return res;
+    }
+    return value;
+}
+
 export function isEmptyObject(obj: object) {
     return obj &&
         Object.getPrototypeOf(obj) === Object.prototype &&
@@ -154,15 +164,25 @@ export function removePropsIfExisting(source: any, comparison: any) {
 
     const res = isArray(source) ? [...source] : { ...source };
 
-    Object.keys(comparison).forEach(key => {
-        if (key in res) {
-            if (isObject(res[key]) && isObject(comparison[key])) {
-                res[key] = removePropsIfExisting(res[key], comparison[key]);
-            } else if (res[key] === comparison[key]) {
-                isArray(res) ? res.splice(key, 1) : delete res[key];
+    if (isArray(res)) {
+        for (let i = res.length - 1; i >= 0; i--) {
+            if (res[i] === comparison[i]) {
+                res.splice(i, 1);
+            } else if (isObject(res[i]) && isObject(comparison[i])) {
+                res[i] = removePropsIfExisting(res[i], comparison[i]);
             }
         }
-    });
+    } else {
+        Object.keys(comparison).forEach(key => {
+            if (key in res) {
+                if (isObject(res[key]) && isObject(comparison[key])) {
+                    res[key] = removePropsIfExisting(res[key], comparison[key]);
+                } else if (res[key] === comparison[key]) {
+                    delete res[key];
+                }
+            }
+        });
+    }
 
     return res;
 }

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/permissions.ts

@@ -8,9 +8,9 @@ const DEFAULT_PERMISSIONS = {
     delete: true
 };
 
-export function resolvePermissions<M extends Record<string, any>, UserType extends User>
+export function resolvePermissions<M extends Record<string, any>, USER extends User>
 (collection: EntityCollection<M>,
- authController: AuthController<UserType>,
+ authController: AuthController<USER>,
  path: string,
  entity: Entity<M> | null): Permissions | undefined {
 
@@ -34,28 +34,29 @@ export function resolvePermissions<M extends Record<string, any>, UserType exten
     throw Error("New type of permission added and not mapped");
 }
 
-export function canEditEntity<M extends Record<string, any>, UserType extends User>
+export function canEditEntity<M extends Record<string, any>, USER extends User>
 (
     collection: EntityCollection<M>,
-    authController: AuthController<UserType>,
+    authController: AuthController<USER>,
     path: string,
     entity: Entity<M> | null): boolean {
     return resolvePermissions(collection, authController, path, entity)?.edit ?? DEFAULT_PERMISSIONS.edit;
 }
 
-export function canCreateEntity<M extends Record<string, any>, UserType extends User>
+export function canCreateEntity<M extends Record<string, any>, USER extends User>
 (
     collection: EntityCollection<M>,
-    authController: AuthController<UserType>,
+    authController: AuthController<USER>,
     path: string,
     entity: Entity<M> | null): boolean {
+    if (collection.collectionGroup) return false;
     return resolvePermissions(collection, authController, path, entity)?.create ?? DEFAULT_PERMISSIONS.create;
 }
 
-export function canDeleteEntity<M extends Record<string, any>, UserType extends User>
+export function canDeleteEntity<M extends Record<string, any>, USER extends User>
 (
     collection: EntityCollection<M>,
-    authController: AuthController<UserType>,
+    authController: AuthController<USER>,
     path: string,
     entity: Entity<M> | null): boolean {
     return resolvePermissions(collection, authController, path, entity)?.delete ?? DEFAULT_PERMISSIONS.delete;

package/src/util/plurals.ts

@@ -1,7 +1,6 @@
 /**
  * Returns the plural of an English word.
  *
- * @export
  * @param {string} word
  * @param {number} [amount]
  * @returns {string}
@@ -92,7 +91,6 @@ export function plural(word: string, amount?: number): string {
 /**
  * Returns the singular of an English word.
  *
- * @export
  * @param {string} word
  * @param {number} [amount]
  * @returns {string}

package/src/util/property_utils.tsx

@@ -1,6 +1,13 @@
 import React from "react";
 
-import { EntityCollection, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedProperty } from "../types";
+import {
+    EntityCollection,
+    PropertiesOrBuilders,
+    PropertyConfig,
+    PropertyOrBuilder,
+    ResolvedProperties,
+    ResolvedProperty
+} from "../types";
 import { isPropertyBuilder } from "./entities";
 import { resolveProperty } from "./resolutions";
 import { CircleIcon, FunctionsIcon } from "@firecms/ui";
@@ -11,7 +18,7 @@ export function isReferenceProperty(propertyOrBuilder: PropertyOrBuilder,
     const resolvedProperty = resolveProperty({
         propertyKey: "ignore", // TODO
         propertyOrBuilder,
-        fields
+        propertyConfigs: fields
     });
     if (!resolvedProperty) return null;
     if (resolvedProperty.dataType === "reference") {
@@ -35,7 +42,7 @@ export function getIconForWidget(widget: PropertyConfig | undefined,
 }
 
 export function getIconForProperty(
-    property: PropertyOrBuilder | ResolvedProperty,
+    property: PropertyOrBuilder<any> | ResolvedProperty<any>,
     size: "small" | "medium" | "large" = "small",
     fields: Record<string, PropertyConfig> = {}
 ): React.ReactNode {
@@ -63,7 +70,7 @@ export function getColorForProperty(property: PropertyOrBuilder, fields: Record<
  * @param properties
  * @param path
  */
-export function getPropertyInPath<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, path: string): PropertyOrBuilder<any, M> | undefined {
+export function getPropertyInPath<M extends Record<string, any>>(properties: PropertiesOrBuilders<M> | ResolvedProperties, path: string): PropertyOrBuilder<any, M> | undefined {
     if (typeof properties === "object") {
         if (path in properties) {
             return properties[path];

package/src/util/references.ts

@@ -9,6 +9,9 @@ export function getEntityPreviewKeys(targetCollection: EntityCollection<any>,
                                      limit = 3) {
     const allProperties = Object.keys(targetCollection.properties);
     let listProperties = previewProperties?.filter(p => allProperties.includes(p as string));
+    if (!listProperties && targetCollection.previewProperties) {
+        listProperties = targetCollection.previewProperties?.filter(p => allProperties.includes(p as string));
+    }
     if (listProperties && listProperties.length > 0) {
         return listProperties;
     } else {
@@ -39,13 +42,19 @@ export function getEntityTitlePropertyKey<M extends Record<string, any>>(collect
 
 export function getEntityImagePreviewPropertyKey<M extends object>(collection: ResolvedEntityCollection<M>): string | undefined {
 
-    // find first text field property
+    // find first storage property of type image
     for (const key in collection.properties) {
         const property = collection.properties[key];
         if (property.dataType === "string" && property.storage?.acceptedFiles?.includes("image/*")) {
             return key;
         }
-
+    }
+    // alternatively, look for the first array of images
+    for (const key in collection.properties) {
+        const property = collection.properties[key];
+        if (property.dataType === "array" && property.of?.dataType === "string" && property.of.storage?.acceptedFiles?.includes("image/*")) {
+            return key;
+        }
     }
     return undefined;
 }