@firecms/core 3.0.0-alpha.7 → 3.0.0-alpha.71

package/src/util/plurals.ts

@@ -0,0 +1,190 @@
+/**
+ * Returns the plural of an English word.
+ *
+ * @export
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export function plural(word: string, amount?: number): string {
+    if (amount !== undefined && amount === 1) {
+        return word
+    }
+    const plurals: { [key: string]: string } = {
+        "(quiz)$": "$1zes",
+        "^(ox)$": "$1en",
+        "([m|l])ouse$": "$1ice",
+        "(matr|vert|ind)ix|ex$": "$1ices",
+        "(x|ch|ss|sh)$": "$1es",
+        "([^aeiouy]|qu)y$": "$1ies",
+        "(hive)$": "$1s",
+        "(?:([^f])fe|([lr])f)$": "$1$2ves",
+        "(shea|lea|loa|thie)f$": "$1ves",
+        sis$: "ses",
+        "([ti])um$": "$1a",
+        "(tomat|potat|ech|her|vet)o$": "$1oes",
+        "(bu)s$": "$1ses",
+        "(alias)$": "$1es",
+        "(octop)us$": "$1i",
+        "(ax|test)is$": "$1es",
+        "(us)$": "$1es",
+        "([^s]+)$": "$1s"
+    }
+    const irregular: { [key: string]: string } = {
+        move: "moves",
+        foot: "feet",
+        goose: "geese",
+        sex: "sexes",
+        child: "children",
+        man: "men",
+        tooth: "teeth",
+        person: "people"
+    }
+    const uncountable: string[] = [
+        "sheep",
+        "fish",
+        "deer",
+        "moose",
+        "series",
+        "species",
+        "money",
+        "rice",
+        "information",
+        "equipment",
+        "bison",
+        "cod",
+        "offspring",
+        "pike",
+        "salmon",
+        "shrimp",
+        "swine",
+        "trout",
+        "aircraft",
+        "hovercraft",
+        "spacecraft",
+        "sugar",
+        "tuna",
+        "you",
+        "wood"
+    ]
+    // save some time in the case that singular and plural are the same
+    if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+        return word;
+    }
+    // check for irregular forms
+    for (const w in irregular) {
+        const pattern = new RegExp(`${w}$`, "i")
+        const replace = irregular[w]
+        if (pattern.test(word)) {
+            return word.replace(pattern, replace);
+        }
+    }
+    // check for matches using regular expressions
+    for (const reg in plurals) {
+        const pattern = new RegExp(reg, "i")
+        if (pattern.test(word)) {
+            return word.replace(pattern, plurals[reg])
+        }
+    }
+    return word;
+}
+
+/**
+ * Returns the singular of an English word.
+ *
+ * @export
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export function singular(word: string, amount?: number): string {
+    if (amount !== undefined && amount !== 1) {
+        return word;
+    }
+    const singulars: { [key: string]: string } = {
+        "(quiz)zes$": "$1",
+        "(matr)ices$": "$1ix",
+        "(vert|ind)ices$": "$1ex",
+        "^(ox)en$": "$1",
+        "(alias)es$": "$1",
+        "(octop|vir)i$": "$1us",
+        "(cris|ax|test)es$": "$1is",
+        "(shoe)s$": "$1",
+        "(o)es$": "$1",
+        "(bus)es$": "$1",
+        "([m|l])ice$": "$1ouse",
+        "(x|ch|ss|sh)es$": "$1",
+        "(m)ovies$": "$1ovie",
+        "(s)eries$": "$1eries",
+        "([^aeiouy]|qu)ies$": "$1y",
+        "([lr])ves$": "$1f",
+        "(tive)s$": "$1",
+        "(hive)s$": "$1",
+        "(li|wi|kni)ves$": "$1fe",
+        "(shea|loa|lea|thie)ves$": "$1f",
+        "(^analy)ses$": "$1sis",
+        "((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$": "$1$2sis",
+        "([ti])a$": "$1um",
+        "(n)ews$": "$1ews",
+        "(h|bl)ouses$": "$1ouse",
+        "(corpse)s$": "$1",
+        "(us)es$": "$1",
+        s$: ""
+    }
+    const irregular: { [key: string]: string } = {
+        move: "moves",
+        foot: "feet",
+        goose: "geese",
+        sex: "sexes",
+        child: "children",
+        man: "men",
+        tooth: "teeth",
+        person: "people"
+    }
+    const uncountable: string[] = [
+        "sheep",
+        "fish",
+        "deer",
+        "moose",
+        "series",
+        "species",
+        "money",
+        "rice",
+        "information",
+        "equipment",
+        "bison",
+        "cod",
+        "offspring",
+        "pike",
+        "salmon",
+        "shrimp",
+        "swine",
+        "trout",
+        "aircraft",
+        "hovercraft",
+        "spacecraft",
+        "sugar",
+        "tuna",
+        "you",
+        "wood"
+    ]
+    // save some time in the case that singular and plural are the same
+    if (uncountable.indexOf(word.toLowerCase()) >= 0) {
+        return word;
+    }
+    // check for irregular forms
+    for (const w in irregular) {
+        const pattern = new RegExp(`${irregular[w]}$`, "i");
+        if (pattern.test(word)) {
+            return word.replace(pattern, w);
+        }
+    }
+    // check for matches using regular expressions
+    for (const reg in singulars) {
+        const pattern = new RegExp(reg, "i");
+        if (pattern.test(word)) {
+            return word.replace(pattern, singulars[reg]);
+        }
+    }
+    return word;
+}

package/src/util/property_utils.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { EntityCollection, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedProperty } from "../types";
+export declare function isReferenceProperty(propertyOrBuilder: PropertyOrBuilder, fields: Record<string, PropertyConfig>): boolean | null;
+export declare function getIdIcon(size: "small" | "medium" | "large"): React.ReactNode;
+export declare function getIconForWidget(widget: PropertyConfig | undefined, size: "small" | "medium" | "large"): import("react/jsx-runtime").JSX.Element;
+export declare function getIconForProperty(property: PropertyOrBuilder | ResolvedProperty, size?: "small" | "medium" | "large", fields?: Record<string, PropertyConfig>): React.ReactNode;
+export declare function getColorForProperty(property: PropertyOrBuilder, fields: Record<string, PropertyConfig>): string;
+/**
+ * Get a property in a property tree from a path like
+ * `address.street`
+ * @param properties
+ * @param path
+ */
+export declare function getPropertyInPath<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, path: string): PropertyOrBuilder<any, M> | undefined;
+export declare function getResolvedPropertyInPath(properties: Record<string, ResolvedProperty>, path: string): ResolvedProperty | undefined;
+export declare function getBracketNotation(path: string): string;
+/**
+ * Get properties exclusively indexed by their order
+ * @param properties
+ * @param propertiesOrder
+ */
+export declare function getPropertiesWithPropertiesOrder<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, propertiesOrder?: Extract<keyof M, string>[]): PropertiesOrBuilders<M>;
+export declare function getDefaultPropertiesOrder(collection: EntityCollection<any>): string[];

