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

package/src/util/collections.ts

@@ -0,0 +1,50 @@
+import {
+    DefaultSelectedViewBuilder,
+    DefaultSelectedViewParams,
+    PropertiesOrBuilders,
+    PropertyOrBuilder
+} from "../types";
+import { isPropertyBuilder } from "./entities";
+
+export function sortProperties<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, propertiesOrder?: (keyof M)[]): PropertiesOrBuilders<M> {
+    try {
+        const propertiesKeys = Object.keys(properties);
+        const allPropertiesOrder = propertiesOrder ?? propertiesKeys;
+        return allPropertiesOrder
+            .map((key) => {
+                if (properties[key as keyof M]) {
+                    const property = properties[key] as PropertyOrBuilder;
+                    if (!isPropertyBuilder(property) && property?.dataType === "map" && property.properties) {
+                        return ({
+                            [key]: {
+                                ...property,
+                                properties: sortProperties(property.properties, property.propertiesOrder)
+                            }
+                        });
+                    } else {
+                        return ({ [key]: property });
+                    }
+                } else {
+                    return undefined;
+                }
+            })
+            .filter((a) => a !== undefined)
+            .reduce((a: any, b: any) => ({ ...a, ...b }), {}) as PropertiesOrBuilders<M>;
+    } catch (e) {
+        console.error("Error sorting properties", e);
+        return properties;
+    }
+}
+
+export function resolveDefaultSelectedView(
+    defaultSelectedView: string | DefaultSelectedViewBuilder | undefined,
+    params: DefaultSelectedViewParams
+) {
+    if (!defaultSelectedView) {
+        return undefined;
+    } else if (typeof defaultSelectedView === "string") {
+        return defaultSelectedView;
+    } else {
+        return defaultSelectedView(params);
+    }
+}

package/src/util/common.tsx

@@ -0,0 +1,2 @@
+export const DEFAULT_ONE_OF_TYPE = "type"
+export const DEFAULT_ONE_OF_VALUE = "value"

package/src/util/dates.ts

@@ -0,0 +1 @@
+export const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";

package/src/util/entities.ts

