@rebasepro/cms 0.17.3 → 0.18.0

package/src/util/previews.ts

@@ -1,131 +0,0 @@
-import type { Property } from "@rebasepro/types";
-import type { AdminCollection } from "@rebasepro/cms-types";
-import { getTitlePropertyKey, getTitlePropertyKeyForValues } from "@rebasepro/app";
-import { isPropertyBuilder } from "@rebasepro/common";
-
-/**
- * Which properties fill a preview surface, best first.
- *
- * The implementation lives in `@rebasepro/app` so that the admin package and
- * the app package cannot disagree about what a record looks like in a card —
- * they had drifted, and only one of the two copies had learned to keep
- * relations out of the list.
- */
-export { getEntityPreviewKeys } from "@rebasepro/app";
-
-/**
- * The property that fills the title slot for a collection.
- *
- * Ranking lives in `@rebasepro/common` so every surface (list rows, cards,
- * board cards, detail header, relation chips) agrees on what an entity is
- * called. Identifiers are excluded from the property *schema* — primary keys,
- * foreign keys, UUID columns — not from the key name.
- */
-export function getEntityTitlePropertyKey<M extends Record<string, unknown>>(
-    collection: AdminCollection<M>
-): string | undefined {
-    return getTitlePropertyKey(collection);
-}
-
-/**
- * Same as {@link getEntityTitlePropertyKey}, but skips candidates that carry
- * no readable value for this particular entity (empty, or an opaque id).
- */
-export function getEntityTitlePropertyKeyForEntity<M extends Record<string, unknown>>(
-    collection: AdminCollection<M>,
-    values: Record<string, unknown> | undefined,
-    entityId?: string | number
-): string | undefined {
-    return getTitlePropertyKeyForValues(collection, values, entityId);
-}
-
-/**
- * True when a property key points at a user picker, whose stored value is an
- * auth user id that has to be resolved before it can be displayed.
- */
-export function isUserSelectProperty<M extends Record<string, unknown>>(
-    collection: AdminCollection<M>,
-    propertyKey: string | undefined
-): boolean {
-    if (!propertyKey) return false;
-    const property = collection.properties[propertyKey];
-    if (!property || isPropertyBuilder(property)) return false;
-    const prop = property as Property;
-    return prop.type === "string" && Boolean(prop.userSelect);
-}
-
-/**
- * Attempt to turn a title value (which might be a relation, reference, date, array, or other complex object)
- * into a renderable, human-readable string.
- */
-export function resolveTitleToString(title: any): string {
-    if (title === null || title === undefined) {
-        return "";
-    }
-
-    if (typeof title !== "object") {
-        return String(title);
-    }
-
-    // Check if it's a relation shape: { __type: "relation", id, path, data }
-    if ("__type" in title && title.__type === "relation") {
-        if (title.data && title.data.values) {
-            const values = title.data.values;
-            // Prioritize common title fields in eagerly loaded relation data
-            for (const key of ["name", "title", "label", "displayName"]) {
-                if (values[key] !== undefined && values[key] !== null) {
-                    return String(values[key]);
-                }
-            }
-            // Fallback: search for first short string value in values
-            for (const val of Object.values(values)) {
-                if (typeof val === "string" && val.length > 0 && val.length < 200) {
-                    return val;
-                }
-            }
-        }
-        if (title.id !== undefined && title.id !== null) {
-            return String(title.id);
-        }
-    }
-
-    // Check if it's a reference shape: { isEntityReference() } or similar
-    if ("isEntityReference" in title && typeof title.isEntityReference === "function" && title.isEntityReference()) {
-        return String(title.id);
-    }
-    if ("id" in title && "path" in title && !("__type" in title)) {
-        // Flat reference/relation-like object
-        return String(title.id);
-    }
-
-    // Check if it's a Date
-    if (title instanceof Date) {
-        return title.toLocaleDateString();
-    }
-
-    // Check if it has a string/number property like name/title/label/id
-    if ("name" in title && title.name !== undefined && title.name !== null && typeof title.name !== "object") {
-        return String(title.name);
-    }
-    if ("title" in title && title.title !== undefined && title.title !== null && typeof title.title !== "object") {
-        return String(title.title);
-    }
-    if ("label" in title && title.label !== undefined && title.label !== null && typeof title.label !== "object") {
-        return String(title.label);
-    }
-    if ("id" in title && title.id !== undefined && title.id !== null && typeof title.id !== "object") {
-        return String(title.id);
-    }
-
-    // Fallback: try converting to string, or JSON.stringify if it looks like a generic object
-    try {
-        const str = String(title);
-        if (str !== "[object Object]") {
-            return str;
-        }
-        return JSON.stringify(title);
-    } catch {
-        return "";
-    }
-}
-