package/src/util/property_utils.tsx

@@ -0,0 +1,130 @@
+import React from "react";
+
+import { EntityCollection, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, 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>) {
+    const resolvedProperty = resolveProperty({
+        propertyKey: "ignore", // TODO
+        propertyOrBuilder,
+        fields
+    });
+    if (!resolvedProperty) return null;
+    if (resolvedProperty.dataType === "reference") {
+        return true;
+    }
+    if (resolvedProperty.dataType === "array") {
+        if (Array.isArray(resolvedProperty.of)) return false;
+        else return resolvedProperty.of?.dataType === "reference"
+    }
+    return false;
+}
+
+export function getIdIcon(size: "small" | "medium" | "large"): React.ReactNode {
+    return <CircleIcon size={size}/>;
+}
+
+export function getIconForWidget(widget: PropertyConfig | undefined,
+                                 size: "small" | "medium" | "large") {
+    const Icon = widget?.Icon ?? CircleIcon;
+    return <Icon size={size}/>;
+}
+
+export function getIconForProperty(
+    property: PropertyOrBuilder | ResolvedProperty,
+    size: "small" | "medium" | "large" = "small",
+    fields: Record<string, PropertyConfig> = {}
+): React.ReactNode {
+
+    if (isPropertyBuilder(property)) {
+        return <FunctionsIcon size={size}/>;
+    } else {
+        const widget = getFieldConfig(property, fields);
+        return getIconForWidget(widget, size);
+    }
+}
+
+export function getColorForProperty(property: PropertyOrBuilder, fields: Record<string, PropertyConfig>): string {
+    if (isPropertyBuilder(property)) {
+        return "#888";
+    } else {
+        const widget = getFieldConfig(property, fields);
+        return widget?.color ?? "#666";
+    }
+}
+
+/**
+ * Get a property in a property tree from a path like
+ * `address.street`
+ * @param properties
+ * @param path
+ */
+export function getPropertyInPath<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, path: string): PropertyOrBuilder<any, M> | undefined {
+    if (typeof properties === "object") {
+        if (path in properties) {
+            return properties[path];
+        }
+        if (path.includes(".")) {
+            const pathSegments = path.split(".");
+            const childProperty = properties[pathSegments[0]];
+            if (typeof childProperty === "object" && childProperty.dataType === "map" && childProperty.properties) {
+                return getPropertyInPath(childProperty.properties, pathSegments.slice(1).join("."))
+            }
+        }
+    }
+    return undefined;
+}
+
+export function getResolvedPropertyInPath(properties: Record<string, ResolvedProperty>, path: string): ResolvedProperty | undefined {
+    if (typeof properties === "object") {
+        if (path in properties) {
+            return properties[path];
+        }
+        if (path.includes(".")) {
+            const pathSegments = path.split(".");
+            const childProperty = properties[pathSegments[0]];
+            if (childProperty.dataType === "map" && childProperty.properties) {
+                return getResolvedPropertyInPath(childProperty.properties, pathSegments.slice(1).join("."))
+            }
+        }
+    }
+    return undefined;
+}
+
+// replace the dot notation with brackets
+// address.street => address[street]
+export function getBracketNotation(path: string): string {
+    return path.replace(/\.([^.]*)/g, "[$1]");
+}
+
+/**
+ * Get properties exclusively indexed by their order
+ * @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 result: PropertiesOrBuilders<any> = {};
+    propertiesOrder.filter(Boolean).forEach(path => {
+        const property = getPropertyInPath(properties, path);
+        if (typeof property === "object" && property.dataType === "map" && property.properties) {
+            result[path] = {
+                ...property,
+                properties: getPropertiesWithPropertiesOrder(property.properties, property.propertiesOrder ?? [])
+            }
+        }
+        if (property) {
+            result[path] = property;
+        }
+    });
+    return result;
+}
+
+export function getDefaultPropertiesOrder(collection: EntityCollection<any>): string[] {
+    if (collection.propertiesOrder) return collection.propertiesOrder;
+    return [...Object.keys(collection.properties), ...(collection.additionalFields ?? []).map(field => field.key)];
+}

package/src/util/references.d.ts

@@ -0,0 +1,2 @@
+import { EntityCollection, PropertyConfig } from "../types";
+export declare function getReferencePreviewKeys(targetCollection: EntityCollection<any>, fields: Record<string, PropertyConfig>, previewProperties?: string[], limit?: number): string[];

package/src/util/references.ts

@@ -0,0 +1,20 @@
+import { EntityCollection, PropertyConfig } from "../types";
+import { isReferenceProperty } from "./property_utils";
+import { isPropertyBuilder } from "./entities";
+
+export function getReferencePreviewKeys(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 && listProperties.length > 0) {
+        return listProperties;
+    } else {
+        listProperties = allProperties;
+        return listProperties.filter(key => {
+            const propertyOrBuilder = targetCollection.properties[key];
+            return propertyOrBuilder && !isPropertyBuilder(propertyOrBuilder) && !isReferenceProperty(propertyOrBuilder, fields);
+        }).slice(0, limit);
+    }
+}

package/src/util/regexp.d.ts

@@ -0,0 +1,7 @@
+export declare function serializeRegExp(input: RegExp): string;
+/**
+ * Get a RegExp out of a serialized string
+ * @param input
+ */
+export declare function hydrateRegExp(input?: string): RegExp | undefined;
+export declare function isValidRegExp(input: string): boolean;

