@firecms/core 3.0.0-canary.22 → 3.0.0-canary.221

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,32 @@ 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, ignoreUndefined: boolean = false): 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];
+            // Skip undefined values when ignoreUndefined is true
+            if (ignoreUndefined && sourceElement === undefined) {
+                return;
+            }
+            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 +132,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 +168,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,17 +1,28 @@
 import React from "react";
 
-import { EntityCollection, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedProperty } from "../types";
+import {
+    AuthController,
+    EntityCollection,
+    PropertiesOrBuilders,
+    PropertyConfig,
+    PropertyOrBuilder,
+    ResolvedProperties,
+    ResolvedProperty
+} from "../types";
 import { isPropertyBuilder } from "./entities";
 import { resolveProperty } from "./resolutions";
 import { CircleIcon, FunctionsIcon } from "@firecms/ui";
 import { getFieldConfig } from "../core";
 
-export function isReferenceProperty(propertyOrBuilder: PropertyOrBuilder,
-                                    fields: Record<string, PropertyConfig>) {
+export function isReferenceProperty(
+    authController: AuthController,
+    propertyOrBuilder: PropertyOrBuilder,
+    fields: Record<string, PropertyConfig>) {
     const resolvedProperty = resolveProperty({
         propertyKey: "ignore", // TODO
         propertyOrBuilder,
-        fields
+        propertyConfigs: fields,
+        authController
     });
     if (!resolvedProperty) return null;
     if (resolvedProperty.dataType === "reference") {
@@ -35,7 +46,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 +74,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

@@ -1,21 +1,26 @@
-import { EntityCollection, PropertyConfig, ResolvedEntityCollection } from "../types";
+import { AuthController, EntityCollection, PropertyConfig, ResolvedEntityCollection } from "../types";
 import { isReferenceProperty } from "./property_utils";
 import { isPropertyBuilder } from "./entities";
 import { getFieldConfig } from "../core";
 
-export function getEntityPreviewKeys(targetCollection: EntityCollection<any>,
-                                     fields: Record<string, PropertyConfig>,
-                                     previewProperties?: string[],
-                                     limit = 3) {
+export function getEntityPreviewKeys(
+    authController: AuthController,
+    targetCollection: EntityCollection<any>,
+    fields: Record<string, PropertyConfig>,
+    previewProperties?: string[],
+    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 {
         listProperties = allProperties;
         return listProperties.filter(key => {
             const propertyOrBuilder = targetCollection.properties[key];
-            return propertyOrBuilder && !isPropertyBuilder(propertyOrBuilder) && !isReferenceProperty(propertyOrBuilder, fields);
+            return propertyOrBuilder && !isPropertyBuilder(propertyOrBuilder) && !isReferenceProperty(authController, propertyOrBuilder, fields);
         }).slice(0, limit);
     }
 }
@@ -39,13 +44,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;
 }