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

package/src/util/icons.tsx

@@ -0,0 +1,45 @@
+import React from "react";
+import { CMSView, EntityCollection } from "../types";
+import { hashString } from "./hash";
+import { coolIconKeys, Icon, iconKeys } from "@firecms/ui";
+import { slugify } from "./strings";
+
+export function getIcon(iconKey?: string, className?:string): React.ReactElement | undefined {
+    if (!iconKey) return undefined;
+    iconKey = slugify(iconKey);
+    if (!(iconKey in iconKeysMap)) {
+        return undefined;
+    }
+    return iconKey in iconKeysMap ? <Icon iconKey={iconKey} size={"medium"} className={className}/> : undefined;
+}
+
+export function getIconForView(collectionOrView: EntityCollection | CMSView, className?:string): React.ReactElement {
+
+    const icon = getIcon(collectionOrView.icon, className);
+    if (collectionOrView?.icon && icon)
+        return icon;
+
+    let slugName = slugify(("singularName" in collectionOrView ? collectionOrView.singularName : undefined) ?? collectionOrView.name);
+
+    let key: string | undefined;
+    if (slugName in iconKeysMap)
+        key = slugName;
+
+    if (!key) {
+        slugName = slugify(collectionOrView.path);
+        if (slugName in iconKeysMap)
+            key = slugName;
+    }
+
+    const iconsCount = coolIconKeys.length;
+
+    if (!key)
+        key = coolIconKeys[hashString(collectionOrView.path) % iconsCount];
+
+    return <Icon iconKey={key} size={"medium"} className={className}/>;
+}
+
+const iconKeysMap: Record<string, string> = iconKeys.reduce((acc: Record<string, string>, key) => {
+    acc[key] = key;
+    return acc;
+}, {});

package/src/util/index.ts

@@ -0,0 +1,22 @@
+export * from "./collections";
+export * from "./entities";
+export * from "./strings";
+export * from "./dates";
+export * from "./enums";
+export * from "./objects";
+export * from "./paths";
+export * from "./regexp";
+export * from "./navigation_utils";
+export * from "./useDebounce";
+export * from "./property_utils";
+export * from "./resolutions";
+export * from "./permissions";
+export * from "./icon_list";
+export * from "./icon_synonyms";
+export * from "./icons";
+export * from "./plurals";
+export * from "./references";
+export * from "./flatten_object";
+export * from "./make_properties_editable";
+export * from "./join_collections";
+export * from "./builders";

package/src/util/join_collections.ts