package/src/util/regexp.ts

@@ -0,0 +1,32 @@
+export function serializeRegExp(input: RegExp): string {
+    if (!input) return "";
+    // const fragments = input.toString().match(/\/(.*?)\/([a-z]*)?$/i);
+    // if (fragments) {
+    //     if (fragments[2])
+    //         return input.toString();
+    //     return fragments[1];
+    // }
+    return input.toString();
+}
+
+/**
+ * Get a RegExp out of a serialized string
+ * @param input
+ */
+export function hydrateRegExp(input?: string): RegExp | undefined {
+    if (!input) return undefined;
+    const fragments = input.match(/\/(.*?)\/([a-z]*)?$/i);
+    if (fragments) {
+        return new RegExp(fragments[1], fragments[2] || "");
+    } else {
+        return new RegExp(input, "");
+    }
+}
+
+export function isValidRegExp(input: string): boolean {
+    const fullRegexp = input.match(/\/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)\/((?:g(?:im?|mi?)?|i(?:gm?|mg?)?|m(?:gi?|ig?)?)?)/);
+    if (fullRegexp)
+        return true;
+    const simpleRegexp = input.match(/((?![*+?])(?:[^\r\n[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*])+)/);
+    return !!simpleRegexp;
+}

package/src/util/resolutions.d.ts

