@rebasepro/app 0.12.1-canary.gf5f1d39 → 0.13.0

package/README.md

@@ -8,7 +8,7 @@ Framework-agnostic runtime for data-driven admin panels — React hooks, provide
 pnpm add @rebasepro/app
 ```
 
-**Peer dependencies:** `react >= 19`, `react-dom >= 19`, `react-router ^7`, `react-router-dom ^7`
+**Peer dependencies:** `react >= 19.2.7`, `react-dom >= 19.2.7`, `react-router ^8`
 
 ## What This Package Does
 

package/dist/auth/api.d.ts

@@ -8,13 +8,6 @@
  * here is the unauthenticated `/api/auth/config` probe used to detect
  * bootstrap mode and enabled providers before a session exists.
  */
-import { RebaseApiError } from "@rebasepro/types";
-/**
- * @deprecated Use {@link RebaseApiError} (from `@rebasepro/types`, re-exported by
- * `@rebasepro/client`). Kept as an alias so `instanceof` / imports keep working;
- * errors thrown here now carry `.code` and `.status` on the unified type.
- */
-export declare const AuthApiError: typeof RebaseApiError;
 /**
  * Auth config response from the backend
  */
@@ -59,7 +52,9 @@ export declare function createAuthConfigCache(): AuthConfigCache;
  * Concurrent calls are deduplicated: only one network request is made
  * and all callers share the same promise.
  */
-export declare function fetchAuthConfig(apiUrl: string, cache: AuthConfigCache): Promise<AuthConfigResponse>;
+export declare function fetchAuthConfig(apiUrl: string, cache: AuthConfigCache, 
+/** The backend's `basePath`; only needed if it is not the default. */
+apiPath?: string): Promise<AuthConfigResponse>;
 /**
  * Clear the cached auth config (e.g. on logout or for testing).
  */

package/dist/auth/index.d.ts

@@ -8,7 +8,7 @@
  * controller are in `../components`. Both are re-exported from the package
  * root, which is where applications should import them from.
  */
-export type { RebaseAuthController, RebaseAuthControllerProps, AuthTokens, DeviceSession, UserInfo, AuthResponse, RefreshResponse } from "./types";
+export type { RebaseAuthController, RebaseAuthControllerProps, User, AuthTokens, DeviceSession, AuthResponse, RefreshResponse } from "./types";
 export { useRebaseAuthController } from "./useRebaseAuthController";
-export { fetchAuthConfig, clearAuthConfigCache, createAuthConfigCache, AuthApiError } from "./api";
+export { fetchAuthConfig, clearAuthConfigCache, createAuthConfigCache } from "./api";
 export type { AuthConfigResponse, AuthConfigCache } from "./api";

package/dist/auth/types.d.ts

@@ -1,11 +1,7 @@
 import { User, AuthTokens, DeviceSession, RebaseSession, AuthChangeEvent } from "@rebasepro/types";
 import { AuthController } from "@rebasepro/admin-types";
 import type { AuthConfigResponse } from "./api";
-/** @deprecated Use `User` from `@rebasepro/types` instead. */
-export type UserInfo = User;
-/** @deprecated Use `DeviceSession` from `@rebasepro/types` instead. */
-export type Session = DeviceSession;
-export type { AuthTokens, DeviceSession };
+export type { User, AuthTokens, DeviceSession };
 /**
  * Auth controller that extends the base AuthController
  * with additional methods for email/password and Google login

package/dist/collections/form-layout.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Form layout resolution.
+ *
+ * Turns a collection into the shape the entity form renders: an ordered list of
+ * sections holding grid-spanned fields, plus the metadata rail beside them.
+ *
+ * The reason this is a pure function rather than logic inside the form is that
+ * the *defaults* are the interesting part. A collection that never writes an
+ * `admin.form` block still has to get a two-column layout out of this — the flat
+ * run of full-width fields it produced before was the single biggest cost in the
+ * form, and no amount of config would have fixed it for collections nobody
+ * hand-tunes. Deriving it here means it is testable in isolation, which matters
+ * because "what span does a date get" is exactly the kind of rule that rots.
+ */
+import type { AdminCollection, PropertySpan } from "@rebasepro/admin-types";
+import type { Property } from "@rebasepro/types";
+/** A field placed on the grid. */
+export interface ResolvedFormField {
+    key: string;
+    /** Columns occupied, out of `GRID_COLUMNS`. Ignored in the rail. */
+    span: PropertySpan;
+    /** True for an `additionalFields` entry rather than a property. */
+    additional: boolean;
+    /**
+     * The span was written on the property rather than derived from its type.
+     * Row filling leaves these alone: an author who wrote a width meant it.
+     */
+    spanExplicit?: boolean;
+}
+export interface ResolvedFormSection {
+    key: string;
+    title?: string;
+    collapsible: boolean;
+    /** Initial state only; the form owns it after first interaction. */
+    collapsed: boolean;
+    fields: ResolvedFormField[];
+}
+export interface ResolvedFormLayout {
+    sections: ResolvedFormSection[];
+    /** Fields shown in the rail. Empty means no rail fields. */
+    sidebar: ResolvedFormField[];
+    /** Show the read-only id/created/updated block at the foot of the rail. */
+    showRecordMeta: boolean;
+    /** True when there is anything at all to put in the rail. */
+    hasRail: boolean;
+}
+export interface ResolveFormLayoutParams<M extends Record<string, unknown>> {
+    collection: AdminCollection<M>;
+    /**
+     * Field keys in render order, already filtered by `propertiesOrder` — i.e.
+     * the output of `getFormFieldKeys`. Passed in rather than recomputed so the
+     * form and the layout can never disagree about which fields exist.
+     */
+    fieldKeys: string[];
+    /**
+     * Which fields the user may edit right now. A manual id is editable while
+     * creating and frozen afterwards, and that decides whether it belongs in the
+     * form at all or only in the record block.
+     */
+    status: "new" | "existing" | "copy";
+}
+/**
+ * The span a property gets when nothing is declared.
+ *
+ * Deliberately coarse: three buckets, chosen by how much room the *editor*
+ * needs, not by how important the field is. Importance is what `admin.form`
+ * sections are for.
+ */
+export declare function deriveSpan(property: Property, isTitleProperty: boolean): PropertySpan;
+/**
+ * Can the user still type this id?
+ *
+ * A `manual` id is a real field while creating and frozen once the row exists.
+ * Every generated strategy (`uuid`, `cuid`, a raw SQL default) is never typed.
+ * Getting this wrong in the "frozen" direction would make manual-id collections
+ * uncreatable, so it fails towards showing the field.
+ */
+export declare function isIdPropertyEditable(property: Property, status: "new" | "existing" | "copy"): boolean;
+/**
+ * An audit timestamp the database maintains — `created_at`, `updated_at`.
+ *
+ * Not a guess from the name: `autoValue` says the column is written by the
+ * system on create or update, so the field is never typed. Rendering it as an
+ * input in the middle of the form promised an edit that cannot happen, and the
+ * record block already shows both values — the same two dates twice on one
+ * screen.
+ */
+export declare function isAuditTimestamp(property: Property | undefined): boolean;
+/**
+ * Close the trailing gap in each row.
+ *
+ * Without this a section of half-width fields with an odd count leaves a hole —
+ * `name | sku` then `brand | ␣␣` — a field stranded beside half a row of
+ * nothing, which reads as a mistake rather than a layout. The remainder is
+ * spread across the row's derived fields rather than dumped on the last one, so
+ * a lone half-width field becomes full width and a pair grows evenly. Fields
+ * with an explicit span are never resized.
+ */
+export declare function fillRows(fields: ResolvedFormField[]): ResolvedFormField[];
+/**
+ * Resolve the layout for a collection's generated form.
+ *
+ * Never drops a field: anything not named by a section lands in a trailing
+ * group, so adding a column to the database cannot make it silently invisible
+ * in the panel.
+ */
+export declare function resolveFormLayout<M extends Record<string, unknown>>({ collection, fieldKeys, status }: ResolveFormLayoutParams<M>): ResolvedFormLayout;

package/dist/collections/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./collection_view_config";
 export * from "./entity_image_preview";
 export * from "./filter-operator-resolution";
+export * from "./form-layout";
 export * from "./navigation_from_path";
 export * from "./navigation_utils";
 export * from "./parent_references_from_path";

package/dist/collections/title-property.d.ts

@@ -14,6 +14,28 @@ import type { AdminCollection } from "@rebasepro/admin-types";
  * @group Collections
  */
 export declare function getTitlePropertyCandidates<M extends Record<string, unknown>>(collection: AdminCollection<M>): string[];
+/**
+ * The relation a collection *leads* with, if it leads with one.
+ *
+ * A junction-shaped collection — a pipeline entry, a membership, a booking —
+ * holds no label of its own: it is "this candidate, for that vacancy". The
+ * general ranking puts relations last (they only read once the target
+ * resolves), so the title slot would otherwise fall to whatever free text
+ * happens to follow: a note, a comment. Preview surfaces that render one row
+ * per entity (list, cards, board) prefer the leading relation instead.
+ *
+ * The decision is structural — the first property that could be a title, in the
+ * order the developer declared (or ordered) them. Declaration order is a
+ * statement about what the collection is about; property *names* are not
+ * consulted here.
+ *
+ * Returns `undefined` when that first property is anything but a
+ * single-cardinality relation, or when the collection states its own
+ * `titleProperty`.
+ *
+ * @group Collections
+ */
+export declare function getLeadingRelationTitleKey<M extends Record<string, unknown>>(collection: AdminCollection<M>): string | undefined;
 /**
  * The property that should fill the title slot for a collection, ignoring any
  * concrete values. Prefer {@link getTitlePropertyKeyForValues} when an entity

package/dist/components/Debug/collection-views/sample_data.d.ts

@@ -1,3 +1,4 @@
+import type { ChipColorKey } from "@rebasepro/ui";
 export type ProjectStatus = "backlog" | "in_progress" | "in_review" | "done";
 export type ProjectPriority = "low" | "medium" | "high" | "critical";
 export interface SampleProject {
@@ -14,10 +15,10 @@ export interface SampleProject {
 }
 export declare const STATUS_CONFIG: Record<ProjectStatus, {
     label: string;
-    color: string;
+    color: ChipColorKey;
 }>;
 export declare const PRIORITY_CONFIG: Record<ProjectPriority, {
     label: string;
-    color: string;
+    color: ChipColorKey;
 }>;
 export declare const SAMPLE_PROJECTS: SampleProject[];

package/dist/hooks/ApiConfigContext.d.ts

@@ -8,17 +8,51 @@ import React from "react";
  */
 export interface ApiConfig {
     apiUrl: string;
+    /**
+     * The path the backend mounts its API under, appended to {@link apiUrl}.
+     *
+     * `"/api"` by default, which is the server's default `basePath`. It is
+     * carried here because a good deal of UI builds request URLs by hand
+     * instead of going through the client's typed methods, and every one of
+     * those sites used to write `/api` as a literal — so a backend configured
+     * with any other `basePath` served an admin panel whose auth-provider
+     * discovery, storage browser, history panel, user picker and Studio tools
+     * all requested paths that did not exist.
+     */
+    apiPath: string;
     getAuthToken?: () => Promise<string | null>;
 }
+/** What the server uses when `basePath` is not configured. */
+export declare const DEFAULT_API_PATH = "/api";
 /**
  * Read the API config from context. Returns `undefined` if no provider is present,
  * allowing hooks to fall back to their own props.
  */
 export declare function useApiConfig(): ApiConfig | undefined;
 /**
- * Provide API configuration (apiUrl, getAuthToken) to the entire subtree.
+ * `apiUrl` and `apiPath` joined, with no trailing slash — the prefix to build a
+ * request URL from.
+ *
+ * Returns `undefined` when there is no provider, so a caller can keep its own
+ * fallback rather than silently requesting a relative path.
+ */
+export declare function useApiBase(): string | undefined;
+/**
+ * The same prefix, derived from a client rather than from context.
+ *
+ * For the code that holds a `RebaseClient` but sits outside (or above) an
+ * `ApiConfigProvider`. Returns `undefined` when the client has no base URL,
+ * which is the signal every caller already treats as "cannot build a request".
+ */
+export declare function apiBaseOf(client?: {
+    baseUrl?: string;
+    apiPath?: string;
+}): string | undefined;
+/**
+ * Provide API configuration (apiUrl, apiPath, getAuthToken) to the entire subtree.
  * Typically rendered inside `<Rebase>` or at the app root.
  */
-export declare function ApiConfigProvider({ apiUrl, getAuthToken, children }: ApiConfig & {
+export declare function ApiConfigProvider({ apiUrl, apiPath, getAuthToken, children }: Omit<ApiConfig, "apiPath"> & {
+    apiPath?: string;
     children: React.ReactNode;
 }): React.JSX.Element;

package/dist/hooks/useBackendStorageSource.d.ts

@@ -7,6 +7,11 @@ export interface BackendStorageSourceProps {
      * Backend API URL (e.g., 'http://localhost:3001')
      */
     apiUrl: string;
+    /**
+     * The path the backend mounts its API under. Defaults to the server's own
+     * default; pass the backend's `basePath` if it was configured otherwise.
+     */
+    apiPath?: string;
     /**
      * Function to get the current auth token
      */
@@ -27,4 +32,4 @@ export interface BackendStorageSourceProps {
  * <Rebase storageSource={storageSource} ... />
  * ```
  */