@@ -0,0 +1,172 @@
+import {
+    EntityCollection,
+    MapProperty,
+    ModifyCollectionProps,
+    PropertiesOrBuilders,
+    Property,
+    PropertyOrBuilder
+} from "../types";
+import { mergeDeep } from "./objects";
+import { sortProperties } from "./collections";
+import { isPropertyBuilder } from "./entities";
+
+function applyModifyFunction(modifyCollection: ((props: ModifyCollectionProps) => (EntityCollection | void)) | undefined,
+                             collection: EntityCollection,
+                             parentPaths: string[]) {
+    if (modifyCollection) {
+        const modified = modifyCollection({
+            collection,
+            parentPaths
+        });
+        const resCollection = modified ?? collection;
+        if (resCollection.subcollections) {
+            resCollection.subcollections = resCollection.subcollections.map((subcollection) => {
+                return applyModifyFunction(modifyCollection, subcollection, [...parentPaths, collection.path]);
+            });
+        }
+        return resCollection;
+    } else {
+        return collection;
+    }
+}
+
+/**
+ *
+ */
+export function joinCollectionLists(targetCollections: EntityCollection[],
+                                    sourceCollections: EntityCollection[] | undefined,
+                                    parentPaths: string[] = [],
+                                    modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void): EntityCollection[] {
+
+    // merge collections that are in both lists
+    const updatedCollections = (sourceCollections ?? [])
+        .map((sourceCol) => {
+            const targetCol = targetCollections?.find((collection) => {
+                return collection.id === sourceCol.id;
+                // return collection.path === codedCollection.path || collection.id && codedCollection.id;
+            });
+            if (!targetCol) {
+                return applyModifyFunction(modifyCollection, sourceCol, parentPaths);
+            } else {
+                return mergeCollection(targetCol, sourceCol, parentPaths, modifyCollection);
+            }
+        });
+
+    const sourceCollectionIds = updatedCollections.map(c => c.id);
+    // fetched collections that are not in the source collections
+    const resultStoredCollections = targetCollections
+        .filter((col) => {
+            return !sourceCollectionIds.includes(col.id);
+        })
+        .map((col) => {
+            if (modifyCollection) {
+                return applyModifyFunction(modifyCollection, col, parentPaths);
+            } else {
+                return col;
+            }
+        });
+
+    return [...updatedCollections, ...resultStoredCollections];
+}
+
+/**
+ *
+ */
+export function mergeCollection(target: EntityCollection,
+                                source: EntityCollection,
+                                parentPaths: string[] = [],
+                                modifyCollection?: (props: ModifyCollectionProps) => EntityCollection | void
+): EntityCollection {
+
+    const subcollectionsMerged = joinCollectionLists(
+        target?.subcollections ?? [],
+        source?.subcollections ?? [],
+        [...parentPaths, target.path],
+        modifyCollection
+    );
+
+    const propertiesMerged: PropertiesOrBuilders = { ...target.properties } as PropertiesOrBuilders;
+    Object.keys(source.properties).forEach((key) => {
+        const property = target.properties[key] as Property;
+        if (property)
+            propertiesMerged[key] = mergePropertyOrBuilder(property, source.properties[key] as PropertyOrBuilder);
+        else
+            propertiesMerged[key] = source.properties[key] as PropertyOrBuilder;
+    });
+
+    const mergedCollection = mergeDeep(target, source);
+    const targetPropertiesOrder = getCollectionKeys(target);
+    const sourcePropertiesOrder = getCollectionKeys(source);
+    const mergedPropertiesOrder = [...new Set([...sourcePropertiesOrder, ...targetPropertiesOrder])];
+    const mergedEntityViews = [...new Set([...(target.entityViews ?? []), ...(source.entityViews ?? [])])];
+
+    let resultCollection: EntityCollection = {
+        ...mergedCollection,
+        subcollections: subcollectionsMerged,
+        properties: sortProperties(propertiesMerged, mergedPropertiesOrder),
+        propertiesOrder: mergedPropertiesOrder,
+        entityViews: mergedEntityViews
+    };
+    if (modifyCollection) {
+        const modifiedCollection = modifyCollection({
+            collection: resultCollection,
+            parentPaths
+        });
+        if (modifiedCollection)
+            resultCollection = modifiedCollection;
+    }
+    return resultCollection
+}
+
+function mergePropertyOrBuilder(target: PropertyOrBuilder, source: PropertyOrBuilder): PropertyOrBuilder {
+    if (isPropertyBuilder(source)) {
+        return source;
+    } else if (isPropertyBuilder(target)) {
+        return target;
+    } else {
+        const mergedProperty = mergeDeep(target, source);
+        const targetEditable = Boolean(target.editable);
+        const sourceEditable = Boolean(source.editable);
+        if (source.dataType === "map" && source.properties) {
+            const targetProperties = ("properties" in target ? target.properties : {}) as PropertiesOrBuilders;
+            const sourceProperties = ("properties" in source ? source.properties : {}) as PropertiesOrBuilders;
+            const targetPropertiesOrder = "propertiesOrder" in target && target.propertiesOrder ? target.propertiesOrder : Object.keys(targetProperties);
+            const sourcePropertiesOrder = "propertiesOrder" in source && source.propertiesOrder ? source.propertiesOrder : ("properties" in source ? Object.keys(source.properties) : []);
+            const mergedPropertiesOrder = [...new Set([...targetPropertiesOrder, ...sourcePropertiesOrder])];
+            const mergedProperties: PropertiesOrBuilders = { ...targetProperties } as PropertiesOrBuilders;
+            Object.keys(source.properties).forEach((key) => {
+                const property = targetProperties[key] as Property;
+                if (property)
+                    mergedProperties[key] = mergePropertyOrBuilder(property, sourceProperties[key] as PropertyOrBuilder);
+            });
+            return {
+                ...mergedProperty,
+                editable: targetEditable && sourceEditable,
+                properties: mergedProperties,
+                propertiesOrder: mergedPropertiesOrder
+            } as MapProperty;
+        }
+        return {
+            ...mergedProperty,
+            editable: targetEditable && sourceEditable
+        };
+    }
+}
+
+function getCollectionKeys(collection: EntityCollection) {
+    if (collection.propertiesOrder && collection.propertiesOrder.length > 0) {
+        const propertiesOrder = collection.propertiesOrder;
+        if (collection.additionalFields) {
+            collection.additionalFields.forEach((field) => {
+                if (!propertiesOrder.includes(field.key)) {
+                    propertiesOrder.push(field.key);
+                }
+            });
+        }
+        return propertiesOrder;
+    }
+    return [
+        ...Object.keys(collection.properties),
+        ...(collection.additionalFields ?? [])?.map(f => f.key)
+    ];
+}