@@ -0,0 +1,196 @@
+import {
+    CMSType,
+    DataType,
+    Entity,
+    EntityReference,
+    EntityStatus,
+    EntityValues,
+    Properties,
+    PropertiesOrBuilders,
+    Property,
+    PropertyBuilder,
+    PropertyOrBuilder,
+    ResolvedProperties,
+    ResolvedProperty
+} from "../types";
+import { DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "./common";
+
+export function isReadOnly(property: Property | ResolvedProperty): boolean {
+    if (property.readOnly)
+        return true;
+    if (property.dataType === "date") {
+        if (property.autoValue)
+            return true;
+    }
+    if (property.dataType === "reference") {
+        return !property.path;
+    }
+    return false;
+}
+
+export function isHidden(property: Property | ResolvedProperty): boolean {
+    return typeof property.disabled === "object" && Boolean(property.disabled.hidden);
+}
+
+export function isPropertyBuilder<T extends CMSType, M extends Record<string, any>>(propertyOrBuilder?: PropertyOrBuilder<T, M> | Property<T> | ResolvedProperty<T>): propertyOrBuilder is PropertyBuilder<T, M> {
+    return typeof propertyOrBuilder === "function";
+}
+
+export function getDefaultValuesFor<M extends Record<string, any>>(properties: PropertiesOrBuilders<M> | ResolvedProperties<M>): Partial<EntityValues<M>> {
+    if (!properties) return {};
+    return Object.entries(properties)
+        .map(([key, property]) => {
+            const value = getDefaultValueFor(property as PropertyOrBuilder);
+            return value === undefined ? {} : { [key]: value };
+        })
+        .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
+}
+
+export function getDefaultValueFor(property: PropertyOrBuilder) {
+    if (isPropertyBuilder(property)) return undefined;
+    if (property.dataType === "map" && property.properties) {
+        const defaultValuesFor = getDefaultValuesFor(property.properties as Properties);
+        if (Object.keys(defaultValuesFor).length === 0) return undefined;
+        return defaultValuesFor;
+    } else if (property.defaultValue) {
+        return property.defaultValue;
+    } else {
+        return getDefaultValueForDataType(property.dataType);
+    }
+}
+
+export function getDefaultValueForDataType(dataType: DataType) {
+    if (dataType === "string") {
+        return null;
+    } else if (dataType === "number") {
+        return null;
+    } else if (dataType === "boolean") {
+        return false;
+    } else if (dataType === "date") {
+        return null;
+    } else if (dataType === "array") {
+        return [];
+    } else if (dataType === "map") {
+        return {};
+    } else {
+        return null;
+    }
+}
+
+/**
+ * Update the automatic values in an entity before save
+ * @group Datasource
+ */
+export function updateDateAutoValues<M extends Record<string, any>>({
+                                                                        inputValues,
+                                                                        properties,
+                                                                        status,
+                                                                        timestampNowValue,
+                                                                        setDateToMidnight
+                                                                    }:
+                                                                        {
+                                                                            inputValues: Partial<EntityValues<M>>,
+                                                                            properties: ResolvedProperties<M>,
+                                                                            status: EntityStatus,
+                                                                            timestampNowValue: any,
+                                                                            setDateToMidnight: (input?: any) => any | undefined
+                                                                        }): EntityValues<M> {
+    return traverseValuesProperties(
+        inputValues,
+        properties,
+        (inputValue, property) => {
+            if (property.dataType === "date") {
+                let resultDate;
+                if (status === "existing" && property.autoValue === "on_update") {
+                    resultDate = timestampNowValue;
+                } else if ((status === "new" || status === "copy") &&
+                    (property.autoValue === "on_update" || property.autoValue === "on_create")) {
+                    resultDate = timestampNowValue;
+                } else {
+                    resultDate = inputValue;
+                }
+                if (property.mode === "date")
+                    resultDate = setDateToMidnight(resultDate);
+                return resultDate;
+            } else {
+                return inputValue;
+            }
+        }
+    ) ?? {} as M;
+}
+
+/**
+ * Add missing required fields, expected in the collection, to the values of an entity
+ * @param values
+ * @param properties
+ * @group Datasource
+ */
+export function sanitizeData<M extends Record<string, any>>
+(
+    values: EntityValues<M>,
+    properties: ResolvedProperties<M>
+) {
+    const result: any = values;
+    Object.entries(properties)
+        .forEach(([key, property]) => {
+            if (values && values[key] !== undefined) result[key] = values[key];
+            else if ((property as Property).validation?.required) result[key] = null;
+        });
+    return result;
+}
+
+export function getReferenceFrom<M extends Record<string, any>>(entity: Entity<M>): EntityReference<M> {
+    return new EntityReference(entity.id, entity.path);
+}
+
+export function traverseValuesProperties<M extends Record<string, any>>(
+    inputValues: Partial<EntityValues<M>>,
+    properties: ResolvedProperties<M>,
+    operation: (value: any, property: Property) => any
+): EntityValues<M> | undefined {
+    const updatedValues = Object.entries(properties)
+        .map(([key, property]) => {
+            const inputValue = inputValues && (inputValues)[key];
+            const updatedValue = traverseValueProperty(inputValue, property as Property, operation);
+            if (updatedValue === undefined) return undefined;
+            return ({ [key]: updatedValue });
+        })
+        .reduce((a, b) => ({ ...a, ...b }), {}) as EntityValues<M>;
+    const result = { ...inputValues, ...updatedValues };
+    if (Object.keys(result).length === 0) return undefined;
+    return result;
+}
+
+export function traverseValueProperty(inputValue: any,
+                                      property: Property,
+                                      operation: (value: any, property: Property) => any): any {
+
+    let value;
+    if (property.dataType === "map" && property.properties) {
+        value = traverseValuesProperties(inputValue, property.properties as ResolvedProperties, operation);
+    } else if (property.dataType === "array") {
+        if (property.of && Array.isArray(inputValue)) {
+            value = inputValue.map((e) => traverseValueProperty(e, property.of as Property, operation));
+        } else if (property.oneOf && Array.isArray(inputValue)) {
+            const typeField = property.oneOf?.typeField ?? DEFAULT_ONE_OF_TYPE;
+            const valueField = property.oneOf?.valueField ?? DEFAULT_ONE_OF_VALUE;
+            value = inputValue.map((e) => {
+                if (e === null) return null;
+                if (typeof e !== "object") return e;
+                const type = e[typeField];
+                const childProperty = property.oneOf?.properties[type];
+                if (!type || !childProperty) return e;
+                return {
+                    [typeField]: type,
+                    [valueField]: traverseValueProperty(e[valueField], childProperty, operation)
+                };
+            });
+        } else {
+            value = inputValue;
+        }
+    } else {
+        value = operation(inputValue, property);
+    }
+
+    return value;
+}

package/src/util/enums.ts

@@ -0,0 +1,56 @@
+import { EnumValueConfig, EnumValues } from "../types";
+import { CHIP_COLORS, ChipColorScheme, getColorSchemeForSeed } from "@firecms/ui";
+
+export function enumToObjectEntries(enumValues: EnumValues): EnumValueConfig[] {
+    if (Array.isArray(enumValues)) {
+        return enumValues;
+    } else {
+        return Object.entries(enumValues).map(([id, value]) => {
+            if (typeof value === "string") {
+                return {
+                    id,
+                    label: value
+                }
+            } else {
+                return {
+                    ...value,
+                    id
+                }
+            }
+        });
+    }
+}
+
+export function getLabelOrConfigFrom(enumValues: EnumValueConfig[], key?: string | number): EnumValueConfig | undefined {
+    if (!key) return undefined;
+    return enumValues.find((entry) => String(entry.id) === String(key));
+}
+
+export function getColorScheme(enumValues: EnumValueConfig[], key: string | number): ChipColorScheme | undefined {
+    const labelOrConfig = getLabelOrConfigFrom(enumValues, key);
+    if (!labelOrConfig?.color)
+        return getColorSchemeForSeed(key.toString());
+    if (typeof labelOrConfig === "object" && "color" in labelOrConfig) {
+        if (typeof labelOrConfig.color === "string")
+            return CHIP_COLORS[labelOrConfig.color];
+        if (typeof labelOrConfig.color === "object")
+            return labelOrConfig.color;
+    }
+    return undefined;
+}
+
+export function isEnumValueDisabled(labelOrConfig?: string | EnumValueConfig) {
+    return typeof labelOrConfig === "object" && (labelOrConfig as EnumValueConfig).disabled;
+}
+
+export function buildEnumLabel(
+    labelOrConfig?: string | EnumValueConfig
+): string | undefined {
+    if (labelOrConfig === undefined)
+        return undefined;
+    if (typeof labelOrConfig === "object") {
+        return labelOrConfig.label;
+    } else {
+        return labelOrConfig;
+    }
+}

package/src/util/flatten_object.ts

@@ -0,0 +1,45 @@
+export function flattenObject(obj: any, parentKey = "") {
+    if (!obj) return obj;
+    return Object.keys(obj).reduce((flatObj, key) => {
+        const newKey = parentKey ? `${parentKey}.${key}` : key;
+
+        if (typeof obj[key] === "object" && obj[key] !== null) {
+            if (Array.isArray(obj[key])) {
+                obj[key].forEach((item: any, index: number) => {
+                    Object.assign(flatObj, flattenObject(item, `${newKey}[${index}]`));
+                });
+            } else {
+                Object.assign(flatObj, flattenObject(obj[key], newKey));
+            }
+        } else {
+            flatObj[newKey] = obj[key];
+        }
+
+        return flatObj;
+    }, {} as { [key: string]: any });
+}
+
+
+// map from nested property key like "a.b.c" to the maximum array count found in a list of objects for that array
+export type ArrayValuesCount = Record<string, number>;
+
+export function getArrayValuesCount(array: any[]): ArrayValuesCount {
+    return array.reduce((acc: ArrayValuesCount, obj: any) => {
+        Object.entries(obj).forEach(([key, value]) => {
+            // proceed only if value is an array
+            if (Array.isArray(value)) {
+                acc[key] = Math.max(acc[key] || 0, value.length);
+            }
+
+            // handle nested object
+            if (typeof value === "object" && value !== null) {
+                const nested = getArrayValuesCount([value]);
+                Object.entries(nested).forEach(([nestedKey, nestedCount]) => {
+                    const compoundKey = `${key}.${nestedKey}`;
+                    acc[compoundKey] = Math.max(acc[compoundKey] || 0, nestedCount);
+                });
+            }
+        });
+        return acc;
+    }, {});
+}

package/src/util/hash.ts

@@ -0,0 +1,11 @@
+export function hashString(str: string): number {
+    let hash = 0;
+    let i;
+    let chr;
+    for (i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return Math.abs(hash);
+}

package/src/util/icon_list.ts

@@ -0,0 +1,17 @@
+import { icon_synonyms } from "./icon_synonyms";
+import { iconKeys } from "@firecms/ui";
+
+// @ts-ignore
+import * as JsSearch from "js-search";
+
+export const iconsSearch = new JsSearch.Search("key");
+iconsSearch.addIndex("synonyms");
+
+iconsSearch.addDocuments(iconKeys
+    .map((importName) => {
+        return {
+            key: importName,
+            // @ts-ignore
+            synonyms: icon_synonyms[importName] ?? [],
+        }
+    }));