@rebasepro/app 0.23.0 → 0.24.1-canary.g19596ef

package/README.md

@@ -67,8 +67,8 @@ This package is **framework-agnostic** in the sense that it doesn't depend on an
 | `useRebaseContext` | Access the top-level Rebase context |
 | `useDialogsController` | Programmatic dialog management |
 | `useSnackbarController` | Show snackbar notifications |
-| `useModeController` / `useBuildModeController` | Light/dark mode |
-| `useStorageSource` / `useBackendStorageSource` | Storage source from context |
+| `useModeController` / `useBuildModeController` | Light/dark mode: `mode` and `setMode("light" \| "dark" \| "system")`. To let your app own the theme, pass its own controller as `<Rebase modeController>`; `useBuildModeController({ enabled: false })` builds one that touches nothing outside React |
+| `useStorageSource` | Storage source from context |
 | `useRebaseClient` | Access the `RebaseClient` instance |
 | `useLargeLayout` | Responsive layout breakpoint hook |
 | `useClipboard` | Copy-to-clipboard |

package/dist/auth/api.d.ts

@@ -8,7 +8,7 @@
  * here is the unauthenticated `/api/auth/config` probe used to detect
  * bootstrap mode and enabled providers before a session exists.
  */
-import type { AuthAdapterCapabilities } from "@rebasepro/types";
+import type { AuthConfigDocument } from "@rebasepro/types";
 /**
  * What `GET /api/auth/config` answers.
  *
@@ -17,7 +17,7 @@ import type { AuthAdapterCapabilities } from "@rebasepro/types";
  * this one listed an `emailServiceEnabled` flag no backend sends, and marked as
  * optional fields every backend always returns.
  */
-export type AuthConfigResponse = AuthAdapterCapabilities;
+export type AuthConfigResponse = AuthConfigDocument;
 /**
  * Cache container for `fetchAuthConfig` — holds both the inflight promise
  * (to deduplicate concurrent calls) and the cached result.

package/dist/auth/types.d.ts

@@ -21,7 +21,14 @@ export type RebaseAuthController = AuthController & {
     /** Login with email and password */
     emailPasswordLogin: (email: string, password: string) => Promise<void>;
     /** Register a new user */
-    register: (email: string, password: string, displayName?: string) => Promise<void>;
+    /**
+     * Create an account. `confirmationRequired` when the backend registers
+     * confirm-first (`requireEmailVerification`): nobody is signed in until
+     * the address is confirmed.
+     */
+    register: (email: string, password: string, displayName?: string) => Promise<{
+        confirmationRequired: boolean;
+    }>;
     /** Skip login (for anonymous access if enabled) */
     skipLogin: () => void;
     /** Whether login was skipped */