package/src/util/make_properties_editable.ts

@@ -0,0 +1,29 @@
+import { Properties, PropertiesOrBuilders } from "../types";
+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);
+        }
+    });
+    return 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) };
+            acc[key] = updated;
+        }
+        if (isPropertyBuilder(property)) {
+            acc[key] = property;
+        } else {
+            acc[key] = { ...property, editable: false };
+        }
+        return acc;
+    }, {} as PropertiesOrBuilders);
+
+}

package/src/util/navigation_from_path.ts

@@ -0,0 +1,107 @@
+import { EntityCollection, EntityCustomView } from "../types";
+import { getCollectionPathsCombinations, removeInitialAndTrailingSlashes } from "./navigation_utils";
+import { resolveEntityView } from "./resolutions";
+
+export type NavigationViewInternal<M extends Record<string, any> = any> =
+    | NavigationViewEntityInternal<M>
+    | NavigationViewCollectionInternal<M>
+    | NavigationViewEntityCustomInternal<M>;
+
+export interface NavigationViewEntityInternal<M extends Record<string, any>> {
+    type: "entity";
+    entityId: string;
+    path: string;
+    parentCollection: EntityCollection<M>;
+}
+
+export interface NavigationViewCollectionInternal<M extends Record<string, any>> {
+    type: "collection";
+    path: string;
+    collection: EntityCollection<M>;
+}
+
+export interface NavigationViewEntityCustomInternal<M extends Record<string, any>> {
+    type: "custom_view";
+    path: string;
+    view: EntityCustomView<M>;
+}
+
+export function getNavigationEntriesFromPathInternal(props: {
+    path: string,
+    collections: EntityCollection[] | undefined,
+    currentFullPath?: string,
+    contextEntityViews?: EntityCustomView<any>[]
+}): NavigationViewInternal [] {
+
+    const {
+        path,
+        collections = [],
+        currentFullPath
+    } = props;
+
+    const subpaths = removeInitialAndTrailingSlashes(path).split("/");
+    const subpathCombinations = getCollectionPathsCombinations(subpaths);
+
+    const result: NavigationViewInternal[] = [];
+    for (let i = 0; i < subpathCombinations.length; i++) {
+        const subpathCombination = subpathCombinations[i];
+
+        const collection: EntityCollection<any> | undefined = collections && collections.find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
+
+        if (collection) {
+            const pathOrAlias = collection.id ?? collection.path;
+            const collectionPath = currentFullPath && currentFullPath.length > 0
+                ? (currentFullPath + "/" + pathOrAlias)
+                : pathOrAlias;
+
+            result.push({
+                type: "collection",
+                path: collectionPath,
+                collection
+            });
+            const restOfThePath = removeInitialAndTrailingSlashes(removeInitialAndTrailingSlashes(path).replace(subpathCombination, ""));
+            const nextSegments = restOfThePath.length > 0 ? restOfThePath.split("/") : [];
+            if (nextSegments.length > 0) {
+                const entityId = nextSegments[0];
+                const fullPath = collectionPath + "/" + entityId;
+                result.push({
+                    type: "entity",
+                    entityId,
+                    path: collectionPath,
+                    parentCollection: collection
+                });
+                if (nextSegments.length > 1) {
+                    const newPath = nextSegments.slice(1).join("/");
+                    if (!collection) {
+                        throw Error("collection not found resolving path: " + collection);
+                    }
+                    const entityViews = collection.entityViews;
+                    const customView = entityViews && entityViews
+                        .map((entry) => resolveEntityView(entry, props.contextEntityViews))
+                        .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,
+                            view: customView
+                        });
+                    } else if (collection.subcollections) {
+                        result.push(...getNavigationEntriesFromPathInternal({
+                            path: newPath,
+                            collections: collection.subcollections,
+                            currentFullPath: fullPath,
+                            contextEntityViews: props.contextEntityViews
+                        }));
+                    }
+                }
+            }
+            break;
+        }
+
+    }
+    return result;
+}

package/src/util/navigation_utils.ts

