@firecms/core 3.0.0-canary.7 → 3.0.0-canary.70

package/src/util/icons.tsx

@@ -1,5 +1,4 @@
 import React from "react";
-import { CMSView, EntityCollection } from "../types";
 import { hashString } from "./hash";
 import { coolIconKeys, Icon, iconKeys } from "@firecms/ui";
 import { slugify } from "./strings";
@@ -14,8 +13,17 @@ export function getIcon(iconKey?: string, className?: string): React.ReactElemen
     return iconKey in iconKeysMap ? <Icon iconKey={iconKey} size={"medium"} className={className}/> : undefined;
 }
 
+export type IconViewProps = {
+    path: string;
+    name: string;
+    singularName?: string;
+    group?: string;
+    icon?: string;
+}
+
 export const IconForView = React.memo(
-    function IconForView({ collectionOrView, className }: { collectionOrView: EntityCollection | CMSView, className?: string }): React.ReactElement {
+    function IconForView({ collectionOrView, className }: { collectionOrView?: IconViewProps, className?: string }): React.ReactElement {
+        if (!collectionOrView) return <></>;
         const icon = getIcon(collectionOrView.icon, className);
         if (collectionOrView?.icon && icon)
             return icon;
@@ -39,7 +47,7 @@ export const IconForView = React.memo(
 
         return <Icon iconKey={key} size={"medium"} className={className}/>;
     }, (prevProps, nextProps) => {
-        return equal(prevProps.collectionOrView.icon, nextProps.collectionOrView.icon);
+        return equal(prevProps.collectionOrView?.icon, nextProps.collectionOrView?.icon);
     });
 
 const iconKeysMap: Record<string, string> = iconKeys.reduce((acc: Record<string, string>, key) => {

package/src/util/navigation_utils.ts

@@ -60,14 +60,14 @@ export function resolveCollectionPathIds(path: string, allCollections: EntityCol
 /**
  * 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 pathOrId
  * @param collections
  */
-export function getCollectionByPathOrId(pathOrAlias: string, collections: EntityCollection[]): EntityCollection | undefined {
+export function getCollectionByPathOrId(pathOrId: string, collections: EntityCollection[]): EntityCollection | undefined {
 
-    const subpaths = removeInitialAndTrailingSlashes(pathOrAlias).split("/");
+    const subpaths = removeInitialAndTrailingSlashes(pathOrId).split("/");
     if (subpaths.length % 2 === 0) {
-        throw Error(`getCollectionByPathOrAlias: Collection paths must have an odd number of segments: ${pathOrAlias}`);
+        throw Error(`getCollectionByPathOrId: Collection paths must have an odd number of segments: ${pathOrId}`);
     }
 
     const subpathCombinations = getCollectionPathsCombinations(subpaths);
@@ -80,10 +80,10 @@ export function getCollectionByPathOrId(pathOrAlias: string, collections: Entity
 
         if (navigationEntry) {
 
-            if (subpathCombination === pathOrAlias) {
+            if (subpathCombination === pathOrId) {
                 result = navigationEntry;
             } else if (navigationEntry.subcollections) {
-                const newPath = pathOrAlias.replace(subpathCombination, "").split("/").slice(2).join("/");
+                const newPath = pathOrId.replace(subpathCombination, "").split("/").slice(2).join("/");
                 if (newPath.length > 0)
                     result = getCollectionByPathOrId(newPath, navigationEntry.subcollections);
             }

package/src/util/objects.ts

@@ -12,38 +12,25 @@ export function isObject(item: any) {
     return item && typeof item === "object" && !Array.isArray(item);
 }
 
-export function mergeDeep<T extends object>(target: T, source: any): T {
+export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(target: T, source: U): T & U {
     const targetIsObject = isObject(target);
-    const output: T = targetIsObject ? { ...target } : target;
+    const output = targetIsObject ? { ...target } : target;
     if (targetIsObject && isObject(source)) {
         Object.keys(source).forEach(key => {
-            if (isObject(source[key])) {
+            const sourceElement = source[key];
+            if (isObject(sourceElement)) {
                 if (!(key in target))
-                    Object.assign(output, { [key]: source[key] });
+                    Object.assign(output, { [key]: sourceElement });
                 else
-                    (output as any)[key] = mergeDeep((target as any)[key], source[key]);
+                    (output as any)[key] = mergeDeep((target as any)[key], sourceElement);
             } else {
-                Object.assign(output, { [key]: source[key] });
+                Object.assign(output, { [key]: sourceElement });
             }
         });
     }
-    return output;
+    return output as T;
 }
 
-// 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") {

package/src/util/permissions.ts

@@ -1,4 +1,5 @@
 import { AuthController, Entity, EntityCollection, Permissions, User } from "../types";
+import { fullPathToCollectionSegments } from "./paths";
 
 const DEFAULT_PERMISSIONS = {
     read: true,
@@ -10,8 +11,8 @@ const DEFAULT_PERMISSIONS = {
 export function resolvePermissions<M extends Record<string, any>, UserType extends User>
 (collection: EntityCollection<M>,
  authController: AuthController<UserType>,
- pathSegments: string[],
- entity: Entity<M> | null): Permissions {
+ path: string,
+ entity: Entity<M> | null): Permissions | undefined {
 
     const permission = collection.permissions;
     if (permission === undefined) {
@@ -19,8 +20,10 @@ export function resolvePermissions<M extends Record<string, any>, UserType exten
     } else if (typeof permission === "object") {
         return permission as Permissions;
     } else if (typeof permission === "function") {
+        const pathSegments = fullPathToCollectionSegments(path);
         return permission({
             entity,
+            path,
             user: authController.user,
             authController,
             collection,
@@ -35,27 +38,28 @@ export function canEditEntity<M extends Record<string, any>, UserType extends Us
 (
     collection: EntityCollection<M>,
     authController: AuthController<UserType>,
-    paths: string[],
+    path: string,
     entity: Entity<M> | null): boolean {
-    return resolvePermissions(collection, authController, paths, entity).edit ?? DEFAULT_PERMISSIONS.edit;
+    return resolvePermissions(collection, authController, path, entity)?.edit ?? DEFAULT_PERMISSIONS.edit;
 }
 
 export function canCreateEntity<M extends Record<string, any>, UserType extends User>
 (
     collection: EntityCollection<M>,
     authController: AuthController<UserType>,
-    paths: string[],
+    path: string,
     entity: Entity<M> | null): boolean {
-    return resolvePermissions(collection, authController, paths, entity).create ?? DEFAULT_PERMISSIONS.create;
+    if (collection.collectionGroup) return false;
+    return resolvePermissions(collection, authController, path, entity)?.create ?? DEFAULT_PERMISSIONS.create;
 }
 
 export function canDeleteEntity<M extends Record<string, any>, UserType extends User>
 (
     collection: EntityCollection<M>,
     authController: AuthController<UserType>,
-    paths: string[],
+    path: string,
     entity: Entity<M> | null): boolean {
-    return resolvePermissions(collection, authController, paths, entity).delete ?? DEFAULT_PERMISSIONS.delete;
+    return resolvePermissions(collection, authController, path, entity)?.delete ?? DEFAULT_PERMISSIONS.delete;
 }
 
 // export function resolveCollectionsPermissions(roles: Role[]): Record<string, Permissions> {

package/src/util/references.ts

@@ -1,11 +1,12 @@
-import { EntityCollection, PropertyConfig } from "../types";
+import { EntityCollection, PropertyConfig, ResolvedEntityCollection } from "../types";
 import { isReferenceProperty } from "./property_utils";
 import { isPropertyBuilder } from "./entities";
+import { getFieldConfig } from "../core";
 
-export function getReferencePreviewKeys(targetCollection: EntityCollection<any>,
-                                        fields: Record<string, PropertyConfig>,
-                                        previewProperties?: string[],
-                                        limit = 3) {
+export function getEntityPreviewKeys(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) {
@@ -18,3 +19,33 @@ export function getReferencePreviewKeys(targetCollection: EntityCollection<any>,
         }).slice(0, limit);
     }
 }
+
+export function getEntityTitlePropertyKey<M extends Record<string, any>>(collection: EntityCollection<M>, propertyConfigs: Record<string, PropertyConfig<any>>): string | undefined {
+    if (collection.titleProperty) {
+        return collection.titleProperty as string;
+    }
+    // find first text field property
+    for (const key in collection.properties) {
+        const property = collection.properties[key];
+        if (!isPropertyBuilder(property)) {
+            const field = getFieldConfig(property, propertyConfigs);
+            if (field?.key === "text_field") {
+                return key;
+            }
+        }
+    }
+    return undefined;
+}
+
+export function getEntityImagePreviewPropertyKey<M extends object>(collection: ResolvedEntityCollection<M>): string | undefined {
+
+    // find first text field property
+    for (const key in collection.properties) {
+        const property = collection.properties[key];
+        if (property.dataType === "string" && property.storage?.acceptedFiles?.includes("image/*")) {
+            return key;
+        }
+
+    }
+    return undefined;
+}

package/src/util/resolutions.ts

@@ -26,7 +26,7 @@ import { getDefaultValuesFor, isPropertyBuilder } from "./entities";
 import { DEFAULT_ONE_OF_TYPE } from "./common";
 import { getIn } from "@firecms/formex";
 import { enumToObjectEntries } from "./enums";
-import { isDefaultFieldConfigId } from "../core";
+import { isDefaultFieldConfigId } from "../core/field_configs";
 
 // import util from "util";
 
@@ -38,7 +38,8 @@ export const resolveCollection = <M extends Record<string, any>, >
      values,
      previousValues,
      userConfigPersistence,
-     fields
+     fields,
+     ignoreMissingFields = false
  }: {
     collection: EntityCollection<M> | ResolvedEntityCollection<M>;
     path: string,
@@ -47,6 +48,7 @@ export const resolveCollection = <M extends Record<string, any>, >
     previousValues?: Partial<EntityValues<M>>,
     userConfigPersistence?: UserConfigurationPersistence;
     fields?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
 }): ResolvedEntityCollection<M> => {
 
     const collectionOverride = userConfigPersistence?.getCollectionConfig<M>(path);
@@ -58,16 +60,15 @@ export const resolveCollection = <M extends Record<string, any>, >
 
     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
+                fields,
+                ignoreMissingFields
             });
             if (!childResolvedProperty) return {};
             return ({
@@ -95,17 +96,15 @@ export const resolveCollection = <M extends Record<string, any>, >
  * 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,
+                                                                                                      ignoreMissingFields = false,
                                                                                                       ...props
                                                                                                   }: {
     propertyKey?: string,
     propertyOrBuilder: PropertyOrBuilder<T, M> | ResolvedProperty<T>,
-    propertyValue?: unknown,
     values?: Partial<M>,
     previousValues?: Partial<M>,
     path?: string,
@@ -113,6 +112,7 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
     index?: number,
     fromBuilder?: boolean;
     fields?: Record<string, PropertyConfig<any>>;
+    ignoreMissingFields?: boolean;
 }): ResolvedProperty<T> | null {
 
     if (typeof propertyOrBuilder === "object" && "resolved" in propertyOrBuilder) {
@@ -128,10 +128,11 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
         if (!path)
             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({
             ...props,
             path,
-            propertyValue,
+            propertyValue: usedPropertyValue,
             values: props.values ?? {},
             previousValues: props.previousValues ?? props.values ?? {}
         });
@@ -142,17 +143,17 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
 
         resolvedProperty = resolveProperty({
             ...props,
-            propertyValue,
             propertyOrBuilder: result,
-            fromBuilder: true
+            fromBuilder: true,
+            ignoreMissingFields
         });
     } else {
         const property = propertyOrBuilder as Property<T>;
         if (property.dataType === "map" && property.properties) {
             const properties = resolveProperties({
+                ignoreMissingFields,
                 ...props,
                 properties: property.properties,
-                propertyValue
             });
             resolvedProperty = {
                 ...property,
@@ -163,8 +164,8 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
         } else if (property.dataType === "array") {
             resolvedProperty = resolveArrayProperty({
                 property,
-                propertyValue,
                 fromBuilder,
+                ignoreMissingFields,
                 ...props
             }) as ResolvedProperty<any>;
         } else if ((property.dataType === "string" || property.dataType === "number") && property.enumValues) {
@@ -182,12 +183,12 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
 
     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`);
+        if (!cmsFields && !ignoreMissingFields) {
+            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];
+        const customField: PropertyConfig | undefined = 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(`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;
         }
@@ -198,7 +199,7 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
             }
             const customFieldProperty = resolveProperty<any>({
                 propertyOrBuilder: configPropertyOrBuilder,
-                propertyValue,
+                ignoreMissingFields,
                 ...props
             });
             if (customFieldProperty) {
@@ -219,12 +220,11 @@ export function resolveProperty<T extends CMSType = CMSType, M extends Record<st
 export function resolveArrayProperty<T extends any[], M>({
                                                              propertyKey,
                                                              property,
-                                                             propertyValue,
+                                                             ignoreMissingFields = false,
                                                              ...props
                                                          }: {
     propertyKey?: string,
     property: ArrayProperty<T> | ResolvedArrayProperty<T>,
-    propertyValue: any,
     values?: Partial<M>,
     previousValues?: Partial<M>,
     path?: string,
@@ -232,7 +232,9 @@ export function resolveArrayProperty<T extends any[], M>({
     index?: number,
     fromBuilder?: boolean;
     fields?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
 }): ResolvedArrayProperty {
+    const propertyValue = propertyKey ? getIn(props.values, propertyKey) : undefined;
 
     if (property.of) {
         if (Array.isArray(property.of)) {
@@ -244,7 +246,7 @@ export function resolveArrayProperty<T extends any[], M>({
                     return resolveProperty({
                         propertyKey: `${propertyKey}.${index}`,
                         propertyOrBuilder: p as Property<any>,
-                        propertyValue: Array.isArray(propertyValue) ? propertyValue[index] : undefined,
+                        ignoreMissingFields,
                         ...props,
                         index
                     });
@@ -256,7 +258,7 @@ export function resolveArrayProperty<T extends any[], M>({
                 ? propertyValue.map((v: any, index: number) => resolveProperty({
                     propertyKey: `${propertyKey}.${index}`,
                     propertyOrBuilder: of,
-                    propertyValue: v,
+                    ignoreMissingFields,
                     ...props,
                     index
                 })).filter(e => Boolean(e)) as ResolvedProperty[]
@@ -264,10 +266,10 @@ export function resolveArrayProperty<T extends any[], M>({
             const ofProperty = resolveProperty({
                 propertyKey: `${propertyKey}`,
                 propertyOrBuilder: of,
-                propertyValue: undefined,
+                ignoreMissingFields,
                 ...props
             });
-            if (!ofProperty)
+            if (!ofProperty && !ignoreMissingFields)
                 throw Error("When using a property builder as the 'of' prop of an ArrayProperty, you must return a valid child property")
             return {
                 ...property,
@@ -287,14 +289,14 @@ export function resolveArrayProperty<T extends any[], M>({
                 return resolveProperty({
                     propertyKey: `${propertyKey}.${index}`,
                     propertyOrBuilder: childProperty,
-                    propertyValue,
+                    ignoreMissingFields,
                     ...props
                 });
             }).filter(e => Boolean(e)) as ResolvedProperty[]
             : [];
         const properties = resolveProperties<any>({
             properties: property.oneOf.properties,
-            propertyValue: undefined,
+            ignoreMissingFields,
             ...props
         });
         return {
@@ -326,11 +328,10 @@ export function resolveArrayProperty<T extends any[], M>({
  */
 export function resolveProperties<M extends Record<string, any>>({
                                                                      properties,
-                                                                     propertyValue,
+                                                                     ignoreMissingFields,
                                                                      ...props
                                                                  }: {
     properties: PropertiesOrBuilders<M>,
-    propertyValue: unknown,
     values?: Partial<M>,
     previousValues?: Partial<M>,
     path?: string,
@@ -338,14 +339,14 @@ export function resolveProperties<M extends Record<string, any>>({
     index?: number,
     fromBuilder?: boolean;
     fields?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
 }): 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,
+                ignoreMissingFields,
                 ...props
             });
             if (!childResolvedProperty) return {};
@@ -367,7 +368,7 @@ export function resolvePropertyEnum(property: StringProperty | NumberProperty, f
         return {
             ...property,
             resolved: true,
-            enumValues: enumToObjectEntries(property.enumValues)?.filter((value) => value && value.id && value.label) ?? [],
+            enumValues: enumToObjectEntries(property.enumValues)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? [],
             fromBuilder: fromBuilder ?? false
         }
     }

package/src/util/storage.ts

@@ -7,15 +7,28 @@ import {
 } from "../types";
 import { randomString } from "./strings";
 
+interface ResolveFilenameStringParams<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;
+}
+
 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> {
+    {
+        input,
+        storage,
+        values,
+        entityId,
+        path,
+        property,
+        file,
+        propertyKey
+    }: ResolveFilenameStringParams<M>): Promise<string> {
     let result;
     if (typeof input === "function") {
         result = await input({
@@ -30,7 +43,13 @@ export async function resolveFilenameString<M extends object>(
         if (!result)
             console.warn("Storage callback returned empty result. Using default name value")
     } else {
-        result = replacePlaceholders(file, input, entityId, propertyKey, path);
+        result = replacePlaceholders({
+            file,
+            input,
+            entityId,
+            propertyKey,
+            path
+        });
     }
 
     if (!result)
@@ -39,15 +58,28 @@ export async function resolveFilenameString<M extends object>(
     return result;
 }
 
+interface ResolveStoragePathStringParams<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;
+}
+
 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 {
+    {
+        input,
+        storage,
+        values,
+        entityId,
+        path,
+        property,
+        file,
+        propertyKey
+    }: ResolveStoragePathStringParams<M>): string {
     let result;
     if (typeof input === "function") {
         result = input({
@@ -62,7 +94,13 @@ export function resolveStoragePathString<M extends object>(
         if (!result)
             console.warn("Storage callback returned empty result. Using default name value")
     } else {
-        result = replacePlaceholders(file, input, entityId, propertyKey, path);
+        result = replacePlaceholders({
+            file,
+            input,
+            entityId,
+            propertyKey,
+            path
+        });
     }
 
     if (!result)
@@ -71,14 +109,30 @@ export function resolveStoragePathString<M extends object>(
     return result;
 }
 
-function replacePlaceholders(file: File, input: string, entityId: string, propertyKey: string, path: string) {
+interface Placeholders {
+    file: File;
+    input: string;
+    entityId: string;
+    propertyKey: string;
+    path?: string;
+}
+
+function replacePlaceholders({
+                                 file,
+                                 input,
+                                 entityId,
+                                 propertyKey,
+                                 path
+                             }: Placeholders) {
     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);
+        .replace("{file.type}", file.type);
+    if (path) {
+        result = result.replace("{path}", path);
+    }
     if (ext) {
         result = result.replace("{file.ext}", ext);
         const name = file.name.replace(`.${ext}`, "");

package/src/util/strings.ts

@@ -56,8 +56,8 @@ export function unslugify(slug?: string): string {
         const result = slug.replace(/[-_]/g, " ");
         return result.replace(/\w\S*/g, function (txt) {
             return txt.charAt(0).toUpperCase() + txt.substr(1);
-        });
+        }).trim();
     } else {
-        return slug;
+        return slug.trim();
     }
 }