@rebasepro/admin 0.6.1 → 0.7.0

package/dist/types/components/EntityFormActionsProps.d.ts

@@ -12,7 +12,7 @@ export interface EntityFormActionsProps {
     disabled: boolean;
     status: "new" | "existing" | "copy";
     pluginActions: React.ReactNode[];
-    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
     showDefaultActions?: boolean;
     navigateBack: () => void;
     formContext: FormContext;

package/dist/types/components/EntityFormProps.d.ts

@@ -3,6 +3,11 @@ import { EntityCollection, EntityCustomViewParams } from "@rebasepro/types";
 import { FormContext } from "../fields";
 import { FormexController } from "./formex";
 import { EntityFormActionsProps } from "./EntityFormActionsProps";
+/**
+ * Props for the headless EntityForm component.
+ * This form can be used without CMS context — all backend concerns
+ * (save, caching, analytics, plugin slots) are provided via callbacks.
+ */
 export type EntityFormProps<M extends Record<string, unknown>> = {
     path: string;
     fullIdPath?: string;
@@ -38,6 +43,60 @@ export type EntityFormProps<M extends Record<string, unknown>> = {
     navigateBack?: () => void;
     Builder?: React.ComponentType<EntityCustomViewParams<M>>;
     children?: React.ReactNode;
+    /**
+     * Called on form submit with the values to save.
+     * The EntityFormBinding wrapper provides this automatically.
+     * When using EntityForm standalone, provide your own save logic.
+     */
+    onSubmit?: (values: M, formex: FormexController<M>) => Promise<Entity<M> | void> | void;
+    /**
+     * Called when form values change (deferred).
+     * The EntityFormBinding wrapper uses this for entity caching.
+     */
+    onValuesChangeDeferred?: (values: M, controller: FormexController<M>) => void;
+    /**
+     * Called when the form is reset.
+     */
+    onReset?: () => void;
+    /**
+     * Validate that a field value is unique.
+     * The EntityFormBinding wrapper provides this via the data layer.
+     */
+    uniqueFieldValidator?: (params: {
+        name: string;
+        value: unknown;
+    }) => Promise<boolean>;
+    /** Content rendered before the form fields */
+    beforeFields?: React.ReactNode;
+    /** Content rendered after the form fields */
+    afterFields?: React.ReactNode;
+    /** Plugin-provided action elements */
+    pluginActions?: React.ReactNode[];
+    /**
+     * Initial values for the form, after applying local changes.
+     * If not provided, computed from entity + collection defaults.
+     */
+    computedInitialValues?: Partial<M>;
+    /**
+     * Whether there are unsaved local changes in the cache.
+     */
+    hasLocalChanges?: boolean;
+    /**
+     * The local changes data for the manual-apply menu.
+     */
+    localChangesData?: Partial<M>;
+    /**
+     * Whether manual-apply local changes mode is enabled.
+     */
+    manualApplyLocalChanges?: boolean;
+    /**
+     * Cache key for the local changes menu.
+     */
+    localChangesCacheKey?: string;
+    /**
+     * Callback when local changes are cleared.
+     */
+    onClearLocalChanges?: () => void;
 };
 export type OnUpdateParams = {
     entity: Entity<Record<string, unknown>>;

package/dist/types/fields.d.ts

@@ -149,7 +149,7 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
     status: "new" | "existing" | "copy";
     entity?: Entity<M>;
     savingError?: Error;
-    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
     /**
      * This is the underlying formex controller that powers the form.
      * If you are in a red only mode, the formex controller is there, but you can't
@@ -157,6 +157,11 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
      */
     formex: FormexController<M>;
     disabled: boolean;
+    /**
+     * Whether the form context is in read-only detail view mode.
+     * Custom entity views can use this to adjust their rendering.
+     */
+    readOnly?: boolean;
 }
 /**
  * In case you need to render a field bound to a Property inside your

package/dist/util/dataControllerAdapter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Adapts an `EntityTableController<M>` (from @rebasepro/types) to a
+ * `CollectionDataController<T>` (from @rebasepro/ui), bridging the
+ * entity-aware data layer to the headless collection view.
+ */
+import type { EntityTableController } from "@rebasepro/types";
+import type { CollectionDataController } from "@rebasepro/ui";
+/**
+ * React hook that adapts an EntityTableController to a CollectionDataController.
+ *
+ * Usage:
+ * ```tsx
+ * const tableController = useDataTableController({ path, collection });
+ * const dataController = useCollectionDataController(tableController);
+ *
+ * <CollectionView dataController={dataController} ... />
+ * ```
+ */
+export declare function useCollectionDataController<M extends Record<string, unknown>>(tableController: EntityTableController<M>): CollectionDataController<M & {
+    id: string | number;
+    path: string;
+}>;
+/**
+ * Non-hook version for cases where you already have the data
+ * and just need to build a static controller.
+ */
+export declare function createStaticDataController<T extends Record<string, unknown>>(data: T[], options?: {
+    loading?: boolean;
+    error?: Error;
+}): CollectionDataController<T>;

package/dist/util/navigation_utils.d.ts

@@ -5,7 +5,7 @@ export { removeInitialAndTrailingSlashes, removeInitialSlash, removeTrailingSlas
  * This is an admin-specific UI concern and lives here (not in common).
  */
 export declare function navigateToEntity({ openEntityMode, collection, entityId, copy, path, selectedTab, defaultValues, sideEntityController, onClose, navigation, replace }: {
-    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
     collection?: EntityCollection;
     entityId?: string | number;
     selectedTab?: string;

package/dist/util/propertyConfigMapper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 } from "@rebasepro/types";
+import type { CollectionPropertyConfig } from "@rebasepro/ui";
+/**
+ * Convert a single Property to a CollectionPropertyConfig.
+ */
+export declare function mapPropertyToConfig(property: Property): CollectionPropertyConfig;
+/**
+ * Convert a Properties record to a CollectionPropertyConfig record.
+ */
+export declare function mapPropertiesToConfigs(properties: Properties): Record<string, CollectionPropertyConfig>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/admin",
   "type": "module",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Rebase CMS — content management views, forms, and routing",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -31,6 +31,14 @@
     "headless cms",
     "content manager"
   ],
+  "scripts": {
+    "watch": "vite build --watch",
+    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json",
+    "test:lint": "eslint \"src/**\" --quiet",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
+    "generateIcons": "ts-node --esm src/icons/generateIcons.ts"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -55,6 +63,13 @@
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@floating-ui/dom": "^1.7.6",
+    "@rebasepro/common": "workspace:*",
+    "@rebasepro/core": "workspace:*",
+    "@rebasepro/formex": "workspace:*",
+    "@rebasepro/schema-inference": "workspace:*",
+    "@rebasepro/types": "workspace:*",
+    "@rebasepro/ui": "workspace:*",
+    "@rebasepro/utils": "workspace:*",
     "cmdk": "^1.1.1",
     "date-fns": "^4.4.0",
     "exceljs": "^4.4.0",
@@ -82,14 +97,7 @@
     "prosemirror-view": "^1.41.9",
     "react-dropzone": "^15.0.0",
     "react-use-measure": "^2.1.7",
-    "zod": "^4.4.3",
-    "@rebasepro/core": "0.6.1",
-    "@rebasepro/formex": "0.6.1",
-    "@rebasepro/schema-inference": "0.6.1",
-    "@rebasepro/common": "0.6.1",
-    "@rebasepro/types": "0.6.1",
-    "@rebasepro/utils": "0.6.1",
-    "@rebasepro/ui": "0.6.1"
+    "zod": "^4.4.3"
   },
   "peerDependencies": {
     "react": ">=19.0.0",
@@ -160,13 +168,5 @@
       "^@rebasepro/formex$": "<rootDir>/../formex/src/index.ts",
       "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
     }
-  },
-  "scripts": {
-    "watch": "vite build --watch",
-    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json",
-    "test:lint": "eslint \"src/**\" --quiet",
-    "test": "jest --passWithNoTests",
-    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
-    "generateIcons": "ts-node --esm src/icons/generateIcons.ts"
   }
-}
+}