package/src/util/propertyConfigMapper.ts

@@ -1,134 +0,0 @@
-/**
- * Maps a Rebase `Property` (from @rebasepro/types) to a `CollectionPropertyConfig`
- * (from @rebasepro/ui), stripping all entity-specific fields and keeping only
- * the UI-relevant subset.
- *
- * This is the bridge between the entity-aware and headless layers.
- */
-
-import type { Property, Properties, EnumValues, EnumValueConfig } from "@rebasepro/types";
-import type { CollectionPropertyConfig, CollectionEnumValueConfig } from "@rebasepro/ui";
-
-/**
- * Map Rebase property types to headless-supported types.
- * `vector` and `binary` are not directly renderable, so we fall back to `string`.
- */
-const TYPE_MAP: Record<string, CollectionPropertyConfig["type"]> = {
-    string: "string",
-    number: "number",
-    boolean: "boolean",
-    date: "date",
-    geopoint: "geopoint",
-    reference: "reference",
-    relation: "relation",
-    array: "array",
-    map: "map",
-    vector: "string",   // vectors display as text
-    binary: "string",   // binary displays as text
-};
-
-/**
- * Convert a single Property to a CollectionPropertyConfig.
- */
-export function mapPropertyToConfig(property: Property): CollectionPropertyConfig {
-    const base: CollectionPropertyConfig = {
-        type: TYPE_MAP[property.type] ?? "string",
-        name: property.name,
-        description: property.description,
-        columnWidth: property.admin?.columnWidth,
-        hideFromCollection: property.admin?.hideFromCollection,
-    };
-
-    // String-specific
-    if (property.type === "string") {
-        if (property.enum) {
-            base.enum = mapEnumValues(property.enum);
-        }
-        if (property.admin?.multiline) base.multiline = true;
-        if (property.admin?.previewAsTag) base.previewAsTag = true;
-        if (property.admin?.urlPreview) base.url = property.admin.urlPreview;
-        if (property.admin?.markdown) base.markdown = true;
-        if (property.storage) base.storage = true;
-        if (property.email) base.email = true;
-    }
-
-    // Number-specific
-    if (property.type === "number" && property.enum) {
-        base.enum = mapEnumValues(property.enum);
-    }
-
-    // Array-specific
-    if (property.type === "array" && property.of && !Array.isArray(property.of)) {
-        base.of = mapPropertyToConfig(property.of);
-    }
-
-    // Map-specific
-    if (property.type === "map" && property.properties) {
-        base.properties = mapPropertiesToConfigs(property.properties);
-        if (property.propertiesOrder) {
-            base.propertiesOrder = property.propertiesOrder;
-        }
-    }
-
-    // Date-specific
-    if (property.type === "date" && property.mode) {
-        base.mode = property.mode;
-    }
-
-    // Custom preview component
-    if (property.admin?.Preview) {
-        // The connected wrapper will handle this by injecting via cellRenderer override
-        // We don't copy it here because Preview may reference entity-aware components
-    }
-
-    return base;
-}
-
-/**
- * Convert a Properties record to a CollectionPropertyConfig record.
- */
-export function mapPropertiesToConfigs(
-    properties: Properties
-): Record<string, CollectionPropertyConfig> {
-    const result: Record<string, CollectionPropertyConfig> = {};
-    for (const [key, property] of Object.entries(properties)) {
-        result[key] = mapPropertyToConfig(property);
-    }
-    return result;
-}
-
-/**
- * Convert Rebase EnumValues to CollectionEnumValueConfig format.
- * Handles both array form (EnumValueConfig[]) and record form.
- */
-function mapEnumValues(
-    enumValues: EnumValues | undefined
-): Record<string, CollectionEnumValueConfig> | Map<string | number, CollectionEnumValueConfig> | undefined {
-    if (!enumValues) return undefined;
-
-    // Array form: EnumValueConfig[]
-    if (Array.isArray(enumValues)) {
-        const result: Record<string, CollectionEnumValueConfig> = {};
-        for (const item of enumValues) {
-            result[String(item.id)] = normalizeEnumValueConfig(item);
-        }
-        return result;
-    }
-
-    // Record form: Record<string | number, string | EnumValueConfig>
-    const result: Record<string, CollectionEnumValueConfig> = {};
-    for (const [key, value] of Object.entries(enumValues)) {
-        result[key] = typeof value === "string"
-            ? value
-            : normalizeEnumValueConfig(value);
-    }
-    return result;
-}
-
-function normalizeEnumValueConfig(config: EnumValueConfig): CollectionEnumValueConfig {
-    return {
-        label: config.label,
-        color: typeof config.color === "string" ? config.color : undefined,
-        disabled: config.disabled,
-    };
-}

