@rebasepro/cms 0.22.0 → 0.24.0

package/dist/components/CollectionTableBinding/fields/TableMultipleRelationField.d.ts

@@ -1,18 +1,21 @@
 import React from "react";
 import { EntityRelation, FilterValues, Relation } from "@rebasepro/types";
-import { CollectionSize, AdminCollection } from "@rebasepro/cms-types";
+import { AdminCollection } from "@rebasepro/cms-types";
 type TableMultipleRelationFieldProps = {
     name: string;
     disabled: boolean;
     internalValue: EntityRelation[] | undefined | null;
     updateValue: (newValue: EntityRelation[] | null) => void;
-    size: CollectionSize;
     previewProperties?: string[];
-    title?: string;
     relation: Relation;
     fixedFilter?: FilterValues<string>;
     includeId?: boolean;
     includeEntityLink?: boolean;
+    /** The cell is selected. */
+    selected?: boolean;
+    /** See `TableRelationField`. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
 };
 export declare function TableMultipleRelationField(props: TableMultipleRelationFieldProps): React.JSX.Element;
 export declare const TableMultipleRelationFieldInternal: React.MemoExoticComponent<(props: TableMultipleRelationFieldProps & {

package/dist/components/CollectionTableBinding/fields/TableReferenceField.d.ts

@@ -9,11 +9,18 @@ type TableReferenceFieldProps = {
     size: CollectionSize;
     multiselect: boolean;
     previewProperties?: string[];
-    title?: string;
     path: string;
     fixedFilter?: FilterValues<string>;
     includeId?: boolean;
     includeEntityLink?: boolean;
+    /** The cell is selected. */
+    selected?: boolean;
+    /**
+     * Set by the cell's opener: opens the selection dialog, and is handed
+     * back as closed at once — the dialog keeps its own state from there.
+     */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
 };
 export declare function TableReferenceField(props: TableReferenceFieldProps): React.JSX.Element;
 export declare const TableReferenceFieldInternal: React.MemoExoticComponent<(props: TableReferenceFieldProps & {

package/dist/components/CollectionTableBinding/fields/TableRelationField.d.ts

@@ -9,11 +9,18 @@ type TableRelationFieldProps = {
     size: CollectionSize;
     multiselect: boolean;
     previewProperties?: string[];
-    title?: string;
     relation: Relation;
     fixedFilter?: FilterValues<string>;
     includeId?: boolean;
     includeEntityLink?: boolean;
+    /** The cell is selected. */
+    selected?: boolean;
+    /**
+     * Set by the cell's opener: opens the selection dialog, and is handed
+     * back as closed at once — the dialog keeps its own state from there.
+     */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
 };
 export declare function TableRelationField(props: TableRelationFieldProps): React.JSX.Element;
 export declare const TableRelationFieldInternal: React.MemoExoticComponent<(props: TableRelationFieldProps & {

package/dist/components/CollectionTableBinding/fields/TableRelationSelectorField.d.ts

@@ -13,9 +13,19 @@ interface RelationSelectorFieldProps {
     relation: Relation;
     /** Force filter to be applied to the relation search */
     fixedFilter?: FilterValues<string>;
-    /** Collection size for display */
-    size?: "compact" | "small" | "medium";
+    /** The cell is selected: the trigger takes the focus, so Enter opens the list. */
+    focused?: boolean;
+    /** Whether the list is open. Set by the cell's opener as well as the trigger. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * What the cell shows at rest. The trigger shows the same node, so a
+     * selected cell looks like an unselected one.
+     */
+    preview?: React.ReactNode;
+    /** The cell: the list opens against it rather than against the trigger. */
+    anchorRef?: React.RefObject<HTMLElement | null>;
 }
 /** Thin wrapper around RelationSelector for table cells */
-export declare function TableRelationSelectorField({ disabled, internalValue, updateValue, relation, fixedFilter, size }: RelationSelectorFieldProps): React.JSX.Element;
+export declare function TableRelationSelectorField({ disabled, internalValue, updateValue, relation, fixedFilter, focused, open, onOpenChange, preview, anchorRef }: RelationSelectorFieldProps): React.JSX.Element;
 export {};

package/dist/components/CollectionTableBinding/fields/VirtualTableSelect.d.ts

@@ -11,5 +11,15 @@ export declare function VirtualTableSelect(props: {
     valueType: "string" | "number";
     updateValue: (newValue: (string | number | string[] | number[] | null)) => void;
     focused: boolean;
+    /** Whether the list is open. Set by the cell's opener as well as the trigger. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * What the cell shows at rest. The trigger shows the same node, so a
+     * selected cell looks like an unselected one; the chevron is the cell's.
+     */
+    preview?: React.ReactNode;
+    /** The cell: the list opens against it rather than against the trigger. */
+    anchorRef?: React.RefObject<HTMLElement | null>;
     onBlur?: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
 }): React.JSX.Element;

package/dist/components/CollectionTableBinding/fields/VirtualTableUserSelect.d.ts

@@ -8,5 +8,15 @@ export declare function VirtualTableUserSelect(props: {
     internalValue: string | string[] | undefined;
     updateValue: (newValue: (string | string[] | null)) => void;
     focused: boolean;
+    /** Whether the list is open. Set by the cell's opener as well as the trigger. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * What the cell shows at rest. The trigger shows the same node, so a
+     * selected cell looks like an unselected one.
+     */
+    preview?: React.ReactNode;
+    /** The cell: the list opens against it rather than against the trigger. */
+    anchorRef?: React.RefObject<HTMLElement | null>;
     onBlur?: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
 }): React.JSX.Element;

package/dist/components/CollectionTableBinding/internal/EntityTableCell.d.ts

@@ -1,5 +1,18 @@
 import React from "react";
 import { TableSize } from "@rebasepro/app";
+import { TableCellOpenerKind } from "./TableCellOpener.js";
+export interface EntityTableCellOpener {
+    kind: TableCellOpenerKind;
+    open: boolean;
+    /** See {@link TableCellOpener}'s `focusOnSelect`. */
+    focusOnSelect: boolean;
+    label: string;
+    /**
+     * Whether the editor should now be open, and the cell's rect for editors
+     * positioned against it. The cell is selected before this is called.
+     */
+    onToggle: (open: boolean, cellRect: DOMRect | undefined) => void;
+}
 interface EntityTableCellProps {
     children: React.ReactNode;
     actions?: React.ReactNode;
@@ -20,6 +33,14 @@ interface EntityTableCellProps {
     fullHeight?: boolean;
     selected?: boolean;
     hideOverflow?: boolean;
+    /**
+     * The control that opens the cell's editor, revealed on hover and kept
+     * shown while the cell is selected. The cell keeps a slot for it at its
+     * trailing edge either way, so it never moves the value.
+     */
+    opener?: EntityTableCellOpener;
+    /** The cell's element, for editors that float and are positioned against it. */
+    cellRef?: React.RefObject<HTMLDivElement | null>;
     onSelect?: (cellRect: DOMRect | undefined) => void;
     sortableNodeRef?: (node: HTMLElement | null) => void;
     sortableStyle?: React.CSSProperties;

package/dist/components/CollectionTableBinding/internal/TableCellOpener.d.ts

@@ -0,0 +1,45 @@
+import React from "react";
+/**
+ * What a cell's opener opens.
+ *
+ * - `dropdown`: a list anchored to the cell — an enum, a user, an inline
+ *   relation picker.
+ * - `dialog`: the selection dialog of a reference, or of a relation drawn with
+ *   the dialog widget. Same chevron: to the person editing, both change which
+ *   record the cell points at.
+ * - `calendar`: the date picker.
+ * - `expand`: the popup form, for values with no editor of their own in a
+ *   cell (maps, arrays, custom fields).
+ */
+export type TableCellOpenerKind = "dropdown" | "dialog" | "calendar" | "expand";
+export interface TableCellOpenerProps {
+    kind: TableCellOpenerKind;
+    /** The editor it opens is open: the chevron turns over and stays shown. */
+    open: boolean;
+    /** The cell is selected: the opener is shown whether or not it is hovered. */
+    selected: boolean;
+    /**
+     * Take the focus when the cell is selected, so Enter opens the editor.
+     * Off when the editor's own trigger takes it instead.
+     */
+    focusOnSelect: boolean;
+    label: string;
+    /**
+     * Called on a click, with whether the editor should now be open. A click
+     * while it is open closes it rather than opening it a second time.
+     */
+    onToggle: (open: boolean) => void;
+}
+/**
+ * The one control a cell reveals to open its editor.
+ *
+ * A cell looks the same at rest, hovered and selected: the value, in the same
+ * place. This is the only thing that appears — on hover, and for as long as
+ * the cell is selected — in a slot the cell keeps for it whether it is shown
+ * or not, so revealing it moves nothing.
+ *
+ * One click on it opens the editor, from rest: it selects the cell on the way.
+ * It never takes the focus on a mouse press, because the cell selects itself
+ * on focus and doing so first would re-render the cell under the pointer.
+ */
+export declare function TableCellOpener({ kind, open, selected, focusOnSelect, label, onToggle }: TableCellOpenerProps): React.JSX.Element;

package/dist/components/CollectionTableBinding/table_bindings.d.ts

@@ -1,6 +1,7 @@
 import React from "react";
 import { Entity, Property } from "@rebasepro/types";
 import { TableSize } from "@rebasepro/app";
+import { TableCellOpenerKind } from "./internal/TableCellOpener.js";
 export interface TableFieldBindingProps<T = unknown> {
     propertyKey: string;
     property: Property;
@@ -15,9 +16,32 @@ export interface TableFieldBindingProps<T = unknown> {
     entity: Entity<Record<string, unknown>>;
     path: string;
     openPopup?: (cellRect: DOMRect | undefined) => void;
+    /**
+     * Whether the cell's floating editor is open — its dropdown, its selection
+     * dialog, its date picker. The cell's opener sets it as well as the
+     * editor's own trigger, and it can be set before the editor has mounted.
+     */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * What the cell shows at rest. An editor with a trigger shows this same
+     * node in it, so selecting the cell changes its frame and nothing else.
+     */
+    preview?: React.ReactNode;
+    /**
+     * The cell's element. A floating editor opens against it rather than
+     * against its own trigger, which can be taller than the cell clipping it.
+     */
+    anchorRef?: React.RefObject<HTMLElement | null>;
 }
 export interface TableFieldConfig {
     Component: React.ComponentType<TableFieldBindingProps>;
+    /**
+     * The opener the cell reveals on hover, and keeps shown while selected,
+     * to open this editor in one click. None for editors that are the value
+     * itself (a text input, a switch) or that draw their own (storage).
+     */
+    opener?: TableCellOpenerKind;
     fullHeight?: boolean;
     allowScroll?: boolean;
     removePadding?: boolean;

package/dist/components/CollectionViewBinding/CollectionViewActions.d.ts

@@ -14,6 +14,11 @@ export type CollectionViewActionsProps<M extends Record<string, unknown>> = {
      */
     onAddExistingClick?: () => void;
     onMultipleDeleteClick: () => void;
+    /**
+     * The rows are shared with other records through a junction, so removing
+     * them unlinks them from this record and deletes nothing. The bin says so.
+     */
+    removeUnlinks?: boolean;
     selectionController: SelectionController<M>;
     tableController: EntityTableController<M>;
     collectionEntitiesCount?: number;
@@ -21,4 +26,4 @@ export type CollectionViewActionsProps<M extends Record<string, unknown>> = {
     children?: React.ReactNode;
     openNewDocument: (defaultValues?: Record<string, unknown>) => void;
 };
-export declare function CollectionViewActions<M extends Record<string, unknown>>({ collection, relativePath, parentCollectionSlugs, parentEntityIds, onNewClick, onAddExistingClick, onMultipleDeleteClick, selectionEnabled, path, selectionController, tableController, collectionEntitiesCount, compact, children, openNewDocument }: CollectionViewActionsProps<M>): React.JSX.Element;
+export declare function CollectionViewActions<M extends Record<string, unknown>>({ collection, relativePath, parentCollectionSlugs, parentEntityIds, onNewClick, onAddExistingClick, onMultipleDeleteClick, removeUnlinks, selectionEnabled, path, selectionController, tableController, collectionEntitiesCount, compact, children, openNewDocument }: CollectionViewActionsProps<M>): React.JSX.Element;

package/dist/components/CollectionViewBinding/CollectionViewBinding.d.ts

@@ -7,8 +7,11 @@ import React from "react";
  */
 export type CollectionViewBindingProps<M extends Record<string, unknown>> = {
     /**
-     * Complete path where this collection is located.
-     * It defaults to the collection path if not provided.
+     * The path the collection is addressed by: its slug, or for a
+     * subcollection `parentSlug/{id}/slug`. Defaults to the collection's slug.
+     * Not the `path` a Firestore or MongoDB collection declares for its store:
+     * the data layer translates to that one, and another collection's slug may
+     * be spelled the same.
      */
     path?: string;
     /**
@@ -41,7 +44,7 @@ export type CollectionViewBindingProps<M extends Record<string, unknown>> = {
     selectedTab?: string;
 } & AdminCollection<M>;
 export declare const CollectionViewBinding: React.FunctionComponent<CollectionViewBindingProps<any>>;
-export declare function EntitiesCount({ path, collection, filter, sortBy, searchString, onCountChange }: {
+export declare function EntitiesCount({ path, collection, filter, sortBy, searchString, onCountChange, refreshKey }: {
     path: string;
     collection: AdminCollection;
     filter?: FilterValues<any>;
@@ -55,4 +58,10 @@ export declare function EntitiesCount({ path, collection, filter, sortBy, search
      */
     searchString: string | undefined;
     onCountChange?: (count: number | null | undefined) => void;
+    /**
+     * Counts again whenever this changes. The count is one read, not a
+     * subscription: after a delete the toolbar kept the old total, and "select
+     * all matching" offered it over the rows that were left.
+     */
+    refreshKey?: number;
 }): null;

package/dist/components/CollectionViewBinding/FiltersDialog.d.ts

@@ -1,6 +1,11 @@
 import type { Property } from "@rebasepro/types";
 import React from "react";
 import { FilterValues } from "@rebasepro/types";
+/**
+ * The properties the dialog lists, each with a filter field: every property
+ * that can be filtered, bar the collection's fixed-filter fields.
+ */
+export declare function getFilterableProperties(properties: Record<string, Property>, fixedFilter?: FilterValues<string>, engine?: string): [string, Property][];
 export interface FiltersDialogProps {
     open: boolean;
     onOpenChange: (open: boolean) => void;

package/dist/components/EditViewBinding.d.ts

@@ -82,11 +82,17 @@ export interface EditViewBindingProps<M extends Record<string, unknown> = Record
  * a record is opened.
  */
 export declare function EditViewBinding<M extends Record<string, unknown>>({ entityId, ...props }: EditViewBindingProps<M>): React.JSX.Element;
-export declare function EditViewBindingInner<M extends Record<string, unknown>>({ path, entityId, selectedTab: selectedTabProp, collection, parentCollectionSlugs, parentEntityIds, onValuesModified, onSaved, onTabChange, navigateBack, onCloseRequest, entity, initialDirtyValues, dataLoading, layout, barActions, barActionsStart, onShowList, status, setStatus, formProps, canEdit }: EditViewBindingProps<M> & {
+export declare function EditViewBindingInner<M extends Record<string, unknown>>({ path, entityId, selectedTab: selectedTabProp, collection, parentCollectionSlugs, parentEntityIds, onValuesModified, onSaved, onTabChange, navigateBack, onCloseRequest, entity, initialDirtyValues, dataLoading, layout, barActions, barActionsStart, onShowList, status, setStatus, formProps, canEdit, deletedElsewhere }: EditViewBindingProps<M> & {
     entity?: Entity<M>;
     initialDirtyValues?: Partial<M>;
     dataLoading: boolean;
     status: EntityStatus;
     setStatus: (status: EntityStatus) => void;
     canEdit?: boolean;
+    /**
+     * The record was deleted by someone else while this form had it open. The
+     * form keeps its values; saving them over the record is no longer
+     * possible, saving them as a new one is.
+     */
+    deletedElsewhere?: boolean;
 }): React.JSX.Element;

package/dist/components/EntityIdentityBar.d.ts

@@ -1,6 +1,24 @@
 import type { AdminCollection } from "@rebasepro/cms-types";
 import type { EntityStatus } from "@rebasepro/types";
 import React from "react";
+import type { PlacedEntityActions } from "../util/entity_actions.js";
+/**
+ * One of the record's own actions, resolved and ready to run — what the bar
+ * needs to draw it as a button or as a menu item.
+ */
+export interface RecordActionItem {
+    key: string;
+    name: string;
+    icon?: React.ReactNode;
+    enabled: boolean;
+    /** Why it is disabled, when it is and its action says. */
+    disabledReason?: string;
+    /**
+     * Runs the action, reporting its own failure. Returns a promise only when
+     * the action is asynchronous, which is what keeps a button's spinner up.
+     */
+    run: () => Promise<void> | undefined;
+}
 export interface EntityIdentityBarProps {
     /** Plural collection name, shown as the breadcrumb ahead of the title. */
     collection: AdminCollection;
@@ -68,10 +86,17 @@ export interface EntityIdentityBarProps {
     externalLink?: string;
     /**
      * Actions performed *on* the record — copy, delete, whatever the collection
-     * adds — as menu items under the overflow button. They live here rather
-     * than in a footer, which is what let the footer go away entirely.
+     * adds — already placed: `inline` ones are buttons ahead of Save, folding
+     * into the overflow menu when the bar runs short of room, and the rest are
+     * menu groups. They live here rather than in a footer, which is what let
+     * the footer go away entirely.
+     */
+    recordActions?: PlacedEntityActions<RecordActionItem>;
+    /**
+     * The read-only view's Edit: its main button, drawn where Save stands on
+     * the edit view — after the record's own buttons, ahead of the menu.
      */
-    recordActions?: React.ReactNode;
+    primaryAction?: React.ReactNode;
     /** Plugin-contributed actions, rendered inline before Save. */
     pluginActions?: React.ReactNode;
     /** Close / full-screen buttons supplied by the panel that owns this view. */
@@ -92,7 +117,7 @@ export interface EntityIdentityBarProps {
  * editing. They live here instead, and the left half of a bar that was
  * previously empty now does the work.
  */
-export declare function EntityIdentityBar({ collection, collectionUrl, title, entityId, status, dirty, saving, onSave, onDiscard, saveDisabled, hasErrors, onSaveAndClose, saveAndClosePlacement, onClose, onBack, onInspect, onViewHistory, externalLink, recordActions, pluginActions, trailing, leading }: EntityIdentityBarProps): React.JSX.Element;
+export declare function EntityIdentityBar({ collection, collectionUrl, title, entityId, status, dirty, saving, onSave, onDiscard, saveDisabled, hasErrors, onSaveAndClose, saveAndClosePlacement, onClose, onBack, onInspect, onViewHistory, externalLink, recordActions, primaryAction, pluginActions, trailing, leading }: EntityIdentityBarProps): React.JSX.Element;
 export type EntitySaveActionsProps = Pick<EntityIdentityBarProps, "status" | "dirty" | "saving" | "onSave" | "onDiscard" | "saveDisabled" | "hasErrors" | "onSaveAndClose" | "saveAndClosePlacement">;
 /**
  * Save, "save and close", Discard, and the words saying where the edit stands.

package/dist/components/EntityPreviewBinding.d.ts

@@ -1,6 +1,7 @@
 import * as React from "react";
 import { Entity } from "@rebasepro/types";
 import type { PreviewSize } from "../types/components/PropertyPreviewProps.js";
+import { EntityPreviewLayout } from "./EntityPreviewNesting.js";
 import type { AdminCollection } from "@rebasepro/cms-types";
 export type EntityPreviewBindingProps = {
     size?: PreviewSize;
@@ -28,12 +29,18 @@ export type EntityPreviewBindingDataProps = {
     includeTitle?: boolean;
     includeEntityLink?: boolean;
     includeImage?: boolean;
+    /**
+     * `row` draws the record as a line of a table row instead of a card: see
+     * {@link EntityPreviewLayout}. No id, no open button — the title opens the
+     * record — and only as many supporting lines as the row has room for.
+     */
+    layout?: EntityPreviewLayout;
 };
 /**
  * This component contains the main logic and content for displaying a entity preview,
  * without any container wrapper. Used internally by EntityPreviewBinding.
  */
-export declare function EntityPreviewBindingData({ actions, collection: collectionProp, previewKeys, size, includeId, onSidePanelClick, includeTitle, includeEntityLink, includeImage, entity }: EntityPreviewBindingDataProps): React.JSX.Element;
+export declare function EntityPreviewBindingData({ actions, collection: collectionProp, previewKeys, size, includeId, onSidePanelClick, includeTitle, includeEntityLink, includeImage, layout, entity }: EntityPreviewBindingDataProps): React.JSX.Element;
 export declare function EntityPreviewBindingWithId({ entityId, path, ...props }: Omit<EntityPreviewBindingProps, "entity"> & {
     entityId: string | number;
     path: string;

package/dist/components/EntityPreviewNesting.d.ts

@@ -23,3 +23,18 @@ export declare function NestedEntityPreviewBoundary({ children }: {
 export declare function RootEntityPreviewBoundary({ children }: {
     children: React.ReactNode;
 }): React.JSX.Element;
+/**
+ * How a top-level reference or relation preview is laid out.
+ *
+ * `card` is the form's: a bordered box with the record's id, title, preview
+ * properties and a button to open it. `row` is a table cell's: the same
+ * record as a line of the row it sits in — image, a title that opens it, one
+ * supporting line — with no box of its own, because the cell is the box and
+ * a card is taller than a row.
+ */
+export type EntityPreviewLayout = "card" | "row";
+export declare function useEntityPreviewLayout(): EntityPreviewLayout;
+/** Lays out the previews below it as rows. See {@link EntityPreviewLayout}. */
+export declare function RowEntityPreviewLayout({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;

package/dist/components/NavigationLoadingErrorView.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+/**
+ * The collections or views could not be resolved: a `collections` or `views`
+ * builder threw, or a plugin's `modifyCollections` did, or something either of
+ * them awaited failed.
+ *
+ * That failure used to be caught, logged and stored as
+ * `navigationLoadingError`, and then read by nothing: the home page rendered
+ * an empty search bar and a deep link to a collection spun for ever, or said
+ * the collection was not registered — the wrong cause. This says what failed
+ * and offers the retry the navigation controller already had.
+ */
+export declare function NavigationLoadingErrorView({ error, onRetry }: {
+    error: Error;
+    onRetry?: () => void;
+}): React.JSX.Element;

package/dist/components/PickerTrigger.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+/**
+ * The trigger of a picker's popover, or — given an anchor — a plain child
+ * beside a `Popover.Anchor` on that element.
+ *
+ * Both at once does not work: Radix's `Trigger` registers itself as the
+ * anchor through a ref callback, and a custom anchor through an effect that
+ * only reports a change. Under StrictMode the ref callback runs again after
+ * the effect, the effect sees nothing new, and the popover stays anchored to
+ * a trigger that the custom anchor then unmounts — it opened at the window's
+ * top-left corner. The pickers open and close themselves, so they lose
+ * nothing by leaving the `Trigger` out.
+ */
+export declare function PickerTrigger({ anchorRef, children }: {
+    anchorRef?: React.RefObject<HTMLElement | null>;
+    children: React.ReactElement;
+}): React.JSX.Element;

package/dist/components/ReferenceTable/SelectionTableBinding.d.ts

@@ -38,6 +38,18 @@ export interface SelectionProps<M extends Record<string, unknown>> {
      * @callback
      */
     onMultipleEntitiesSelected?(entities: Entity<any>[]): void;
+    /**
+     * Called once, with the final selection, when the user presses Done.
+     *
+     * `onMultipleEntitiesSelected` reports every tick as it happens, which is
+     * right when the selection *is* the value (a reference field). Use this
+     * one instead when acting on the selection writes something — linking
+     * rows, say — so a row ticked and then unticked, or a selection cleared,
+     * is never acted on.
+     * @param entities
+     * @callback
+     */
+    onSelectionDone?(entities: Entity<M>[]): void;
     /**
      * Allow selection of entities that pass the given filter only.
      */

package/dist/components/RelationSelector.d.ts

@@ -20,13 +20,10 @@ export interface RelationSelectorProps {
      * scale, so a relation picker lines up with the text field beside it.
      *
      * `small` and `medium` predate that scale (42 and 56) and are kept as they
-     *
-     * `compact` is the 32px trigger for a selected table cell in a text row:
-     * the chosen records as inline lines (each opens its record), a chevron,
-     * nothing else.
-     * are because the table cells and the filter row are built around them.
+     * are because the filter row is built around them. A table cell passes
+     * `triggerContent` instead, and has no size of its own.
      */
-    size?: "compact" | "small" | "medium" | "large";
+    size?: "small" | "medium" | "large";
     useChips?: boolean;
     disabled?: boolean;
     invisible?: boolean;
@@ -64,6 +61,26 @@ export interface RelationSelectorProps {
      */
     emptyCollectionText?: string;
     loadingText?: string;
+    /**
+     * Whether the list is open, for a caller that opens it from outside the
+     * trigger — a table cell's opener. Every open and close the selector
+     * makes itself is reported through `onOpenChange`, controlled or not.
+     */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Replaces everything the trigger draws — the value, the box, its padding
+     * and the chevron — with this node. For a caller that frames the picker
+     * itself: a table cell passes the preview it shows at rest, so the cell
+     * looks the same whether the picker is mounted, closed or open.
+     */
+    triggerContent?: React.ReactNode;
+    /**
+     * Positions the list against this element instead of the trigger. A
+     * table cell passes itself: the trigger inside it can be taller than the
+     * cell that clips it, and the list belongs under what can be seen.
+     */
+    anchorRef?: React.RefObject<HTMLElement | null>;
     /**
      * Whether the open list offers to create a row in the target collection.
      * Defaults to `true`. The offer is shown only when the user could actually
@@ -73,4 +90,4 @@ export interface RelationSelectorProps {
      */
     allowCreate?: boolean;
 }
-export declare const RelationSelector: React.ForwardRefExoticComponent<RelationSelectorProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const RelationSelector: React.ForwardRefExoticComponent<RelationSelectorProps & React.RefAttributes<HTMLElement>>;

package/dist/components/UserSelector.d.ts

@@ -21,5 +21,12 @@ export interface UserSelectorProps {
     searchPlaceholder?: string;
     noResultsText?: string;
     loadingText?: string;
+    /** See `RelationSelector`'s `open`. */
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** See `RelationSelector`'s `triggerContent`. */
+    triggerContent?: React.ReactNode;
+    /** See `RelationSelector`'s `anchorRef`. */
+    anchorRef?: React.RefObject<HTMLElement | null>;
 }
-export declare const UserSelector: React.ForwardRefExoticComponent<UserSelectorProps & React.RefAttributes<HTMLButtonElement>>;
+export declare const UserSelector: React.ForwardRefExoticComponent<UserSelectorProps & React.RefAttributes<HTMLElement>>;

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

@@ -0,0 +1,15 @@
+import React from "react";
+/**
+ * An action's name in a menu and, when it is unavailable and says why, the
+ * reason on a line beneath it.
+ *
+ * In the text rather than a tooltip: a disabled menu item cannot be focused or
+ * hovered into anything, and on a touch screen there is no hover at all — the
+ * reason has to be readable where the item is. It is drawn in the label's own
+ * ink, a size down, because the item dims everything it holds: a muted colour
+ * under that dimming fell below legible.
+ */
+export declare function ActionMenuLabel({ name, disabledReason }: {
+    name: string;
+    disabledReason?: string;
+}): React.JSX.Element;

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

@@ -15,3 +15,40 @@ export declare function ResetPasswordActionDialog({ user, open, onClose }: {
     onClose: () => void;
 }): React.JSX.Element;
 export declare const resetPasswordAction: EntityAction;
+/** A user, as the two dialogs below need one. */
+interface AdminActionUser {
+    uid: string;
+    email: string;
+}
+/**
+ * Remove every second factor and recovery code an account has, and end its
+ * sessions — for someone who lost their authenticator and their codes.
+ */
+export declare function ResetMfaActionDialog({ user, open, onClose }: {
+    user: AdminActionUser;
+    open: boolean;
+    onClose: () => void;
+}): React.JSX.Element;
+/**
+ * Switch an account off, or back on. Off, it signs in nowhere and every session
+ * and token it holds ends; the switch reads the account's state first, because
+ * the users table does not carry it.
+ */
+export declare function AccountAccessDialog({ user, open, onClose }: {
+    user: AdminActionUser;
+    open: boolean;
+    onClose: () => void;
+}): React.JSX.Element;
+/**
+ * Reset a user's two-step verification. Offered to whoever holds
+ * `users:write`, as `DELETE /admin/users/:uid/mfa` is; the route also refuses
+ * an account that outranks the caller, and the dialog says so.
+ */
+export declare const resetMfaAction: EntityAction;
+/**
+ * Switch an account off or on. Offered to whoever holds `users:write`, as
+ * `PUT /admin/users/:uid { disabled }` is, and never on the caller's own
+ * account, which the route refuses.
+ */
+export declare const accountAccessAction: EntityAction;
+export {};

package/dist/data_export/export/additional_fields.d.ts

@@ -0,0 +1,13 @@
+import { Entity } from "@rebasepro/types";
+import { AdditionalFieldDelegate, ExportMappingFunction, RebaseContext } from "@rebasepro/cms-types";
+/**
+ * The values of the export's extra columns, one record per entity: the
+ * collection's `exportable.additionalFields` and its `additionalFields` that
+ * declare a `value`, both in the same record.
+ */
+export declare function resolveAdditionalExportValues<M extends Record<string, unknown>>({ entities, exportFields, additionalFields, context }: {
+    entities: Entity<M>[];
+    exportFields: ExportMappingFunction[] | undefined;
+    additionalFields: AdditionalFieldDelegate<M>[] | undefined;
+    context: RebaseContext;
+}): Promise<Record<string, unknown>[]>;

package/dist/data_export/export/export.d.ts

@@ -23,6 +23,12 @@ export declare function getEntityJsonExportableData(data: Entity<Record<string,
  * the spreadsheet as "treat the rest as text", so the value reads back intact.
  */
 export declare function escapeCsvFormula(value: string): string;
+/**
+ * The inverse of {@link escapeCsvFormula}, for a file read back in: a cell that
+ * is an apostrophe followed by a formula trigger loses the apostrophe, as it
+ * does when a spreadsheet reads it. Any other apostrophe is text.
+ */
+export declare function unescapeCsvFormula(value: string): string;
 export declare function entryToCSVRow(entry: unknown[]): string;
 export declare function downloadBlob(content: BlobPart[], filename: string, contentType: string): void;
 export declare function downloadDataAsCsv(data: object[], name: string): void;