package/src/collection_editor/extensibility_types.ts

@@ -0,0 +1,168 @@
+/**
+ * Extension point types for the collection editor UI.
+ *
+ * These types define props that let external consumers customize the editor
+ * without forking the UI: property type presets, type filtering,
+ * custom form field slots, and tab visibility.
+ *
+ * All extension points are additive and optional — the standard Rebase
+ * editor experience is unchanged when these props are not provided.
+ *
+ * @module
+ */
+
+import type React from "react";
+import type { SerializableProperty, SerializableCollection } from "./serializable_types";
+
+// ═══════════════════════════════════════════════════════════════════════
+// PROPERTY TYPE PRESETS
+// ═══════════════════════════════════════════════════════════════════════
+
+/**
+ * The base property data types supported by Rebase.
+ * Derived from the `type` discriminant on `SerializableProperty`.
+ */
+export type PropertyType = SerializableProperty["type"];
+
+/**
+ * A higher-level "preset" that maps to a base Rebase property type
+ * with pre-filled configuration. Presets replace the default type picker
+ * in the property form when provided.
+ *
+ * @example
+ * ```typescript
+ * const emailPreset: PropertyTypePreset = {
+ *     id: "email",
+ *     label: "Email",
+ *     baseType: "string",
+ *     icon: "Mail",
+ *     defaults: { email: true },
+ *     detect: (p) => p.type === "string" && "email" in p && p.email === true,
+ * };
+ * ```
+ */
+export interface PropertyTypePreset {
+    /** Unique identifier for this preset (e.g. "email", "phone", "currency"). */
+    id: string;
+
+    /** Display label shown in the type picker. */
+    label: string;
+
+    /** The underlying Rebase property type this maps to. */
+    baseType: PropertyType;
+
+    /** Icon to show in the picker (Lucide icon name string or React node). */
+    icon?: string | React.ReactNode;
+
+    /** Default property config applied when this preset is selected. */
+    defaults: Partial<SerializableProperty>;
+
+    /**
+     * Optional: detect this preset from an existing property.
+     * Used when loading existing schemas to show the correct preset label
+     * instead of the raw base type. First match wins.
+     * If not provided, falls back to matching by `baseType` alone.
+     */
+    detect?: (property: SerializableProperty) => boolean;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// TAB VISIBILITY
+// ═══════════════════════════════════════════════════════════════════════
+
+/**
+ * The tabs available in the collection editor.
+ */
+export type CollectionEditorTab = "general" | "display" | "properties" | "rls";
+
+// ═══════════════════════════════════════════════════════════════════════
+// CUSTOM FORM FIELD SLOTS
+// ═══════════════════════════════════════════════════════════════════════
+
+/**
+ * Parameters passed to the `renderExtraPropertyFields` render prop.
+ */
+export interface ExtraPropertyFieldsParams {
+    /** Current metadata values from `property.metadata`. */
+    metadata: Record<string, unknown>;
+    /** Callback to update a single metadata key. Triggers dirty-state tracking. */
+    onMetadataChange: (key: string, value: unknown) => void;
+    /** The full current property being edited (serializable form). */
+    property: SerializableProperty;
+    /** The collection this property belongs to (serializable form). */
+    collection: SerializableCollection;
+}
+
+/**
+ * Parameters passed to the `renderExtraCollectionFields` render prop.
+ */
+export interface ExtraCollectionFieldsParams {
+    /** Current metadata values from `collection.metadata`. */
+    metadata: Record<string, unknown>;
+    /** Callback to update a single metadata key. Triggers dirty-state tracking. */
+    onMetadataChange: (key: string, value: unknown) => void;
+    /** The full current collection being edited (serializable form). */
+    collection: SerializableCollection;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// COMBINED EXTENSION PROPS
+// ═══════════════════════════════════════════════════════════════════════
+
+/**
+ * All extension props for the collection editor UI.
+ *
+ * This interface groups every customization point into a single type
+ * that can be intersected with component props interfaces for clean threading.
+ *
+ * All fields are optional — when not provided, the standard Rebase
+ * editor experience is unchanged (backward compatible).
+ */
+export interface CollectionEditorExtensionProps {
+    /**
+     * Custom property type presets. When provided, these REPLACE the default
+     * type picker entirely. To include standard Rebase types alongside custom
+     * ones, include them explicitly in the array.
+     *
+     * When not provided, the standard Rebase widget picker is shown.
+     */
+    propertyTypePresets?: PropertyTypePreset[];
+
+    /**
+     * Property types to hide from the type picker.
+     * Only applies when `propertyTypePresets` is NOT provided.
+     * When `propertyTypePresets` IS provided, this prop is ignored.
+     */
+    hiddenPropertyTypes?: PropertyType[];
+
+    /**
+     * Render additional form fields below the standard property configuration.
+     * Metadata is stored in `property.metadata`.
+     */
+    renderExtraPropertyFields?: (params: ExtraPropertyFieldsParams) => React.ReactNode;
+
+    /**
+     * Render additional form fields in the collection editor's General tab.
+     * Metadata is stored in `collection.metadata`.
+     */
+    renderExtraCollectionFields?: (params: ExtraCollectionFieldsParams) => React.ReactNode;
+
+    /**
+     * Which tabs to show in the collection editor.
+     * Default: all tabs are shown (current behavior).
+     */
+    visibleTabs?: CollectionEditorTab[];
+
+    /**
+     * When true, the editor runs in standalone mode — all Rebase-specific
+     * context dependencies (snackbar, auth, collection registry, import,
+     * navigation state, URL controller) use safe defaults instead of
+     * reading from React contexts.
+     *
+     * Use this when embedding the collection editor outside of the Rebase
+     * CMS, where the Rebase context providers are not available.
+     *
+     * Default: false (standard Rebase mode).
+     */
+    standalone?: boolean;
+}

package/src/collection_editor/index.ts

@@ -17,6 +17,50 @@ export {
 export {
     useLocalCollectionsConfigController
 } from "./useLocalCollectionsConfigController";
+export {
+    useJsonCollectionsConfigController,
+    type UseJsonCollectionsConfigControllerOptions,
+} from "./useJsonCollectionsConfigController";
+
+export {
+    toSerializableCollection,
+    toSerializableProperty,
+    toSerializableProperties,
+    fromSerializableCollection,
+    fromSerializableProperty,
+    fromSerializableProperties,
+} from "./serializable_utils";
+
+export type {
+    SerializableCollection,
+    SerializableProperty,
+    SerializableProperties,
+    SerializableBaseProperty,
+    SerializableStringProperty,
+    SerializableNumberProperty,
+    SerializableBooleanProperty,
+    SerializableDateProperty,
+    SerializableGeopointProperty,
+    SerializableReferenceProperty,
+    SerializableRelationProperty,
+    SerializableArrayProperty,
+    SerializableMapProperty,
+    SerializableVectorProperty,
+    SerializableBinaryProperty,
+    SerializableStorageConfig,
+    SerializableStringValidation,
+    SerializableDateValidation,
+    JsonCollectionStore,
+} from "./serializable_types";
+
+export type {
+    PropertyTypePreset,
+    PropertyType,
+    CollectionEditorTab,
+    CollectionEditorExtensionProps,
+    ExtraPropertyFieldsParams,
+    ExtraCollectionFieldsParams,
+} from "./extensibility_types";
 
 export {
     validateCollectionJson,
@@ -58,4 +102,6 @@ export * from "./ui/collection_editor/util";
 export type { CollectionEditorDialogProps } from "./ui/collection_editor/CollectionEditorDialog";
 export type { CollectionStudioViewProps } from "./ui/collection_editor/CollectionStudioView";
 export type { CollectionsStudioViewProps } from "./ui/collection_editor/CollectionsStudioView";
+export type { RouterCollectionStudioViewProps } from "./ui/collection_editor/RouterCollectionStudioView";
+export type { RouterCollectionsStudioViewProps } from "./ui/collection_editor/RouterCollectionsStudioView";
 export type { PropertyFormProps, OnPropertyChangedParams } from "./ui/collection_editor/PropertyEditView";