package/src/util/property_utils.tsx

@@ -1,236 +0,0 @@
-
-import type { Properties } from "@rebasepro/types";
-import type { MapProperty, Property } from "@rebasepro/types";
-import type { PropertyConfig, AdminCollection } from "@rebasepro/cms-types";
-import React from "react";
-
-import { isPropertyBuilder } from "@rebasepro/common";
-import {
-    AlignLeftIcon,
-    CalendarIcon,
-    CircleIcon,
-    FlagIcon,
-    FunctionSquareIcon,
-    GlobeIcon,
-    HashIcon,
-    iconSize,
-    LinkIcon,
-    MailIcon,
-    RepeatIcon,
-    Rows3Icon,
-    TextIcon,
-    UploadIcon,
-    VoteIcon
-} from "@rebasepro/ui";
-import type { IconSize, LucideIcon } from "@rebasepro/ui";
-
-/**
- * Resolve a size value (string token or number) to a numeric pixel value
- * suitable for passing to Lucide icons.
- */
-function resolveSize(size: IconSize | number): number {
-    if (typeof size === "number") return size;
-    return iconSize[size];
-}
-
-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: IconSize | number) {
-    const Icon = widget?.Icon ?? CircleIcon;
-    const px = resolveSize(size);
-    return <Icon size={px}/>;
-}
-
-/**
- * Returns a default Lucide icon component based on property type.
- * This provides a sensible fallback when no PropertyConfig is available.
- */
-function getDefaultIconForProperty(property: Property): LucideIcon {
-    switch (property.type) {
-        case "string": {
-            if (property.storage) return UploadIcon;
-            if (property.admin?.urlPreview) return GlobeIcon;
-            if (property.email) return MailIcon;
-            if (property.admin?.multiline || property.admin?.markdown) return AlignLeftIcon;
-            return TextIcon;
-        }
-        case "number":
-            return HashIcon;
-        case "boolean":
-            return FlagIcon;
-        case "date":
-            return CalendarIcon;
-        case "map":
-            return VoteIcon;
-        case "array": {
-            const of = property.of;
-            const oneOf = property.oneOf;
-            if (oneOf) return Rows3Icon;
-            if (of && !Array.isArray(of)) {
-                if (of.type === "reference") return LinkIcon;
-                if (of.type === "string" && of.storage) return UploadIcon;
-            }
-            return RepeatIcon;
-        }
-        case "reference":
-            return LinkIcon;
-        case "relation":
-            return LinkIcon;
-        case "vector":
-            return HashIcon;
-        default:
-            return CircleIcon;
-    }
-}
-
-export function getIconForProperty(
-    property: Property,
-    size: IconSize | number = "small",
-    fields: Record<string, PropertyConfig> = {}
-): React.ReactNode {
-    const px = resolveSize(size);
-
-    if (isPropertyBuilder(property)) {
-        return <FunctionSquareIcon size={px}/>;
-    }
-
-    // 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={px}/>;
-}
-
-/**
- * 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(".");
-            // A path whose root is not a property at all is simply not found.
-            // Reading `.type` off the miss threw a TypeError instead, which
-            // turned one unresolvable column key into a crash for whatever was
-            // walking the properties — see `propertiesToColumns`, where that is
-            // the whole table. `getPropertyInPath` above already guards this.
-            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: AdminCollection): string[] {
-    if (collection.propertiesOrder) return collection.propertiesOrder;
-    return [...Object.keys(collection.properties), ...(collection.additionalFields ?? []).map(field => field.key)];
-}

package/src/util/resolutions.ts

@@ -1,96 +0,0 @@
-import { HistoryIcon } from "@rebasepro/ui";
-import React from "react";
-import type { CollectionCustomView, CustomizationController, EntityAction, EntityCustomView } from "@rebasepro/cms-types";
-import { VIEW_MODES } from "./view_mode";
-
-/**
- * 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: 20 }),
-        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;
-    }
-}
-
-/**
- * Resolve a collection's `admin.customViews` into the views it can actually
- * render, dropping every entry that names a key nothing registered.
- *
- * Dropping is deliberate: an unresolvable key must not become a switcher entry
- * that renders a blank panel. It falls out of `enabledViews` too, so a user
- * whose saved view mode was removed lands on a built-in.
- */
-export function resolveCollectionViews(
-    customViews: (string | CollectionCustomView<any>)[] | undefined,
-    contextCollectionViews?: CollectionCustomView<any>[]
-): CollectionCustomView<any>[] {
-    if (!customViews) return [];
-    const resolved: CollectionCustomView<any>[] = [];
-    const seen = new Set<string>();
-    for (const entry of customViews) {
-        const view = typeof entry === "string"
-            ? contextCollectionViews?.find((candidate) => candidate.key === entry)
-            : entry;
-        // A custom view keyed "table" would shadow a built-in in the switcher
-        // and be unreachable in the render chain, which checks built-ins first.
-        if (!view || VIEW_MODES.includes(view.key) || seen.has(view.key)) continue;
-        seen.add(view.key);
-        resolved.push(view);
-    }
-    return resolved;
-}
-
-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 { entityViews?: EntityCustomView[] }).entityViews))
-              .filter(Boolean)
-              .filter((e) => (e as EntityCustomView).key !== "__rebase_history") 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
-    };
-}

