@firecms/core 3.0.1 → 3.1.0-canary.7d91b7c

package/src/util/objects.ts

@@ -12,10 +12,9 @@ export function isObject(item: any) {
     return item && typeof item === "object" && !Array.isArray(item);
 }
 
-
-export function isPlainObject(obj:any) {
+export function isPlainObject(obj: any) {
     // 1. Rule out non-objects, null, and arrays
-    if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
         return false;
     }
 
@@ -26,7 +25,6 @@ export function isPlainObject(obj:any) {
     return proto === Object.prototype;
 }
 
-
 export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(
     target: T,
     source: U,
@@ -75,9 +73,11 @@ export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>
                             newArray[i] = sourceItem;
                         } else if (sourceItem === null) {
                             newArray[i] = targetItem;
-                        } else if (isObject(sourceItem) && isObject(targetItem)) {
+                        } else if (isPlainObject(sourceItem) && isPlainObject(targetItem)) {
+                            // Only recursively merge plain objects, preserve class instances
                             newArray[i] = mergeDeep(targetItem, sourceItem, ignoreUndefined);
                         } else {
+                            // For class instances and primitives, use source directly
                             newArray[i] = sourceItem;
                         }
                     }
@@ -87,17 +87,20 @@ export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>
                     // overwrite with a shallow copy of the source array.
                     (output as any)[key] = [...sourceValue];
                 }