@@ -0,0 +1,64 @@
+import { ArrayProperty, CMSType, EntityCollection, EntityCustomView, EntityValues, EnumValueConfig, EnumValues, NumberProperty, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedArrayProperty, ResolvedEntityCollection, ResolvedNumberProperty, ResolvedProperties, ResolvedProperty, ResolvedStringProperty, StringProperty, UserConfigurationPersistence } from "../types";
+export declare const resolveCollection: <M extends Record<string, any>>({ collection, path, entityId, values, previousValues, userConfigPersistence, fields }: {
+    collection: EntityCollection<M, import("../types").User> | ResolvedEntityCollection<M>;
+    path: string;
+    entityId?: string | undefined;
+    values?: Partial<M> | undefined;
+    previousValues?: Partial<M> | undefined;
+    userConfigPersistence?: UserConfigurationPersistence | undefined;
+    fields?: Record<string, PropertyConfig> | undefined;
+}) => ResolvedEntityCollection<M>;
+/**
+ * Resolve property builders, enums and arrays.
+ * @param propertyOrBuilder
+ * @param propertyValue
+ * @param values
+ */
+export declare function resolveProperty<T extends CMSType = CMSType, M extends Record<string, any> = any>({ propertyOrBuilder, propertyValue, fromBuilder, ...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;
+export declare 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;
+/**
+ * Resolve enums and arrays for properties
+ * @param properties
+ * @param value
+ */
+export declare 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>;
+/**
+ * Resolve enum aliases for a string or number property
+ * @param property
+ * @param fromBuilder
+ */
+export declare function resolvePropertyEnum(property: StringProperty | NumberProperty, fromBuilder?: boolean): ResolvedStringProperty | ResolvedNumberProperty;
+export declare function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined;
+export declare function resolveEntityView(entityView: string | EntityCustomView<any>, contextEntityViews?: EntityCustomView<any>[]): EntityCustomView<any> | undefined;