package/src/util/view_constants.ts

@@ -1,33 +0,0 @@
-/**
- * Shared tab value constants used by EditViewBinding and DetailViewBinding.
- */
-export const MAIN_TAB_VALUE = "__main_##Q$SC^#S6";
-export const JSON_TAB_VALUE = "__json";
-export const HISTORY_TAB_VALUE = "__rebase_history";
-
-/**
- * The tab row belongs to the header band above the record, not to the record
- * itself, so it carries the same surface the identity bar over it and the form
- * rail beside it carry. Against that, the active tab takes the record's own
- * white and reads as connected to what it opens; on a white row it had to be
- * the tinted one, which is the relationship backwards.
- */
-export const ENTITY_VIEW_TAB_BAR_CLASS = "bg-surface-50 dark:bg-surface-900";
-
-/**
- * Every tab in that row, a custom `tabComponent` included.
- *
- * `h-full` over the variant's `h-9`: the row is 40px and the tab 36px, so a
- * centred tab floated ~2px clear of the row's bottom border and the active
- * tab's underline stopped short of the record it opens. Paired with
- * `items-stretch` on the Tabs root, which the variant leaves centred.
- */
-export const ENTITY_VIEW_TAB_CLASS = "h-full data-[state=active]:bg-white dark:data-[state=active]:bg-surface-800";
-
-/**
- * Added on top for the tabs this row labels itself — a custom `tabComponent`
- * sizes its own contents. The main tab was the only one rendered without it,
- * and so the only one left at the boxy variant's `text-xs` while its
- * neighbours sat at `text-sm`.
- */
-export const ENTITY_VIEW_TAB_LABEL_CLASS = "text-sm min-w-[90px]";