-            } else if (isObject(sourceValue)) {
-                // If source value is an object:
-                if (isObject(outputValue)) {
-                    // If the corresponding value in output (from target) is also an object, recurse.
+            } else if (isPlainObject(sourceValue)) {
+                // If source value is a plain object (not a class instance like EntityReference, GeoPoint, etc.):
+                if (isPlainObject(outputValue)) {
+                    // If the corresponding value in output (from target) is also a plain object, recurse.
                     // Ensure the ignoreUndefined flag is passed down.
                     (output as any)[key] = mergeDeep(outputValue, sourceValue, ignoreUndefined);
                 } else {
-                    // If output's value (from target) is not an object (e.g., null, primitive, or key didn't exist in original target),
+                    // If output's value (from target) is not a plain object (e.g., null, primitive, class instance, or key didn't exist in original target),
                     // overwrite with the source object.
                     (output as any)[key] = sourceValue;
                 }
+            } else if (isObject(sourceValue)) {
+                // If source value is a class instance (not a plain object), use it directly to preserve prototype
+                (output as any)[key] = sourceValue;
             } else {
                 // If source value is a primitive, null, or undefined (and not ignored).
                 (output as any)[key] = sourceValue;
@@ -108,7 +111,6 @@ export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>
     return output as T & U;
 }
 
-
 export function getValueInPath(o: object | undefined, path: string): any {
     if (!o) return undefined;
     if (typeof o === "object") {
@@ -151,6 +153,14 @@ export function removeFunctions(o: object | undefined): any {
     if (o === undefined) return undefined;
     if (o === null) return null;
     if (typeof o === "object") {
+        // Handle arrays first - map over them recursively
+        if (Array.isArray(o)) {
+            return o.map(v => removeFunctions(v));
+        }
+        // Preserve class instances (EntityReference, GeoPoint, etc.) - don't recurse into them
+        if (!isPlainObject(o)) {
+            return o;
+        }
         return Object.entries(o)
             .filter(([_, value]) => typeof value !== "function")
             .map(([key, value]) => {
@@ -186,9 +196,13 @@ export function removeUndefined(value: any, removeEmptyStrings?: boolean): any {
         return value.map((v: any) => removeUndefined(v, removeEmptyStrings));
     }
     if (typeof value === "object") {
-        const res: object = {};
         if (value === null)
             return value;
+        // Preserve class instances (EntityReference, GeoPoint, etc.) - don't recurse into them
+        if (!isPlainObject(value)) {
+            return value;
+        }
+        const res: object = {};
         Object.keys(value).forEach((key) => {
             if (!isEmptyObject(value)) {
                 const childRes = removeUndefined(value[key], removeEmptyStrings);
@@ -211,9 +225,13 @@ export function removeNulls(value: any): any {
         return value.map((v: any) => removeNulls(v));
     }
     if (typeof value === "object") {
-        const res: object = {};
         if (value === null)
             return value;
+        // Preserve class instances (EntityReference, GeoPoint, etc.) - don't recurse into them
+        if (!isPlainObject(value)) {
+            return value;
+        }
+        const res: object = {};
         Object.keys(value).forEach((key) => {
             if (value[key] !== null)
                 (res as any)[key] = removeNulls(value[key]);

package/src/util/{references.ts → previews.ts}

@@ -1,4 +1,4 @@
-import { AuthController, EntityCollection, PropertyConfig, ResolvedEntityCollection } from "../types";
+import { AuthController, EntityCollection, Property, PropertyConfig, ResolvedEntityCollection } from "../types";
 import { isReferenceProperty } from "./property_utils";
 import { isPropertyBuilder } from "./entities";
 import { getFieldConfig } from "../core";
@@ -33,7 +33,7 @@ export function getEntityTitlePropertyKey<M extends Record<string, any>>(collect
     for (const key in collection.properties) {
         const property = collection.properties[key];
         if (!isPropertyBuilder(property)) {
-            const field = getFieldConfig(property, propertyConfigs);
+            const field = getFieldConfig(property as Property, propertyConfigs);
             if (field?.key === "text_field") {
                 return key;
             }
@@ -58,5 +58,19 @@ export function getEntityImagePreviewPropertyKey<M extends object>(collection: R
             return key;
         }
     }
+    // also check for URL properties with image preview type
+    for (const key in collection.properties) {
+        const property = collection.properties[key];
+        if (property.dataType === "string" && property.url === "image") {
+            return key;
+        }
+    }
+    // and arrays of URL properties with image preview type
+    for (const key in collection.properties) {
+        const property = collection.properties[key];
+        if (property.dataType === "array" && property.of?.dataType === "string" && property.of.url === "image") {
+            return key;
+        }
+    }
     return undefined;
 }

package/src/util/property_utils.tsx

@@ -18,7 +18,7 @@ export function isReferenceProperty(
     authController: AuthController,
     propertyOrBuilder: PropertyOrBuilder,
     fields: Record<string, PropertyConfig>) {
-    const resolvedProperty = resolveProperty({
+    const resolvedProperty: ResolvedProperty<any> | null = resolveProperty({
         propertyKey: "ignore", // TODO
         propertyOrBuilder,
         propertyConfigs: fields,
@@ -36,13 +36,13 @@ export function isReferenceProperty(
 }
 
 export function getIdIcon(size: "small" | "medium" | "large"): React.ReactNode {
-    return <CircleIcon size={size}/>;
+    return <CircleIcon size={size} />;
 }
 
 export function getIconForWidget(widget: PropertyConfig | undefined,
-                                 size: "small" | "medium" | "large") {
+    size: "small" | "medium" | "large") {
     const Icon = widget?.Icon ?? CircleIcon;
-    return <Icon size={size}/>;
+    return <Icon size={size} />;
 }
 
 export function getIconForProperty(
@@ -52,7 +52,7 @@ export function getIconForProperty(
 ): React.ReactNode {
 
     if (isPropertyBuilder(property)) {
-        return <FunctionsIcon size={size}/>;
+        return <FunctionsIcon size={size} />;
     } else {
         const widget = getFieldConfig(property, fields);
         return getIconForWidget(widget, size);
@@ -113,25 +113,51 @@ export function getBracketNotation(path: string): string {
 }
 
 /**
- * Get properties exclusively indexed by their order
+ * Get properties sorted by their order, but include ALL properties.
+ * Nested keys (like "data.mode") in propertiesOrder are ignored - they're for column ordering.
  * @param properties
  * @param propertiesOrder
  */
 export function getPropertiesWithPropertiesOrder<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, propertiesOrder?: Extract<keyof M, string>[]): PropertiesOrBuilders<M> {
     if (!propertiesOrder) return properties;
+
+    const propertyKeys = Object.keys(properties);
+
+    // Filter propertiesOrder to only include top-level keys (no dots) that exist
+    const validOrderKeys = (propertiesOrder as string[]).filter(
+        key => !key.includes(".") && properties[key as keyof M]
+    );
+
     const result: PropertiesOrBuilders<any> = {};
-    propertiesOrder.filter(Boolean).forEach(path => {
-        const property = getPropertyInPath(properties, path);
+
+    // First add properties in the specified order
+    validOrderKeys.forEach(key => {
+        const property = properties[key];
         if (typeof property === "object" && property.dataType === "map" && property.properties) {
-            result[path] = {
+            result[key] = {
                 ...property,
                 properties: getPropertiesWithPropertiesOrder(property.properties, property.propertiesOrder ?? [])
             }
+        } else if (property) {
+            result[key] = property;
         }
-        if (property) {
-            result[path] = property;
+    });
+
+    // Then add any missing properties (so they don't disappear!)
+    propertyKeys.forEach(key => {
+        if (!result[key]) {
+            const property = properties[key];
+            if (typeof property === "object" && property.dataType === "map" && property.properties) {
+                result[key] = {
+                    ...property,
+                    properties: getPropertiesWithPropertiesOrder(property.properties, property.propertiesOrder ?? [])
+                }
+            } else if (property) {
+                result[key] = property;
+            }
         }
     });
+
     return result;
 }
 

package/src/util/resolutions.ts

@@ -13,6 +13,7 @@ import {
     Properties,
     PropertiesOrBuilders,
     Property,
+    PropertyBuilder,
     PropertyConfig,
     PropertyOrBuilder,
     ResolvedArrayProperty,
@@ -31,28 +32,28 @@ import { getIn } from "@firecms/formex";
 import { enumToObjectEntries } from "./enums";
 import { isDefaultFieldConfigId } from "../core";
 
-export const resolveCollection = <M extends Record<string, any>, >
-({
-     collection,
-     path,
-     entityId,
-     values,
-     previousValues,
-     userConfigPersistence,
-     propertyConfigs,
-     ignoreMissingFields = false,
-     authController
- }: {
-    collection: EntityCollection<M> | ResolvedEntityCollection<M>;
-    path: string,
-    entityId?: string,
-    values?: Partial<EntityValues<M>>,
-    previousValues?: Partial<EntityValues<M>>,
-    userConfigPersistence?: UserConfigurationPersistence;
-    propertyConfigs?: Record<string, PropertyConfig>;
-    ignoreMissingFields?: boolean;
-    authController: AuthController;
-}): ResolvedEntityCollection<M> => {
+export const resolveCollection = <M extends Record<string, any>,>
+    ({
+        collection,
+        path,
+        entityId,
+        values,
+        previousValues,
+        userConfigPersistence,
+        propertyConfigs,
+        ignoreMissingFields = false,
+        authController
+    }: {
+        collection: EntityCollection<M> | ResolvedEntityCollection<M>;
+        path: string,
+        entityId?: string,
+        values?: Partial<EntityValues<M>>,
+        previousValues?: Partial<EntityValues<M>>,
+        userConfigPersistence?: UserConfigurationPersistence;
+        propertyConfigs?: Record<string, PropertyConfig>;
+        ignoreMissingFields?: boolean;
+        authController: AuthController;
+    }): ResolvedEntityCollection<M> => {
 
     const collectionOverride = userConfigPersistence?.getCollectionConfig<M>(path);
     const storedProperties = getValueInPath(collectionOverride, "properties");
@@ -62,6 +63,7 @@ export const resolveCollection = <M extends Record<string, any>, >
     const usedPreviousValues = previousValues ?? values ?? defaultValues;
 
     const resolvedProperties = Object.entries(collection.properties)
+        .filter(([, propertyOrBuilder]) => propertyOrBuilder != null)
         .map(([key, propertyOrBuilder]) => {
             const childResolvedProperty = resolveProperty({
                 propertyKey: key,
@@ -102,13 +104,13 @@ export const resolveCollection = <M extends Record<string, any>, >
  * @param propertyValue
  */
 export function resolveProperty<T extends CMSType = CMSType, M extends Record<string, any> = any>({
-                                                                                                      propertyOrBuilder,
-                                                                                                      fromBuilder = false,
-                                                                                                      ignoreMissingFields = false,
-                                                                                                      ...props
-                                                                                                  }: {
+    propertyOrBuilder,
+    fromBuilder = false,
+    ignoreMissingFields = false,
+    ...props
+}: {
     propertyKey?: string,
-    propertyOrBuilder: PropertyOrBuilder<T, M> | ResolvedProperty<T>,
+    propertyOrBuilder: PropertyOrBuilder<T, M> | ResolvedProperty<T> | PropertyOrBuilder | Property | ResolvedProperty | undefined,
     values?: Partial<M>,
     previousValues?: Partial<M>,
     path?: string,
@@ -120,7 +122,7 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
     authController: AuthController;
 }): ResolvedProperty<T> | null {
 
-    if (typeof propertyOrBuilder === "object" && "resolved" in propertyOrBuilder) {
+    if (propertyOrBuilder !== null && typeof propertyOrBuilder === "object" && "resolved" in propertyOrBuilder) {
         return propertyOrBuilder as ResolvedProperty<T>;
     }
 
@@ -134,7 +136,7 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
             throw Error("Trying to resolve a property builder without specifying the entity path");
 
         const usedPropertyValue = props.propertyKey ? getIn(props.values, props.propertyKey) : undefined;
-        const result: Property<T> | null = propertyOrBuilder({
+        const result: Property<T> | null = (propertyOrBuilder as PropertyBuilder<T, M>)({
             ...props,
             path,
             propertyValue: usedPropertyValue,
@@ -223,11 +225,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>,
@@ -256,11 +258,11 @@ export function getArrayResolvedProperties<M>({
 }
 
 export function resolveArrayProperty<T extends any[], M>({
-                                                             propertyKey,
-                                                             property,
-                                                             ignoreMissingFields = false,
-                                                             ...props
-                                                         }: {
+    propertyKey,
+    property,
+    ignoreMissingFields = false,
+    ...props
+}: {
     propertyKey?: string,
     property: ArrayProperty<T> | ResolvedArrayProperty<T>,
     values?: Partial<M>,
@@ -272,7 +274,7 @@ export function resolveArrayProperty<T extends any[], M>({
     propertyConfigs?: Record<string, PropertyConfig>;
     ignoreMissingFields?: boolean;
     authController: AuthController;
-}): ResolvedArrayProperty {
+}): ResolvedArrayProperty | null {
     const propertyValue = propertyKey ? getIn(props.values, propertyKey) : undefined;
 
     if (property.of) {
@@ -347,7 +349,8 @@ export function resolveArrayProperty<T extends any[], M>({
             resolvedProperties
         } as ResolvedArrayProperty;
     } else if (!property.Field) {
-        throw Error("The array property needs to declare an 'of' or a 'oneOf' property, or provide a custom `Field`")
+        console.error("The array property needs to declare an 'of' or a 'oneOf' property, or provide a custom `Field`", property);
+        return null;
     } else {
         return {
             ...property,
@@ -364,11 +367,11 @@ export function resolveArrayProperty<T extends any[], M>({
  * @param value
  */
 export function resolveProperties<M extends Record<string, any>>({
-                                                                     propertyKey,
-                                                                     properties,
-                                                                     ignoreMissingFields,
-                                                                     ...props
-                                                                 }: {
+    propertyKey,
+    properties,
+    ignoreMissingFields,
+    ...props
+}: {
     propertyKey?: string,
     properties: PropertiesOrBuilders<M>,
     values?: Partial<M>,
@@ -416,16 +419,17 @@ export function resolvePropertyEnum(property: StringProperty | NumberProperty, f
 }
 
 export function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined {
-    if (typeof input === "object") {
-        return Object.entries(input).map(([id, value]) =>
-            (typeof value === "string"
-                ? {
-                    id,
-                    label: value
-                }
-                : value));
-    } else if (Array.isArray(input)) {
+    // Check Array.isArray first since typeof [] === "object" is true in JavaScript
+    if (Array.isArray(input)) {
         return input as EnumValueConfig[];
+    } else if (typeof input === "object" && input !== null) {
+        return Object.entries(input).map(([id, value]) =>
+        (typeof value === "string"
+            ? {
+                id,
+                label: value
+            }
+            : value));
     } else {
         return undefined;
     }
@@ -457,8 +461,8 @@ export function resolvedSelectedEntityView<M extends Record<string, any>>(
     canEdit?: boolean,
 ) {
     const resolvedEntityViews = customViews ? customViews
-            .map(e => resolveEntityView(e, customizationController.entityViews))
-            .filter((e): e is EntityCustomView<M> => Boolean(e))
+        .map(e => resolveEntityView(e, customizationController.entityViews))
+        .filter((e): e is EntityCustomView<M> => Boolean(e))
         // .filter((e) => canEdit || !e.includeActions)
         : [];