@rebasepro/app 0.24.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/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/contexts/CollectionResolverContext.d.ts

@@ -29,5 +29,12 @@ export type DataPathResolver = (path: string) => string | undefined;
  * 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, resolveDataPath?: DataPathResolver) => 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;