@@ -0,0 +1,111 @@
+import { EntityCollection } from "../types";
+
+export function removeInitialAndTrailingSlashes(s: string): string {
+    return removeInitialSlash(removeTrailingSlash(s));
+}
+
+export function removeInitialSlash(s: string) {
+    if (s.startsWith("/"))
+        return s.slice(1);
+    else return s;
+}
+
+export function removeTrailingSlash(s: string) {
+    if (s.endsWith("/"))
+        return s.slice(0, -1);
+    else return s;
+}
+
+export function addInitialSlash(s: string) {
+    if (s.startsWith("/"))
+        return s;
+    else return `/${s}`;
+}
+
+export function getLastSegment(path: string) {
+    const cleanPath = removeInitialAndTrailingSlashes(path);
+    if (cleanPath.includes("/")) {
+        const segments = cleanPath.split("/");
+        return segments[segments.length - 1];
+    }
+    return cleanPath;
+}
+
+export function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string {
+
+    const cleanPath = removeInitialAndTrailingSlashes(path);
+    const subpaths = cleanPath.split("/");
+    if (subpaths.length % 2 === 0) {
+        throw Error(`resolveCollectionPathAliases: Collection paths must have an odd number of segments: ${path}`);
+    }
+
+    const aliasedCollection = allCollections.find((col) => col.id === subpaths[0]);
+    let resolvedAliased;
+    if (aliasedCollection) {
+        resolvedAliased = aliasedCollection.path;
+    }
+
+    if (subpaths.length > 1) {
+        const segmentCollection = getCollectionByPathOrId(resolvedAliased ?? subpaths[0], allCollections);
+        if (!segmentCollection?.subcollections) {
+            return cleanPath;
+        }
+        const restOfThePath = cleanPath.split("/").slice(2).join("/");
+        return (resolvedAliased ?? subpaths[0]) + "/" + subpaths[1] + "/" + resolveCollectionPathIds(restOfThePath, segmentCollection.subcollections);
+    } else {
+        return resolvedAliased ?? cleanPath;
+    }
+}
+
+/**
+ * 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 collections
+ */
+export function getCollectionByPathOrId(pathOrAlias: string, collections: EntityCollection[]): EntityCollection | undefined {
+
+    const subpaths = removeInitialAndTrailingSlashes(pathOrAlias).split("/");
+    if (subpaths.length % 2 === 0) {
+        throw Error(`getCollectionByPathOrAlias: Collection paths must have an odd number of segments: ${pathOrAlias}`);
+    }
+
+    const subpathCombinations = getCollectionPathsCombinations(subpaths);
+    let result: EntityCollection | undefined;
+    for (let i = 0; i < subpathCombinations.length; i++) {
+        const subpathCombination = subpathCombinations[i];
+        const navigationEntry = collections && collections
+            .sort((a, b) => (a.id ?? "").localeCompare(b.id ?? ""))
+            .find((entry) => entry.id === subpathCombination || entry.path === subpathCombination);
+
+        if (navigationEntry) {
+
+            if (subpathCombination === pathOrAlias) {
+                result = navigationEntry;
+            } else if (navigationEntry.subcollections) {
+                const newPath = pathOrAlias.replace(subpathCombination, "").split("/").slice(2).join("/");
+                if (newPath.length > 0)
+                    result = getCollectionByPathOrId(newPath, navigationEntry.subcollections);
+            }
+        }
+        if (result) break;
+    }
+    return result;
+}
+
+/**
+ * Get the subcollection combinations from a path:
+ * "sites/es/locales" => ["sites/es/locales", "sites"]
+ * @param subpaths
+ */
+export function getCollectionPathsCombinations(subpaths: string[]): string[] {
+    const entries = subpaths.length > 0 && subpaths.length % 2 === 0 ? subpaths.splice(0, subpaths.length - 1) : subpaths;
+
+    const length = entries.length;
+    const result: string[] = [];
+    for (let i = length; i > 0; i = i - 2) {
+        result.push(entries.slice(0, i).join("/"));
+    }
+    return result;
+
+}

package/src/util/objects.ts