-export declare function useBackendStorageSource({ apiUrl, getAuthToken }: BackendStorageSourceProps): StorageSource;
+export declare function useBackendStorageSource({ apiUrl, apiPath, getAuthToken }: BackendStorageSourceProps): StorageSource;

package/dist/hooks/useNavigationBlocker.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { Blocker, BlockerFunction } from "react-router-dom";
+import { Blocker, BlockerFunction } from "react-router";
 /**
  * Owns the single React Router blocker for the whole app.
  *

package/dist/hooks/useSnackbarController.d.ts

@@ -1,4 +1,4 @@
-import type { SnackbarMessageType } from "@rebasepro/admin-types";
+import type { SnackbarAction, SnackbarMessageType } from "@rebasepro/admin-types";
 import React from "react";
 /**
  * Hook to retrieve the SnackbarContext.
@@ -15,6 +15,7 @@ export declare const useSnackbarController: () => {
         title?: string;
         message: React.ReactNode;
         autoHideDuration?: number;
+        action?: SnackbarAction;
     }) => void;
     close: () => void;
 };

package/dist/hooks/useStudioBridge.d.ts

@@ -13,6 +13,31 @@ export interface StudioBridge {
     urlController: UrlController;
     navigationState: NavigationStateController;
     breadcrumbs: BreadcrumbsController;
+    capabilities: StudioCapabilities;
+}
+/**
+ * What the *host* of these tools can do, as opposed to what the backend can.
+ *
+ * Studio is mounted in two very different places. In a project's own admin
+ * panel it runs next to the collection source files and can edit them through
+ * the schema-editor routes. In the hosted console it runs against somebody
+ * else's deployed container: there is no source to edit — the container is
+ * rebuilt from the customer's repository on every deploy — and the routes that
+ * would edit it are not mounted at all, because the framework switches the
+ * schema editor off under `NODE_ENV=production`.
+ *
+ * Tools that would otherwise offer a write into the codebase read this to
+ * decide whether that write is even meaningful.
+ */
+export interface StudioCapabilities {
+    /**
+     * Whether the host has the project's collection source at hand and can
+     * write to it.
+     *
+     * Defaults to `true`, which is what an admin panel running beside its own
+     * `collectionsDir` has always assumed.
+     */
+    codebase: boolean;
 }
 export declare const StudioBridgeContext: React.Context<StudioBridge>;
 /**
@@ -46,6 +71,8 @@ export declare function useStudioUrlController(): UrlController;
 export declare function useStudioNavigationState(): NavigationStateController;
 /** Breadcrumbs controller — returns noop if the admin is not present. */
 export declare function useStudioBreadcrumbs(): BreadcrumbsController;
+/** What the host can do — see {@link StudioCapabilities}. */
+export declare function useStudioCapabilities(): StudioCapabilities;
 /**
  * Registry that controllers use to self-register their implementations
  * into the Studio bridge. Each controller calls `register(key, value)`

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export * from "./auth";
 export * from "./components";
 export * from "./util";
 export * from "./contexts";
-export { CONTAINER_FULL_WIDTH, ADDITIONAL_TAB_WIDTH, FORM_CONTAINER_WIDTH } from "./internal/common";
+export { CONTAINER_FULL_WIDTH, FORM_CONTAINER_WIDTH, SIDE_PANEL_DEFAULT_WIDTH } from "./internal/common";
 export { useRestoreScroll } from "./internal/useRestoreScroll";
 export { useUnsavedChangesDialog } from "./hooks/useUnsavedChangesDialog";
 export { NavigationBlockerProvider, useNavigationBlocker } from "./hooks/useNavigationBlocker";