@@ -36,10 +43,33 @@ export type RebaseAuthController = AuthController & {
     forgotPassword: (email: string) => Promise<void>;
     /** Reset password using token from email */
     resetPassword: (token: string, password: string) => Promise<void>;
-    /** Confirm an email address using the token from a verification email */
-    verifyEmail: (token: string) => Promise<void>;
+    /**
+     * Confirm an email address using the token from a verification email.
+     * Refused with `PROOF_REQUIRED` when the account holds a password this
+     * call does not prove: pass `password` to keep it (and sign in), or
+     * `removeUnproven` to verify without it.
+     */
+    verifyEmail: (token: string, options?: {
+        password?: string;
+        removeUnproven?: boolean;
+    }) => Promise<{
+        passwordRemoved: boolean;
+        signedIn: boolean;
+    }>;
+    /** Sign in with a magic link's token. Absent when the client cannot. */
+    magicLinkLogin?: (token: string) => Promise<void>;
     /** Change password for authenticated user */
     changePassword: (oldPassword: string, newPassword: string) => Promise<void>;
+    /** Ask to move the signed-in account to another address. Absent when the client cannot. */
+    changeEmail?: (newEmail: string) => Promise<{
+        pendingEmail: string;
+        expiresAt: string;
+    }>;
+    /** Follow an address-change link. Absent when the client cannot. */
+    confirmEmailChange?: (token: string) => Promise<{
+        email: string;
+        removedProviders: string[];
+    }>;
     /** Update user profile */
     updateProfile: (displayName?: string, photoURL?: string) => Promise<User>;
     /** Fetch active sessions */
@@ -64,6 +94,8 @@ export type RebaseAuthController = AuthController & {
      * the client has no MFA support.
      */
     verifyMfaChallenge?: (mfaToken: string, challengeId: string, code: string) => Promise<void>;
+    /** The scopes the signed-in user holds; `undefined` until known. */
+    heldScopes?: string[];
 };
 /**
  * Structural type for the subset of `client.auth` (from `@rebasepro/client`)
@@ -91,8 +123,23 @@ export interface ClientAuth {
     resetPasswordForEmail(email: string): Promise<unknown>;
     resetPassword(token: string, password: string): Promise<unknown>;
     /** Optional so a hand-built auth client need not implement it. */
-    verifyEmail?(token: string): Promise<unknown>;
+    verifyEmail?(token: string, options?: {
+        password?: string;
+        removeUnproven?: boolean;
+    }): Promise<unknown>;
     changePassword(oldPassword: string, newPassword: string): Promise<unknown>;
+    /** Optional so a hand-built auth client need not implement it. */
+    verifyMagicLink?(token: string): Promise<unknown>;
+    /** Optional so a hand-built auth client need not implement it. */
+    changeEmail?(newEmail: string): Promise<{
+        pendingEmail: string;
+        expiresAt: string;
+    }>;
+    /** Optional so a hand-built auth client need not implement it. */
+    confirmEmailChange?(token: string): Promise<{
+        email: string;
+        removedProviders: string[];
+    }>;
     updateUser(updates: {
         displayName?: string;
         photoURL?: string;
@@ -131,6 +178,12 @@ export interface RebaseAuthControllerProps {
             setAuthTokenGetter: (getter: () => Promise<string | null>) => void;
         };
         auth?: ClientAuth;
+        /** Read for the scopes the signed-in user holds (`GET /auth/scopes`). */
+        personalKeys?: {
+            listScopes(): Promise<{
+                held: string[];
+            }>;
+        };
     };
     /** Google OAuth client ID (optional, enables Google login) */
     googleClientId?: string;

package/dist/collections/filter-operator-resolution.d.ts

@@ -55,3 +55,21 @@ export interface ResolveFilterOperatorsParams {
  * @group Models
  */
 export declare function resolveFilterOperators({ property, isArray, engine }: ResolveFilterOperatorsParams): WhereFilterOp[];
+/**
+ * Whether a property can be filtered at all — the one answer the table header
+ * and the filters dialog both give.
+ *
+ * They used to answer it with a predicate each, and disagreed: the header
+ * allowed an array only of strings, numbers, dates, references and relations;
+ * the dialog allowed an array of anything, and listed an array of maps with an
+ * empty control. The header, for its part, ignored both the developer's
+ * `filterOperators: []` and a custom `admin.Filter`.
+ *
+ * A property with a custom filter field is filterable: the developer owns that
+ * field. Otherwise it is filterable when at least one operator survives
+ * {@link resolveFilterOperators} — for an array, on its item type. A tuple
+ * array (`of: [a, b]`) has no single item type to filter by.
+ *
+ * @group Models
+ */
+export declare function isPropertyFilterable(property: Property, engine?: string): boolean;

package/dist/collections/navigation_utils.d.ts

@@ -13,8 +13,14 @@ export declare function resolveCollectionPathIds(path: string, allCollections: A
  */
 export declare function getCollectionBySlugWithin(slugOrPath: string, collections: AdminCollection[]): AdminCollection | undefined;
 /**
- * Get the subcollection combinations from a path:
- * "sites/es/locales" => ["sites/es/locales", "sites"]
+ * Every leading run of whole segments of a path, longest first: the
+ * candidates for the collection the path starts with.
+ * "sites/es/locales" => ["sites/es/locales", "sites/es", "sites"]
+ *
+ * Every length, not only the odd ones. A slug may contain slashes, so
+ * `content/podcasts/abc123/episodes` starts with the two-segment collection
+ * `content/podcasts`, and a path's own segment count says nothing about where
+ * its first collection ends.
  * @param subpaths
  */
 export declare function getCollectionPathsCombinations(subpaths: string[]): string[];

package/dist/collections/property_presentation.d.ts

@@ -3,23 +3,20 @@
  *
  * These read a property's admin block — `readOnly`, `disabled.hidden`, the
  * declarative `conditions` — and lived in `@rebasepro/common`, which is on the
- * backend's dependency path. Nothing in core ever called them: `isReadOnly` and
- * `isHidden` are used only by the panel, and `applyPropertyConditions` has no
- * production caller at all.
+ * backend's dependency path. Nothing in core ever called them: `isReadOnly`,
+ * `isHidden` and `applyPropertyConditions` are the panel's alone.
  *
- * That last one is worth knowing about rather than assuming: the collection editor
- * has a whole Conditions UI, `serializable_utils` persists what it writes, and
- * `BaseProperty.conditions` documents itself as "evaluated at runtime like property
- * builders" — but the evaluator below is reached only from its own tests. It lives
- * here because here is where it would be called from once it is wired up.
+ * `applyPropertyConditions` is called by the record form, through
+ * `resolveFormProperty`, both where a field is laid out and where the form is
+ * judged on save — so a rule the collection editor writes hides, disables and
+ * requires what it says it does, and a field it hides is not held against the
+ * save. Until that was wired, the evaluator was reached only from its own tests.
  *
- * The one part of `conditions` that *is* applied is the literal case:
- * `hidden`/`readOnly`/`disabled` stated as a plain boolean rather than as a rule.
- * A literal needs no context, so `isHidden`/`isReadOnly`/`isDisabled` can answer
- * it directly, and those three gates are consulted everywhere a field is laid
- * out. A *rule* still is not evaluated anywhere in production — the split is
- * deliberate, not an oversight: it is the difference between a condition that
- * needs an entity to be evaluated against and one that does not.
+ * A condition may also be a literal: `hidden`/`readOnly`/`disabled` stated as a
+ * plain boolean rather than as a rule. A literal needs no context, so
+ * `isHidden`/`isReadOnly`/`isDisabled` answer it directly, and those three
+ * gates are consulted everywhere a field is laid out — including places with
+ * no entity to evaluate a rule against.
  */
 import type { ConditionContext, Property } from "@rebasepro/types";
 export declare function isReadOnly(property: Property): boolean;

package/dist/components/ConnectionLostBanner.d.ts

@@ -0,0 +1,31 @@
+import React from "react";
+import type { RealtimeConnectionState } from "@rebasepro/types";
+/**
+ * The realtime connection's state, re-rendering on every change.
+ *
+ * `undefined` when there is no client, or it was built without realtime —
+ * there is no connection to describe.
+ *
+ * @group Hooks and utilities
+ */
+export declare function useRealtimeConnectionState(): RealtimeConnectionState | undefined;
+export interface ConnectionLostBannerProps {
+    className?: string;
+}
+/**
+ * Says that live updates have stopped, while they have.
+ *
+ * Shown once the realtime client reports the connection `disconnected`: the
+ * socket has been down for longer than a blip, so tables, boards and open
+ * records are showing what they last received and nothing else will arrive
+ * until it is back. They keep their data rather than turning into errors — this
+ * banner is how the user learns it may be out of date. It disappears by itself
+ * when the connection returns, and every live view then refreshes.
+ *
+ * A brief drop (`reconnecting`) shows nothing: a deploy blips every socket for
+ * a second or two, and a banner that flashes on each one teaches people to
+ * ignore it.
+ *
+ * @group Components
+ */
+export declare function ConnectionLostBanner({ className }: ConnectionLostBannerProps): React.JSX.Element | null;

package/dist/components/LoginView/email-link.d.ts

@@ -3,9 +3,11 @@
  *
  * The server builds them from the configured frontend URL:
  * `<frontend>/reset-password?token=…` for a forgotten password, an admin's
- * "send reset email" and every invitation, and `<frontend>/verify-email?token=…`
- * to confirm an address. The frontend URL may carry a base path (`/admin`), so
- * the action is the *last* path segment, not the whole path.
+ * "send reset email" and every invitation, `<frontend>/verify-email?token=…`
+ * to confirm an address, `<frontend>/confirm-email-change?token=…` to move an
+ * account to a new one, and `<frontend>/auth/magic-link?token=…` to sign in.
+ * The frontend URL may carry a base path (`/admin`), so the action is read off
+ * the *end* of the path, not the whole path.
  */
 export type EmailLinkAction = {
     kind: "reset-password";
@@ -13,14 +15,21 @@ export type EmailLinkAction = {
 } | {
     kind: "verify-email";
     token: string;
+} | {
+    kind: "confirm-email-change";
+    token: string;
+} | {
+    kind: "magic-link";
+    token: string;
 };
 export declare function readEmailLinkAction(location: {
     pathname: string;
     search: string;
 }): EmailLinkAction | null;
 /**
- * Where the app lives: the link's own address without the action segment and
- * its token. `/admin/reset-password?token=…` becomes `/admin/`.
+ * Where the app lives: the link's own address without the action's path and
+ * its token. `/admin/reset-password?token=…` becomes `/admin/`, and
+ * `/admin/auth/magic-link?token=…` too.
  */
 export declare function appAddressOfEmailLink(location: {
     origin: string;

package/dist/components/LoginView/index.d.ts

@@ -1,2 +1,4 @@
 export { LoginView } from "./LoginView.js";
 export type { LoginViewProps } from "./LoginView.js";
+export { readEmailLinkAction } from "./email-link.js";
+export type { EmailLinkAction } from "./email-link.js";

package/dist/components/UserSelectPopover.d.ts

@@ -28,6 +28,19 @@ export interface UserSelectPopoverProps {
      * Whether users are currently loading.
      */
     loading?: boolean;
+    /**
+     * Called with the search text each time it changes (debounced), for a
+     * parent that searches its users on a server rather than passing them all
+     * in `users`. The list is still filtered here by the same text.
+     */
+    onSearchTextChange?: (searchText: string) => void;
+    /**
+     * For a parent that lists only the first page of a server search: how many
+     * users that search matched in all. Leave it out when `users` holds every
+     * match. When set, the header counts the listed users against it and a
+     * notice says the others are not listed.
+     */
+    totalCount?: number;
     /**
      * The current user (displayed as the "self" option at the top).
      */
@@ -60,4 +73,4 @@ export interface UserSelectPopoverProps {
  *
  * @group Components
  */
-export declare function UserSelectPopover({ selectedUser, onUserSelected, users, loading, currentUser, defaultLabel, renderLimit, className, size }: UserSelectPopoverProps): React.JSX.Element;
+export declare function UserSelectPopover({ selectedUser, onUserSelected, users, loading, onSearchTextChange, totalCount, currentUser, defaultLabel, renderLimit, className, size }: UserSelectPopoverProps): React.JSX.Element;

package/dist/components/common/useColumnsIds.d.ts

@@ -12,8 +12,8 @@ export declare function getSubcollectionColumnId(collection: AdminCollection<any
  * Every child view gets a 200px button column that opens its tab. For a relation
  * declared in `relations` that button is the relation's only presence in the
  * table. For one declared as a property it is the second: the property's own
- * column is already there, hydrated by the list fetch's `include: ["*"]`, showing
- * the child rows themselves — and carrying the *same heading*, because the tab
+ * column is already there, hydrated by the list fetch's `include`
+ * (`getRelationIncludeParams`), showing the child rows themselves — and carrying the *same heading*, because the tab
  * takes its name from the declaring property. Two columns called "Applications",
  * one of them a button, and nothing in the header to tell them apart.
  *

package/dist/components/common/useDataTableController.d.ts

@@ -2,6 +2,12 @@ import { Entity, FilterValues, User } from "@rebasepro/types";
 import { EntityTableController, AdminCollection } from "@rebasepro/cms-types";
 import { ScrollRestorationController } from "./useScrollRestoration.js";
 export declare const DEFAULT_PAGE_SIZE = 50;
+/**
+ * Rows held with `pagination: false` past which development builds warn. The
+ * docs promise every row, so they are all loaded; but tens of thousands of
+ * them sit in memory and re-render on every change, and nothing said so.
+ */
+export declare const UNPAGINATED_WARNING_ROWS = 10000;
 export type DataTableControllerProps<M extends Record<string, any> = any> = {
     /**
      * Full path where the data of this table is located
@@ -26,6 +32,14 @@ export type DataTableControllerProps<M extends Record<string, any> = any> = {
      * When set to true the filters and sort will be updated in the URL
      */
     updateUrl?: boolean;
+    /**
+     * Read rows at all. Defaults to `true`. `false` closes the subscription and
+     * reads nothing — for a view that keeps the controller for its search and
+     * filters but draws its rows some other way, like the board, whose columns
+     * each read their own. The rows already held stay until it is enabled
+     * again, which reads afresh.
+     */
+    enabled?: boolean;
 };
 /**
  * Use this hook to build a controller for the {@link DataCollectionTable}.
@@ -42,4 +56,4 @@ export type DataTableControllerProps<M extends Record<string, any> = any> = {
  * @param fixedFilterFromProps
  * @param updateUrl
  */
-export declare function useDataTableController<M extends Record<string, any> = any, USER extends User = User>({ path, collection, scrollRestoration, entitiesDisplayedFirst, lastDeleteTimestamp, fixedFilter: fixedFilterFromProps, updateUrl }: DataTableControllerProps<M>): EntityTableController<M>;
+export declare function useDataTableController<M extends Record<string, any> = any, USER extends User = User>({ path, collection, scrollRestoration, entitiesDisplayedFirst, lastDeleteTimestamp, fixedFilter: fixedFilterFromProps, updateUrl, enabled }: DataTableControllerProps<M>): EntityTableController<M>;

package/dist/components/common/useScrollRestoration.d.ts

@@ -1,4 +1,18 @@
 import { Entity, FilterValues } from "@rebasepro/types";
+/**
+ * Where a collection view was, and the rows to show when it comes back.
+ *
+ * `data` is the rows around what was on screen — a page either side, when the
+ * view reports what it draws — starting at row `dataOffset` (0 when absent:
+ * `data` then starts at the first row). It used to be every row the view held,
+ * which a table scrolled to 100,000 rows kept for the rest of the session and
+ * read again in full on the way back.
+ */
+export type CollectionScrollEntry = {
+    scrollOffset: number;
+    data: Entity<any>[];
+    dataOffset?: number;
+};
 /**
  * Forget every collection's scroll position and the rows kept with it.
  *
@@ -7,15 +21,10 @@ import { Entity, FilterValues } from "@rebasepro/types";
  */
 export declare function clearCollectionScrollCache(): void;
 export type ScrollRestorationController = {
-    getCollectionScroll: (path: string, filters?: FilterValues<any>) => {
-        scrollOffset: number;
-        data: Entity<any>[];
-    } | undefined;
-    updateCollectionScroll: (props: {
+    getCollectionScroll: (path: string, filters?: FilterValues<any>) => CollectionScrollEntry | undefined;
+    updateCollectionScroll: (props: CollectionScrollEntry & {
         path: string;
-        scrollOffset: number;
         filters?: FilterValues<any>;
-        data: Entity<any>[];
     }) => void;
 };
 export declare function useScrollRestoration(): ScrollRestorationController;

package/dist/components/email-change-message.d.ts

@@ -0,0 +1,6 @@
+/**
+ * What the settings screen and the link's screen say about a refused address
+ * change: the codes a person can act on get the panel's own, translated words,
+ * and anything else keeps the server's message.
+ */
+export declare function emailChangeErrorMessage(error: unknown, t: (key: string) => string): string;

package/dist/components/index.d.ts

@@ -13,3 +13,4 @@ export * from "./UserDisplay.js";
 export * from "./LoginView/index.js";
 export * from "./RebaseAuth.js";
 export * from "./SchemaDriftBanner.js";
+export * from "./ConnectionLostBanner.js";

package/dist/contexts/CollectionResolverContext.d.ts

@@ -5,6 +5,12 @@ import React from "react";
 export type CollectionResolver = (slug: string) => {
     properties?: Record<string, unknown>;
 } | undefined;
+/**
+ * Translate the path a collection is addressed by into the path its driver
+ * stores it under — `fs_diagnosis` into `diagnosis`, for a Firestore collection
+ * that declares `path: "diagnosis"`. See `EntityDataOptions.resolveDataPath`.
+ */
+export type DataPathResolver = (path: string) => string | undefined;
 /**
  * Lets the layer that owns the collections hand a resolver *up* to the data
  * layer, which needs a collection's primary keys to give its rows an address.
@@ -15,9 +21,20 @@ export type CollectionResolver = (slug: string) => {
  * prop without giving every headless BaaS app a collections argument it has no
  * use for.
  *
+ * The same layer knows where each collection is stored, so it hands up the
+ * data-path translation alongside: a direct driver has to be given a
+ * collection's declared `path`, and only the registry knows it.
+ *
  * Registration is a ref write, so it is safe to call during render — and it has
  * to be. The views that fetch rows are *below* the registrar, and child effects
  * run before parent effects, so registering in an effect would bind after the
  * first page of rows had already been converted.
+ *
+ * Several layers may own collections at once — the CMS navigation, and each
+ * standalone `CollectionsProvider` on a page — so each registers under its own
+ * `owner` (`"default"` when omitted). A lookup asks every owner and takes the
+ * first that knows the collection. Registering nothing (`undefined` for both)
+ * removes that owner's registration.
  */
-export declare const CollectionResolverRegistrationContext: React.Context<(resolver: CollectionResolver | undefined) => void>;
+export type CollectionResolverRegistration = (resolver: CollectionResolver | undefined, resolveDataPath?: DataPathResolver, owner?: string) => void;
+export declare const CollectionResolverRegistrationContext: React.Context<CollectionResolverRegistration>;

package/dist/contexts/StorageSourcesContext.d.ts

@@ -14,6 +14,12 @@ export interface StorageSourcesContextValue {
     registry: Record<string, StorageSourceDefinition>;
     /** Built {@link StorageSource} for direct sources, keyed by key. */
     sources: Record<string, StorageSource>;
+    /**
+     * A server-routed source for a key not (yet) in `sources` — requests carry
+     * `?storageId=<key>`, so the server serves it or refuses naming it, rather
+     * than the panel guessing the default. Absent without a client.
+     */
+    createSource?: (key: string) => StorageSource;
 }
 /** @internal */
 export declare const StorageSourcesContext: React.Context<StorageSourcesContextValue>;

package/dist/core/RebaseProps.d.ts

@@ -45,6 +45,7 @@ type DeepPartial<T> = T extends object ? {
  */
 export type { EffectiveRoleController } from "@rebasepro/types";
 import type { EffectiveRoleController } from "@rebasepro/types";
+import type { ModeController } from "../hooks/useModeController.js";
 /**
  * Props for the main {@link Rebase} component.
  *
@@ -265,6 +266,26 @@ export type RebaseProps<USER extends User, DB = unknown> = {
      * Controller to simulate different roles when dev mode is active.
      */
     effectiveRoleController?: EffectiveRoleController;
+    /**
+     * The light/dark mode, owned by the host app.
+     *
+     * Without it, `<Rebase>` owns the page's theme: it puts the `dark` class on
+     * `<html>`, follows `prefers-color-scheme`, remembers the user's pick in
+     * localStorage, and takes its class away when it unmounts. Pass one when
+     * your app already has a theme — Rebase then reads `mode` from it, calls
+     * its `setMode` from its own theme toggle, and touches none of the above.
+     *
+     * @example
+     * ```tsx
+     * const [mode, setMode] = useState<"light" | "dark">("light");
+     * const modeController = useMemo(() => ({
+     *     mode,
+     *     setMode: (next: "light" | "dark" | "system") => setMode(next === "dark" ? "dark" : "light")
+     * }), [mode]);
+     * <Rebase client={client} modeController={modeController}>…</Rebase>
+     * ```
+     */
+    modeController?: ModeController;
     /**
      * Override or extend any Rebase UI string, keyed by locale.
      */

package/dist/core/deprecated_plugin_keys.d.ts

@@ -0,0 +1,10 @@
+import type { RebasePlugin } from "@rebasepro/cms-types";
+/**
+ * Warn, once per plugin and key, about plugin keys that are declared on
+ * `RebasePlugin` but that nothing has ever called.
+ *
+ * A plugin that set one of these did nothing and said nothing about it. The
+ * types mark them deprecated; this names them at runtime too, which also
+ * reaches a plugin written in JavaScript.
+ */
+export declare function warnDeprecatedPluginKeys(plugins: readonly RebasePlugin[]): void;