@firecms/core 3.0.0-alpha.8 → 3.0.0-alpha.80

package/src/util/resolutions.ts

@@ -0,0 +1,399 @@
+import {
+    ArrayProperty,
+    CMSType,
+    EntityCollection,
+    EntityCustomView,
+    EntityValues,
+    EnumValueConfig,
+    EnumValues,
+    NumberProperty,
+    Properties,
+    PropertiesOrBuilders,
+    Property,
+    PropertyConfig,
+    PropertyOrBuilder,
+    ResolvedArrayProperty,
+    ResolvedEntityCollection,
+    ResolvedNumberProperty,
+    ResolvedProperties,
+    ResolvedProperty,
+    ResolvedStringProperty,
+    StringProperty,
+    UserConfigurationPersistence
+} from "../types";
+import { getValueInPath, mergeDeep } from "./objects";
+import { getDefaultValuesFor, isPropertyBuilder } from "./entities";
+import { DEFAULT_ONE_OF_TYPE } from "./common";
+import { getIn } from "formik";
+import { enumToObjectEntries } from "./enums";
+import { isDefaultFieldConfigId } from "../core";
+
+// import util from "util";
+
+export const resolveCollection = <M extends Record<string, any>, >
+({
+     collection,
+     path,
+     entityId,
+     values,
+     previousValues,
+     userConfigPersistence,
+     fields
+ }: {
+    collection: EntityCollection<M> | ResolvedEntityCollection<M>;
+    path: string,
+    entityId?: string,
+    values?: Partial<EntityValues<M>>,
+    previousValues?: Partial<EntityValues<M>>,
+    userConfigPersistence?: UserConfigurationPersistence;
+    fields?: Record<string, PropertyConfig>;
+}): ResolvedEntityCollection<M> => {
+
+    const collectionOverride = userConfigPersistence?.getCollectionConfig<M>(path);
+    const storedProperties = getValueInPath(collectionOverride, "properties");
+
+    const defaultValues = getDefaultValuesFor(collection.properties);
+    const usedValues = values ?? defaultValues;
+    const usedPreviousValues = previousValues ?? values ?? defaultValues;
+
+    const resolvedProperties = Object.entries(collection.properties)
+        .map(([key, propertyOrBuilder]) => {
+            const propertyValue = usedValues ? getIn(usedValues, key) : undefined;
+            const childResolvedProperty = resolveProperty({
+                propertyKey: key,
+                propertyOrBuilder: propertyOrBuilder as PropertyOrBuilder | ResolvedProperty,
+                values: usedValues,
+                previousValues: usedPreviousValues,
+                path,
+                propertyValue,
+                entityId,
+                fields
+            });
+            if (!childResolvedProperty) return {};
+            return ({
+                [key]: childResolvedProperty
+            });
+        })
+        .filter((a) => a !== null)
+        .reduce((a, b) => ({ ...a, ...b }), {}) as ResolvedProperties<M>;
+
+    const properties: Properties = mergeDeep(resolvedProperties, storedProperties);
+    const cleanedProperties = Object.entries(properties)
+        .filter(([_, property]) => Boolean(property?.dataType))
+        .map(([id, property]) => ({ [id]: property }))
+        .reduce((a, b) => ({ ...a, ...b }), {});
+
+    return {
+        ...collection,
+        properties: cleanedProperties,
+        originalCollection: collection
+    } as ResolvedEntityCollection<M>;
+
+};
+
+/**
+ * Resolve property builders, enums and arrays.
+ * @param propertyOrBuilder
+ * @param propertyValue
+ * @param values
+ */
+export function resolveProperty<T extends CMSType = CMSType, M extends Record<string, any> = any>({
+                                                                                                      propertyOrBuilder,
+                                                                                                      propertyValue,
+                                                                                                      fromBuilder = false,
+                                                                                                      ...props
+                                                                                                  }: {
+    propertyKey?: string,
+    propertyOrBuilder: PropertyOrBuilder<T, M> | ResolvedProperty<T>,
+    propertyValue?: unknown,
+    values?: Partial<M>,
+    previousValues?: Partial<M>,
+    path?: string,
+    entityId?: string,
+    index?: number,
+    fromBuilder?: boolean;
+    fields?: Record<string, PropertyConfig<any>>;
+}): ResolvedProperty<T> | null {
+
+    if (typeof propertyOrBuilder === "object" && "resolved" in propertyOrBuilder) {
+        return propertyOrBuilder as ResolvedProperty<T>;
+    }
+
+    let resolvedProperty: ResolvedProperty<T> | null = null;
+
+    if (!propertyOrBuilder) {
+        return null;
+    } else if (isPropertyBuilder(propertyOrBuilder)) {
+        const path = props.path;
+        if (!path)
+            throw Error("Trying to resolve a property builder without specifying the entity path");
+
+        const result: Property<T> | null = propertyOrBuilder({
+            ...props,
+            path,
+            propertyValue,
+            values: props.values ?? {},
+            previousValues: props.previousValues ?? props.values ?? {}
+        });
+
+        if (!result) {
+            return null;
+        }
+
+        resolvedProperty = resolveProperty({
+            ...props,
+            propertyValue,
+            propertyOrBuilder: result,
+            fromBuilder: true
+        });
+    } else {
+        const property = propertyOrBuilder as Property<T>;
+        if (property.dataType === "map" && property.properties) {
+            const properties = resolveProperties({
+                ...props,
+                properties: property.properties,
+                propertyValue
+            });
+            resolvedProperty = {
+                ...property,
+                resolved: true,
+                fromBuilder,
+                properties
+            } as ResolvedProperty<T>;
+        } else if (property.dataType === "array") {
+            resolvedProperty = resolveArrayProperty({
+                property,
+                propertyValue,
+                fromBuilder,
+                ...props
+            }) as ResolvedProperty<any>;
+        } else if ((property.dataType === "string" || property.dataType === "number") && property.enumValues) {
+            resolvedProperty = resolvePropertyEnum(property, fromBuilder) as ResolvedProperty<any>;
+        }
+    }
+
+    if (!resolvedProperty) {
+        resolvedProperty = {
+            ...propertyOrBuilder,
+            resolved: true,
+            fromBuilder
+        } as ResolvedProperty<T>;
+    }
+
+    if (resolvedProperty.propertyConfig && !isDefaultFieldConfigId(resolvedProperty.propertyConfig)) {
+        const cmsFields = props.fields;
+        if (!cmsFields) {
+            throw Error(`Trying to resolve a property with key ${resolvedProperty.propertyConfig} that inherits from a custom property config but no custom property configs were provided. Use the property \`propertyConfigs\` in your app config to provide them`);
+        }
+        const customField: PropertyConfig<any> = cmsFields[resolvedProperty.propertyConfig];
+        if (!customField) {
+            console.warn(`Trying to resolve a property with key ${resolvedProperty.propertyConfig} that inherits from a custom property config but no custom property config with that key was found. Check the \`propertyConfigs\` in your app config`)
+            console.warn("Available property configs", cmsFields);
+            return null;
+        }
+        if (customField.property) {
+            const configPropertyOrBuilder = customField.property;
+            if ("propertyConfig" in configPropertyOrBuilder) {
+                delete configPropertyOrBuilder.propertyConfig;
+            }
+            const customFieldProperty = resolveProperty<any>({
+                propertyOrBuilder: configPropertyOrBuilder,
+                propertyValue,
+                ...props
+            });
+            if (customFieldProperty) {
+                resolvedProperty = mergeDeep(customFieldProperty, resolvedProperty);
+            }
+        }
+
+    }
+
+    return resolvedProperty
+        ? {
+            ...resolvedProperty,
+            resolved: true
+        }
+        : null;
+}
+
+export function resolveArrayProperty<T extends any[], M>({
+                                                             propertyKey,
+                                                             property,
+                                                             propertyValue,
+                                                             ...props
+                                                         }: {
+    propertyKey?: string,
+    property: ArrayProperty<T> | ResolvedArrayProperty<T>,
+    propertyValue: any,
+    values?: Partial<M>,
+    previousValues?: Partial<M>,
+    path?: string,
+    entityId?: string,
+    index?: number,
+    fromBuilder?: boolean;
+    fields?: Record<string, PropertyConfig>;
+}): ResolvedArrayProperty {
+
+    if (property.of) {
+        if (Array.isArray(property.of)) {
+            return {
+                ...property,
+                resolved: true,
+                fromBuilder: props.fromBuilder,
+                resolvedProperties: property.of.map((p, index) => {
+                    return resolveProperty({
+                        propertyKey: `${propertyKey}.${index}`,
+                        propertyOrBuilder: p as Property<any>,
+                        propertyValue: Array.isArray(propertyValue) ? propertyValue[index] : undefined,
+                        ...props,
+                        index
+                    });
+                })
+            } as ResolvedArrayProperty;
+        } else {
+            const of = property.of;
+            const resolvedProperties: ResolvedProperty[] = Array.isArray(propertyValue)
+                ? propertyValue.map((v: any, index: number) => resolveProperty({
+                    propertyKey: `${propertyKey}.${index}`,
+                    propertyOrBuilder: of,
+                    propertyValue: v,
+                    ...props,
+                    index
+                })).filter(e => Boolean(e)) as ResolvedProperty[]
+                : [];
+            const ofProperty = resolveProperty({
+                propertyKey: `${propertyKey}`,
+                propertyOrBuilder: of,
+                propertyValue: undefined,
+                ...props
+            });
+            if (!ofProperty)
+                throw Error("When using a property builder as the 'of' prop of an ArrayProperty, you must return a valid child property")
+            return {
+                ...property,
+                resolved: true,
+                fromBuilder: props.fromBuilder,
+                of: ofProperty,
+                resolvedProperties
+            } as ResolvedArrayProperty;
+        }
+    } else if (property.oneOf) {
+        const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+        const resolvedProperties: ResolvedProperty[] = Array.isArray(propertyValue)
+            ? propertyValue.map((v, index) => {
+                const type = v && v[typeField];
+                const childProperty = property.oneOf?.properties[type];
+                if (!type || !childProperty) return null;
+                return resolveProperty({
+                    propertyKey: `${propertyKey}.${index}`,
+                    propertyOrBuilder: childProperty,
+                    propertyValue,
+                    ...props
+                });
+            }).filter(e => Boolean(e)) as ResolvedProperty[]
+            : [];
+        const properties = resolveProperties<any>({
+            properties: property.oneOf.properties,
+            propertyValue: undefined,
+            ...props
+        });
+        return {
+            ...property,
+            resolved: true,
+            oneOf: {
+                ...property.oneOf,
+                properties
+            },
+            fromBuilder: props.fromBuilder,
+            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`")
+    } else {
+        return {
+            ...property,
+            resolved: true,
+            fromBuilder: props.fromBuilder
+        } as ResolvedArrayProperty;
+    }
+
+}
+
+/**
+ * Resolve enums and arrays for properties
+ * @param properties
+ * @param value
+ */
+export function resolveProperties<M extends Record<string, any>>({
+                                                                     properties,
+                                                                     propertyValue,
+                                                                     ...props
+                                                                 }: {
+    properties: PropertiesOrBuilders<M>,
+    propertyValue: unknown,
+    values?: Partial<M>,
+    previousValues?: Partial<M>,
+    path?: string,
+    entityId?: string,
+    index?: number,
+    fromBuilder?: boolean;
+    fields?: Record<string, PropertyConfig>;
+}): ResolvedProperties<M> {
+    return Object.entries<PropertyOrBuilder>(properties as Record<string, PropertyOrBuilder>)
+        .map(([key, property]) => {
+            const thisPropertyValue = propertyValue && typeof propertyValue === "object" ? getValueInPath(propertyValue, key) : undefined;
+            const childResolvedProperty = resolveProperty({
+                propertyKey: key,
+                propertyOrBuilder: property,
+                propertyValue: thisPropertyValue,
+                ...props
+            });
+            if (!childResolvedProperty) return {};
+            return {
+                [key]: childResolvedProperty
+            };
+        })
+        .filter((a) => a !== null)
+        .reduce((a, b) => ({ ...a, ...b }), {}) as ResolvedProperties<M>;
+}
+
+/**
+ * Resolve enum aliases for a string or number property
+ * @param property
+ * @param fromBuilder
+ */
+export function resolvePropertyEnum(property: StringProperty | NumberProperty, fromBuilder?: boolean): ResolvedStringProperty | ResolvedNumberProperty {
+    if (typeof property.enumValues === "object") {
+        return {
+            ...property,
+            resolved: true,
+            enumValues: enumToObjectEntries(property.enumValues)?.filter((value) => value && value.id && value.label) ?? [],
+            fromBuilder: fromBuilder ?? false
+        }
+    }
+    return property as ResolvedStringProperty | ResolvedNumberProperty;
+}
+
+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)) {
+        return input as EnumValueConfig[];
+    } else {
+        return undefined;
+    }
+}
+
+export function resolveEntityView(entityView: string | EntityCustomView<any>, contextEntityViews?: EntityCustomView<any>[]): EntityCustomView<any> | undefined {
+    if (typeof entityView === "string") {
+        return contextEntityViews?.find((entry) => entry.key === entityView);
+    } else {
+        return entityView;
+    }
+}

package/src/util/storage.ts

@@ -0,0 +1,92 @@
+import {
+    EntityValues,
+    ResolvedArrayProperty,
+    ResolvedStringProperty,
+    StorageConfig,
+    UploadedFileContext
+} from "../types";
+import { randomString } from "./strings";
+
+export async function resolveFilenameString<M extends object>(
+    input: string | ((context: UploadedFileContext) => Promise<string> | string),
+    storage: StorageConfig,
+    values: EntityValues<M>,
+    entityId: string,
+    path: string,
+    property: ResolvedStringProperty | ResolvedArrayProperty<string[]>,
+    file: File,
+    propertyKey: string): Promise<string> {
+    let result;
+    if (typeof input === "function") {
+        result = await input({
+            path,
+            entityId,
+            values,
+            property,
+            file,
+            storage,
+            propertyKey
+        });
+        if (!result)
+            console.warn("Storage callback returned empty result. Using default name value")
+    } else {
+        result = replacePlaceholders(file, input, entityId, propertyKey, path);
+    }
+
+    if (!result)
+        result = randomString() + "_" + file.name;
+
+    return result;
+}
+
+export function resolveStoragePathString<M extends object>(
+    input: string | ((context: UploadedFileContext) => string),
+    storage: StorageConfig,
+    values: EntityValues<M>,
+    entityId: string,
+    path: string,
+    property: ResolvedStringProperty | ResolvedArrayProperty<string[]>,
+    file: File,
+    propertyKey: string): string {
+    let result;
+    if (typeof input === "function") {
+        result = input({
+            path,
+            entityId,
+            values,
+            property,
+            file,
+            storage,
+            propertyKey
+        });
+        if (!result)
+            console.warn("Storage callback returned empty result. Using default name value")
+    } else {
+        result = replacePlaceholders(file, input, entityId, propertyKey, path);
+    }
+
+    if (!result)
+        result = randomString() + "_" + file.name;
+
+    return result;
+}
+
+function replacePlaceholders(file: File, input: string, entityId: string, propertyKey: string, path: string) {
+    const ext = file.name.split(".").pop();
+    let result = input.replace("{entityId}", entityId)
+        .replace("{propertyKey}", propertyKey)
+        .replace("{rand}", randomString())
+        .replace("{file}", file.name)
+        .replace("{file.type}", file.type)
+        .replace("{path}", path);
+    if (ext) {
+        result = result.replace("{file.ext}", ext);
+        const name = file.name.replace(`.${ext}`, "");
+        result = result.replace("{file.name}", name)
+    }
+
+    if (!result)
+        result = randomString() + "_" + file.name;
+
+    return result;
+}

package/src/util/strings.ts

@@ -0,0 +1,62 @@
+const kebabCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+
+export const toKebabCase = (str: string) => {
+    const regExpMatchArray = str.match(kebabCaseRegex);
+    if (!regExpMatchArray) return "";
+    return regExpMatchArray
+        .map(x => x.toLowerCase())
+        .join("-");
+};
+
+const snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+
+export const toSnakeCase = (str: string) => {
+    const regExpMatchArray = str.match(snakeCaseRegex);
+    if (!regExpMatchArray) return "";
+    return regExpMatchArray
+        .map(x => x.toLowerCase())
+        .join("_");
+};
+
+export function randomString(strLength = 5) {
+    return Math.random().toString(36).slice(2, 2 + strLength);
+}
+
+export function randomColor() {
+    return Math.floor(Math.random() * 16777215).toString(16);
+}
+
+export function slugify(text?: string, separator = "_", lowercase = true) {
+    if (!text) return "";
+    const from = "ãàáäâẽèéëêìíïîõòóöôùúüûñç·/_,:;-"
+    const to = `aaaaaeeeeeiiiiooooouuuunc${separator}${separator}${separator}${separator}${separator}${separator}${separator}`;
+
+    for (let i = 0, l = from.length; i < l; i++) {
+        text = text.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
+    }
+
+    text = text
+        .toString() // Cast to string
+        .replace(/\s+/g, separator) // Replace spaces with separator
+        .replace(/&/g, separator) // Replace & with separator
+        .replace(/[^\w\\-]+/g, "") // Remove all non-word chars
+        .replace(new RegExp("\\" + separator + "\\" + separator + "+", "g"),
+            separator) // Replace multiple separators with single one
+        .trim() // Remove whitespace from both sides of a string
+        .replace(/^\s+|\s+$/g, "");
+
+    return lowercase
+        ? text.toLowerCase() // Convert the string to lowercase letters
+        : text;
+}
+
+export function unslugify(slug: string): string {
+    if (slug.includes("-") || slug.includes("_") || !slug.includes(" ")) {
+        const result = slug.replace(/[-_]/g, " ");
+        return result.replace(/\w\S*/g, function (txt) {
+            return txt.charAt(0).toUpperCase() + txt.substr(1);
+        });
+    } else {
+        return slug;
+    }
+}

package/src/util/useDebounce.ts

@@ -0,0 +1,25 @@
+import React from "react";
+
+export function useDebounce<T>(value: T, callback: () => void, immediate: boolean, timeoutMs = 300) {
+
+    const pendingUpdate = React.useRef(false);
+    const performUpdate = () => {
+        callback();
+        pendingUpdate.current = false;
+    };
+
+    const handlerRef = React.useRef<number | undefined>(undefined);
+
+    React.useEffect(
+        () => {
+            pendingUpdate.current = true;
+            clearTimeout(handlerRef.current);
+            handlerRef.current = setTimeout(performUpdate, timeoutMs) as any;
+            return () => {
+                if (immediate)
+                    performUpdate();
+            };
+        },
+        [immediate, value]
+    );
+}