@rebasepro/cms 0.0.1-canary.4d4fb3e

package/src/util/navigation_utils.ts

@@ -0,0 +1,223 @@
+import { EntityCollection } from "@rebasepro/types";
+import type { UrlController, SideEntityController } from "@rebasepro/types";
+import { getSubcollections } from "@rebasepro/common";
+
+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 {
+    let remainingPath = removeInitialAndTrailingSlashes(path);
+    if (!remainingPath) {
+        return "";
+    }
+
+    let currentCollections: EntityCollection[] | undefined = allCollections;
+    const resolvedPathParts: string[] = [];
+
+    while (remainingPath.length > 0) {
+        if (!currentCollections || currentCollections.length === 0) {
+            // We have remaining path segments but no more collections to match against
+            console.warn(`resolveCollectionPathIds: Path structure implies subcollections, but none found before segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+            resolvedPathParts.push(remainingPath);
+            remainingPath = ""; // Stop processing
+            break;
+        }
+
+        let foundMatch = false;
+        // Sort potential matches by length descending to prioritize longer matches (e.g., "a/b" over "a")
+        const potentialMatches: { col: EntityCollection; match: string; }[] = currentCollections
+            .flatMap(col => [{
+                col,
+                match: col.slug
+            }])
+            .filter(p => p.match && remainingPath.startsWith(p.match))
+            .sort((a, b) => b.match.length - a.match.length);
+
+        if (potentialMatches.length > 0) {
+            const {
+                col: foundCollection,
+                match: matchString
+            } = potentialMatches[0];
+
+            resolvedPathParts.push(foundCollection.slug); // Use the defined path
+            remainingPath = removeInitialSlash(remainingPath.substring(matchString.length));
+
+            // Check if we are at the end of the path
+            if (remainingPath.length === 0) {
+                foundMatch = true;
+                break; // Path ends with a collection segment
+            }
+
+            // The next segment must be an entity ID
+            const idSeparatorIndex = remainingPath.indexOf("/");
+            let entityId: string | number;
+            if (idSeparatorIndex > -1) {
+                entityId = remainingPath.substring(0, idSeparatorIndex);
+                remainingPath = remainingPath.substring(idSeparatorIndex + 1);
+            } else {
+                // This should not happen if the original path is valid (odd segments)
+                // but handle it defensively: assume the rest is the ID
+                entityId = remainingPath;
+                remainingPath = "";
+                console.warn(`resolveCollectionPathIds: Path seems to end with an entity ID "${entityId}" instead of a collection segment in original path "${path}". This might indicate an invalid input path.`);
+                // Even if it ends here, we still need to push the ID
+            }
+
+            resolvedPathParts.push(entityId); // Append entity ID
+            currentCollections = getSubcollections(foundCollection); // Move to subcollections
+            foundMatch = true;
+
+            if (!currentCollections && remainingPath.length > 0) {
+                // Warn if the path continues but no subcollections were defined
+                console.warn(`resolveCollectionPathIds: Path continues after entity ID "${entityId}", but no subcollections are defined for the preceding collection "${foundCollection.slug}" in path "${path}". Appending remaining original path.`);
+                resolvedPathParts.push(remainingPath); // Append the rest
+                remainingPath = ""; // Stop processing
+                break;
+            }
+
+        }
+
+        if (!foundMatch) {
+            // Collection definition not found for the start of the remaining path
+            console.warn(`resolveCollectionPathIds: Collection definition not found for segment starting with "${remainingPath}" in original path "${path}". Appending remaining original path.`);
+            resolvedPathParts.push(remainingPath); // Append the rest
+            remainingPath = ""; // Stop processing
+            break;
+        }
+    }
+
+    return resolvedPathParts.join("/");
+}
+
+/**
+ * Find the corresponding view at any depth for a given path.
+ * Note that path or segments of the paths can be collection aliases.
+ * @param slugOrPath
+ * @param collections
+ */
+export function getCollectionBySlugWithin(slugOrPath: string, collections: EntityCollection[]): EntityCollection | undefined {
+
+    const subpaths = removeInitialAndTrailingSlashes(slugOrPath).split("/");
+    if (subpaths.length % 2 === 0) {
+        throw Error(`getCollectionBySlug: Collection paths must have an odd number of segments: ${slugOrPath}`);
+    }
+
+    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.slug ?? "").localeCompare(b.slug ?? ""))
+            .find((entry) => entry.slug === subpathCombination);
+
+        if (navigationEntry) {
+
+            if (subpathCombination === slugOrPath) {
+                result = navigationEntry;
+            } else if (getSubcollections(navigationEntry).length > 0) {
+                const newPath = slugOrPath.replace(subpathCombination, "").split("/").slice(2).join("/");
+                if (newPath.length > 0)
+                    result = getCollectionBySlugWithin(newPath, getSubcollections(navigationEntry));
+            }
+        }
+        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;
+
+}
+
+export function navigateToEntity({
+    openEntityMode,
+    collection,
+    entityId,
+    copy,
+    path,
+    selectedTab,
+    sideEntityController,
+    onClose,
+    navigation
+}:
+
+    {
+        openEntityMode: "side_panel" | "full_screen";
+        collection?: EntityCollection;
+        entityId?: string | number;
+        selectedTab?: string;
+        copy?: boolean;
+        path: string;
+        sideEntityController: SideEntityController;
+        onClose?: () => void;
+        navigation: UrlController
+    }) {
+
+    if (openEntityMode === "side_panel") {
+
+        sideEntityController.open({
+            entityId,
+            path: path,
+            copy,
+            selectedTab,
+            collection,
+            updateUrl: true,
+            onClose
+        });
+
+    } else {
+        let to = navigation.buildUrlCollectionPath(entityId ? `${path ?? path}/${entityId}` : path ?? path);
+        if (entityId && selectedTab) {
+            to += `/${selectedTab}`;
+        }
+        if (!entityId) {
+            to += "#new";
+        }
+        if (copy) {
+            to += "#copy";
+        }
+        navigation.navigate(to);
+    }
+
+}

package/src/util/previews.ts

@@ -0,0 +1,50 @@
+import type { EntityCollection, Property, PropertyConfig } from "@rebasepro/types";
+import { AuthController } from "@rebasepro/types";
+import { isPropertyBuilder } from "@rebasepro/common";
+import { isReferenceProperty, isRelationProperty } from "./property_utils";
+
+export function getEntityPreviewKeys(
+    authController: AuthController,
+    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 && targetCollection.previewProperties) {
+        listProperties = targetCollection.previewProperties?.filter(p => allProperties.includes(p as string));
+    }
+    if (listProperties && listProperties.length > 0) {
+        return listProperties;
+    } else {
+        listProperties = allProperties;
+        return listProperties
+            .filter(key => {
+                const prop = targetCollection.properties[key];
+                const isIdProp = prop && typeof prop === "object" && "isId" in prop && Boolean((prop as unknown as { isId?: boolean }).isId);
+                return !isIdProp && key !== "id";
+            })
+            .filter(key => {
+                const property = targetCollection.properties[key];
+                return property && !isPropertyBuilder(property) && !isReferenceProperty(property) && !isRelationProperty(property);
+            }).slice(0, limit);
+    }
+}
+
+export function getEntityTitlePropertyKey<M extends Record<string, unknown>>(collection: EntityCollection<M>, propertyConfigs: Record<string, PropertyConfig>): 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 prop = property as Property;
+            if (prop.type === "string" && !prop.multiline && !prop.markdown && !prop.storage && !prop.isId) {
+                return key;
+            }
+        }
+    }
+    return undefined;
+}
+

package/src/util/property_utils.tsx

@@ -0,0 +1,215 @@
+import type { Properties } from "@rebasepro/types";
+import type { EntityCollection, MapProperty, Property, PropertyConfig } from "@rebasepro/types";
+import React from "react";
+
+import { isPropertyBuilder } from "@rebasepro/common";
+import {
+    AddLinkIcon,
+    BallotIcon,
+    CircleIcon,
+    FlagIcon,
+    FunctionsIcon,
+    HttpIcon,
+    LinkIcon,
+    MailIcon,
+    NumbersIcon,
+    RepeatIcon,
+    ScheduleIcon,
+    ShortTextIcon,
+    SubjectIcon,
+    UploadFileIcon,
+    ViewStreamIcon
+} from "@rebasepro/ui";
+
+export function isReferenceProperty(property: Property) {
+
+    if (!property) return null;
+    if (property.type === "reference") {
+        return true;
+    }
+    if (property.type === "array") {
+        if (Array.isArray(property.of)) return false;
+        else return property.of?.type === "reference"
+    }
+    return false;
+}
+
+export function isRelationProperty(property: Property) {
+    if (!property) return null;
+    if (property.type === "relation") {
+        return true;
+    }
+    if (property.type === "array") {
+        if (Array.isArray(property.of)) return false;
+        else return property.of?.type === "relation"
+    }
+    return false;
+}
+
+export function getIconForWidget(widget: PropertyConfig | undefined,
+    size: "smallest" | "small" | "medium" | "large" | number) {
+    const Icon = widget?.Icon ?? CircleIcon;
+    return <Icon size={size} />;
+}
+
+/**
+ * Returns a default icon component based on property type.
+ * This provides a sensible fallback when no PropertyConfig is available.
+ */
+function getDefaultIconForProperty(property: Property): React.ComponentType<{ size: "smallest" | "small" | "medium" | "large" | number }> {
+    switch (property.type) {
+        case "string": {
+            if (property.storage) return UploadFileIcon;
+            if (property.url) return HttpIcon;
+            if (property.email) return MailIcon;
+            if (property.multiline || property.markdown) return SubjectIcon;
+            if (property.reference) return LinkIcon;
+            return ShortTextIcon;
+        }
+        case "number":
+            return NumbersIcon;
+        case "boolean":
+            return FlagIcon;
+        case "date":
+            return ScheduleIcon;
+        case "map":
+            return BallotIcon;
+        case "array": {
+            const of = property.of;
+            const oneOf = property.oneOf;
+            if (oneOf) return ViewStreamIcon;
+            if (of && !Array.isArray(of)) {
+                if (of.type === "reference") return AddLinkIcon;
+                if (of.type === "string" && of.storage) return UploadFileIcon;
+            }
+            return RepeatIcon;
+        }
+        case "reference":
+            return LinkIcon;
+        case "relation":
+            return AddLinkIcon;
+        default:
+            return CircleIcon;
+    }
+}
+
+export function getIconForProperty(
+    property: Property,
+    size: "smallest" | "small" | "medium" | "large" | number = "small",
+    fields: Record<string, PropertyConfig> = {}
+): React.ReactNode {
+    if (isPropertyBuilder(property)) {
+        return <FunctionsIcon size={size} />;
+    }
+
+    // Try to look up a custom PropertyConfig icon first
+    const configId = property.propertyConfig || undefined;
+    const widget = configId ? fields[configId] : undefined;
+    if (widget?.Icon) {
+        return getIconForWidget(widget, size);
+    }
+
+    // Fall back to a type-based default icon
+    const Icon = getDefaultIconForProperty(property);
+    return <Icon size={size} />;
+}
+
+/**
+ * Get a property in a property tree from a path like
+ * `address.street`
+ * @param properties
+ * @param path
+ */
+export function getPropertyInPath(properties: Properties, path: string): Property | undefined {
+    if (typeof properties === "object") {
+        if (path in properties) {
+            return (properties as Record<string, Property>)[path];
+        }
+        if (path.includes(".")) {
+            const pathSegments = path.split(".");
+            const childProperty = (properties as Record<string, Property>)[pathSegments[0]];
+            if (typeof childProperty === "object" && childProperty.type === "map" && childProperty.properties) {
+                return getPropertyInPath(childProperty.properties, pathSegments.slice(1).join("."))
+            }
+        }
+    }
+    return undefined;
+}
+
+export function getResolvedPropertyInPath(properties: Record<string, Property>, path: string): Property | 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.type === "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 sorted by their order, but include ALL properties.
+ * Nested keys (like "data.mode") in propertiesOrder are ignored - they're for column ordering.
+ * @param properties
+ * @param propertiesOrder
+ */
+export function getPropertiesWithPropertiesOrder(properties: Properties, propertiesOrder?: string[]): Properties {
+    if (!propertiesOrder) return properties;
+
+    const propertyKeys = Object.keys(properties);
+
+    // Filter propertiesOrder to only include top-level keys (no dots) that exist
+    const validOrderKeys = (propertiesOrder as string[]).filter(
+        key => !key.includes(".") && properties[key]
+    );
+
+    const result: Properties = {};
+
+    // First add properties in the specified order
+    validOrderKeys.forEach(key => {
+        const property = properties[key];
+        if (typeof property === "object" && property.type === "map" && (property as MapProperty).properties) {
+            const mapProp = property as MapProperty;
+            result[key] = {
+                ...mapProp,
+                properties: getPropertiesWithPropertiesOrder(mapProp.properties!, mapProp.propertiesOrder ?? [])
+            } as Property;
+        } else if (property) {
+            result[key] = property;
+        }
+    });
+
+    // Then add any missing properties (so they don't disappear!)
+    propertyKeys.forEach(key => {
+        if (!result[key]) {
+            const property = properties[key];
+            if (typeof property === "object" && property.type === "map" && (property as MapProperty).properties) {
+                const mapProp = property as MapProperty;
+                result[key] = {
+                    ...mapProp,
+                    properties: getPropertiesWithPropertiesOrder(mapProp.properties!, mapProp.propertiesOrder ?? [])
+                } as Property;
+            } else if (property) {
+                result[key] = property;
+            }
+        }
+    });
+
+    return result;
+}
+
+export function getDefaultPropertiesOrder(collection: EntityCollection): string[] {
+    if (collection.propertiesOrder) return collection.propertiesOrder;
+    return [...Object.keys(collection.properties), ...(collection.additionalFields ?? []).map(field => field.key)];
+}

package/src/util/resolutions.ts

@@ -0,0 +1,69 @@
+import React from "react";
+import type { EntityCustomView, EntityCollection } from "@rebasepro/types";
+import type { CustomizationController, EntityAction } from "@rebasepro/types";
+import { EntityHistoryView } from "../components/history";
+import { HistoryIcon } from "@rebasepro/ui";
+
+/**
+ * Built-in entity views that are resolved by token name.
+ * These are always available without needing to be registered
+ * in the customization controller's entityViews array.
+ */
+const BUILTIN_ENTITY_VIEWS: Record<string, EntityCustomView> = {
+    "__rebase_history": {
+        key: "__rebase_history",
+        name: "History",
+        tabComponent: React.createElement(HistoryIcon, { size: "small" }),
+        Builder: EntityHistoryView,
+        position: "end"
+    }
+};
+
+export function resolveEntityView(
+    entityView: string | EntityCustomView<any>,
+    contextEntityViews?: EntityCustomView<any>[]
+): EntityCustomView<any> | undefined {
+    if (typeof entityView === "string") {
+        // Check built-in views first, then user-registered views
+        return BUILTIN_ENTITY_VIEWS[entityView]
+            ?? contextEntityViews?.find((entry) => entry.key === entityView);
+    } else {
+        return entityView;
+    }
+}
+
+export function resolveEntityAction<M extends Record<string, unknown>>(
+    entityAction: string | EntityAction<M>,
+    contextEntityActions?: EntityAction<M>[]
+): EntityAction<M> | undefined {
+    if (typeof entityAction === "string") {
+        return contextEntityActions?.find((entry) => entry.key === entityAction);
+    } else {
+        return entityAction;
+    }
+}
+
+export function resolvedSelectedEntityView<M extends Record<string, unknown>>(
+    customViews: (string | EntityCustomView<M>)[] | undefined,
+    customizationController: CustomizationController,
+    selectedTab?: string,
+    _canEdit?: boolean
+) {
+    const resolvedEntityViews = customViews
+        ? customViews
+              .map((e) => resolveEntityView(e, (customizationController as unknown as { entityViews?: EntityCustomView[] }).entityViews))
+              .filter(Boolean) as EntityCustomView[]
+        : [];
+
+    const selectedEntityView = resolvedEntityViews.find((e) => e.key === selectedTab);
+    const selectedSecondaryForm =
+        customViews &&
+        resolvedEntityViews
+            .filter((e) => e.includeActions)
+            .find((e) => e.key === selectedTab);
+    return {
+        resolvedEntityViews,
+        selectedEntityView,
+        selectedSecondaryForm,
+    };
+}