@@ -0,0 +1,168 @@
+import hash from "object-hash";
+import { GeoPoint } from "../types";
+
+export const pick: <T>(obj: T, ...args: any[]) => T = (obj: any, ...args: any[]) => ({
+    ...args.reduce((res, key) => ({
+        ...res,
+        [key]: obj[key]
+    }), {})
+});
+
+export function isObject(item: any) {
+    return item && typeof item === "object" && !Array.isArray(item);
+}
+
+export function mergeDeep<T extends object>(target: T, source: any): T {
+    const targetIsObject = isObject(target);
+    const output: T = targetIsObject ? { ...target } : target;
+    if (targetIsObject && isObject(source)) {
+        Object.keys(source).forEach(key => {
+            if (isObject(source[key])) {
+                if (!(key in target))
+                    Object.assign(output, { [key]: source[key] });
+                else
+                    (output as any)[key] = mergeDeep((target as any)[key], source[key]);
+            } else {
+                Object.assign(output, { [key]: source[key] });
+            }
+        });
+    }
+    return output;
+}
+
+// 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") {
+        if (path in o) {
+            return (o as any)[path];
+        }
+        if (path.includes(".") || path.includes("[")) {
+            let pathSegments = path.split(/[.[]/);
+            if (path.includes("[")) {
+                pathSegments = pathSegments.map(segment => segment.replace("]", ""));
+            }
+            const firstSegment = pathSegments[0];
+            const isArrayAndIndexExists = Array.isArray((o as any)[firstSegment]) && !isNaN(parseInt(pathSegments[1]));
+            const nextObject = isArrayAndIndexExists
+                ? (o as any)[firstSegment][parseInt(pathSegments[1])]
+                : (o as any)[firstSegment];
+
+            const nextPath = pathSegments.slice(isArrayAndIndexExists ? 2 : 1).join(".");
+            if (nextPath === "")
+                return nextObject;
+            return getValueInPath(nextObject, nextPath)
+        }
+    }
+    return undefined;
+}
+
+export function removeInPath(o: object, path: string): object | undefined {
+    let currentObject = { ...o };
+    const parts = path.split(".");
+    const last = parts.pop();
+    for (const part of parts) {
+        currentObject = (currentObject as any)[part]
+    }
+    if (last)
+        delete (currentObject as any)[last];
+    return currentObject;
+}
+
+export function removeFunctions(o: object | undefined): any {
+    if (o === undefined) return undefined;
+    if (o === null) return null;
+    if (typeof o === "object") {
+        return Object.entries(o)
+            .filter(([_, value]) => typeof value !== "function")
+            .map(([key, value]) => {
+                if (Array.isArray(value)) {
+                    return { [key]: value.map(v => removeFunctions(v)) };
+                } else if (typeof value === "object") {
+                    return { [key]: removeFunctions(value) };
+                } else return { [key]: value };
+            })
+            .reduce((a, b) => ({ ...a, ...b }), {});
+    }
+    return o;
+}
+
+export function getHashValue<T>(v: T) {
+    if (!v) return null;
+    if (typeof v === "object") {
+        if ("id" in v)
+            return (v as any).id;
+        else if (v instanceof Date)
+            return v.toLocaleString();
+        else if (v instanceof GeoPoint)
+            return hash(v as Record<string, unknown>);
+    }
+    return hash(v, { ignoreUnknown: true });
+}
+
+export function removeUndefined(value: any, removeEmptyStrings?: boolean): any {
+    if (typeof value === "function") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v: any) => removeUndefined(v, removeEmptyStrings));
+    }
+    if (typeof value === "object") {
+        const res: object = {};
+        if (value === null)
+            return value;
+        Object.keys(value).forEach((key) => {
+            if (!isEmptyObject(value)) {
+                const childRes = removeUndefined(value[key], removeEmptyStrings);
+                const isString = typeof childRes === "string";
+                const shouldKeepIfString = !removeEmptyStrings || (removeEmptyStrings && !isString) || (removeEmptyStrings && isString && childRes !== "");
+                if (childRes !== undefined && !isEmptyObject(childRes) && shouldKeepIfString)
+                    (res as any)[key] = childRes;
+            }
+        });
+        return res;
+    }
+    return value;
+}
+
+export function isEmptyObject(obj: object) {
+    return obj &&
+        Object.getPrototypeOf(obj) === Object.prototype &&
+        Object.keys(obj).length === 0
+}
+
+export function removePropsIfExisting(source: any, comparison: any) {
+    const isObject = (val: any) => typeof val === "object" && val !== null;
+    const isArray = (val: any) => Array.isArray(val);
+
+    if (!isObject(source) || !isObject(comparison)) {
+        return source;
+    }
+
+    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];
+            }
+        }
+    });
+
+    return res;
+}

package/src/util/os.ts

@@ -0,0 +1,13 @@
+export function getOS() {
+    let OS = "Unknown";
+    if (navigator.userAgent.indexOf("Win") !== -1) OS = "Windows";
+    if (navigator.userAgent.indexOf("Mac") !== -1) OS = "MacOS";
+    if (navigator.userAgent.indexOf("X11") !== -1) OS = "UNIX";
+    if (navigator.userAgent.indexOf("Linux") !== -1) OS = "Linux";
+    return OS;
+}
+
+export function getAltSymbol() {
+    if (getOS() === "MacOS") return "⌥";
+    return "Alt";
+}