@rebasepro/cms 0.22.0 → 0.24.0

package/dist/preview/components/StorageMarkdown.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { type MarkdownProps } from "@rebasepro/ui";
+/**
+ * Markdown whose images may be stored as `rebase-storage:` references — what
+ * the markdown editor writes for an uploaded image — rendered with a freshly
+ * signed URL for each.
+ *
+ * @internal
+ */
+export declare function StorageMarkdown({ source, ...props }: MarkdownProps): React.JSX.Element;

package/dist/preview/util.d.ts

@@ -1,4 +1,5 @@
 import { CollectionSize } from "@rebasepro/cms-types";
+import type { DateProperty } from "@rebasepro/types";
 import type { PreviewSize } from "../types/components/PropertyPreviewProps.js";
 export declare function sanitizeUrl(url: string | undefined): string;
 export declare const SMALL_THUMBNAIL = 40;
@@ -6,3 +7,31 @@ export declare const MEDIUM_THUMBNAIL = 100;
 export declare const LARGE_THUMBNAIL = 200;
 export declare function getThumbnailMeasure(size: PreviewSize): number;
 export declare function getPreviewSizeFrom(size: CollectionSize): PreviewSize;
+/**
+ * The zone a date property is shown and entered in.
+ *
+ * A `columnType: "date"` column holds a calendar day with no zone. It travels
+ * as that day's UTC midnight, and Postgres keeps the date part of whatever it
+ * is given, so it is read and written in UTC. In the browser's own zone a
+ * stored 15th showed as the 14th west of Greenwich, and a 15th picked east of
+ * it was stored as the 14th.
+ *
+ * A `columnType: "time"` column holds a time of day with no zone, and travels
+ * as that time on 1970-01-01 UTC, so it is shown in UTC too: in the browser's
+ * zone a stored 09:30 read as 10:30 in Rome.
+ *
+ * Any other date is shown in the property's declared `timezone`, or the
+ * browser's when it declares none.
+ */
+export declare function getDatePropertyTimezone(property: DateProperty): string | undefined;
+/**
+ * Whether a date property is picked and shown as a day or a day and a time. A
+ * `date` column holds no time, so it is a day whatever `mode` says.
+ */
+export declare function getDatePropertyMode(property: DateProperty): "date" | "date_time" | undefined;
+/**
+ * Whether a value has nothing to show: absent, a blank string, an empty list.
+ * A preview of one draws the empty marker, which is the right thing for a
+ * column of values and the wrong thing for the one line under a record's name.
+ */
+export declare function isEmptyPreviewValue(value: unknown): boolean;

package/dist/util/caller_scopes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Does the signed-in caller hold `scope`? Read off the controller's
+ * `heldScopes` — `GET /auth/scopes` — so an action is offered, or an admin
+ * route asked, by exactly those the route admits. Not known yet is no.
+ */
+export declare function callerHoldsScope(authController: unknown, scope: string): boolean;
+/**
+ * Does the controller report the caller's scopes at all? `useRebaseAuthController`
+ * does (`undefined` until they are known). A controller without the field,
+ * such as `useAuthSubscription` or a hand-written one, cannot say, and a gate
+ * built on it has to fall back to asking the backend.
+ */
+export declare function reportsScopes(authController: unknown): authController is {
+    heldScopes?: unknown;
+};

package/dist/util/entity_actions.d.ts

@@ -1,2 +1,38 @@
-import type { EntityAction } from "@rebasepro/cms-types";
+import type { EntityAction, EntityActionClickProps } from "@rebasepro/cms-types";
 export declare function mergeEntityActions(currentActions: EntityAction[], newActions: EntityAction[]): EntityAction[];
+export interface PlacedEntityActions<A = EntityAction> {
+    /** Declared `collapsed: false`: buttons of their own, in declaration order. */
+    inline: A[];
+    /** The collection's own actions that wait in the menu. */
+    own: A[];
+    /** The built-ins that work on any record: Edit, Copy. */
+    generic: A[];
+    /** Delete, or Remove on a linked tab. */
+    destructive: A[];
+}
+/**
+ * Where each of a record's actions goes — the same answer on every surface
+ * that shows them, the record's bar and a table row alike.
+ *
+ * Built-ins used to come first, so the menu read Copy, Delete, then the
+ * collection's own: Delete sat second, between two harmless items, and the
+ * operations a collection adds — the reason someone opened this record — came
+ * after it. The menu leads with those now, Copy follows, and Delete is last
+ * and set apart, where it is not hit while reaching for a neighbour.
+ *
+ * Whether an action is a button is the developer's call, by `collapsed`, and
+ * that holds for the built-ins too: a Delete declared `collapsed: false` is a
+ * button.
+ */
+export declare function placeEntityActions<A extends Pick<EntityAction, "key" | "collapsed">>(actions: A[]): PlacedEntityActions<A>;
+export interface EntityActionState {
+    enabled: boolean;
+    /** Only when disabled, and only if the action says why. */
+    disabledReason?: string;
+}
+/**
+ * Whether an action can run for these props and, when it cannot, why — the
+ * one question every surface that draws an action asks, so a reason declared
+ * once shows on the record's bar, its menu and the collection's rows alike.
+ */
+export declare function resolveEntityActionState(action: Pick<EntityAction, "isEnabled" | "disabledReason">, props: EntityActionClickProps<Record<string, unknown>>): EntityActionState;

package/dist/util/fit_inline_actions.d.ts

@@ -0,0 +1,20 @@
+export interface InlineActionsFit {
+    /** How many of the actions, from the front, stay in the bar. */
+    count: number;
+    /** Icon-only, the name moving to a tooltip. */
+    compact: boolean;
+}
+/**
+ * How many of a bar's inline actions fit in `available` pixels, and in which
+ * form.
+ *
+ * Labelled while they all fit. Then icon-only, all of them — an action with no
+ * icon keeps its label, so its compact width is its labelled one. Then as many
+ * icon-only buttons as fit, from the front: the developer declared the most
+ * important first, so the last ones fold into the menu.
+ *
+ * Widths that are all zero mean nothing was laid out — a hidden tab, a test
+ * DOM. Every action is shown, labelled, and the observer that called this
+ * measures again once there is layout.
+ */
+export declare function fitInlineActions(available: number, labelled: number[], compact: number[], gap: number): InlineActionsFit;

package/dist/util/navigation_utils.d.ts

@@ -1,10 +1,10 @@
-import type { UrlController, SidePanelController, AdminCollection } from "@rebasepro/cms-types";
+import type { UrlController, SidePanelBindingProps, SidePanelController, AdminCollection } from "@rebasepro/cms-types";
 export { removeInitialAndTrailingSlashes, removeInitialSlash, removeTrailingSlash, addInitialSlash, getLastSegment, resolveCollectionPathIds, getCollectionBySlugWithin, getCollectionPathsCombinations } from "@rebasepro/app";
 /**
  * Navigate to a entity using either a side panel or full-screen mode.
  * This is an admin-specific UI concern and lives here (not in common).
  */
-export declare function navigateToEntity({ openEntityMode, collection, entityId, copy, path, selectedTab, defaultValues, sidePanelController, onClose, navigation, replace }: {
+export declare function navigateToEntity({ openEntityMode, collection, entityId, copy, path, selectedTab, defaultValues, sidePanelController, onClose, onUpdate, navigation, replace }: {
     openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
     collection?: AdminCollection;
     entityId?: string | number;
@@ -22,6 +22,18 @@ export declare function navigateToEntity({ openEntityMode, collection, entityId,
     path: string;
     sidePanelController: SidePanelController;
     onClose?: () => void;
+    /**
+     * Called when the side panel or dialog saves the record. A full-screen
+     * record replaces the view that opened it, and that view reads
+     * everything again when it comes back, so nothing is called there.
+     */
+    onUpdate?: SidePanelBindingProps["onUpdate"];
     navigation: UrlController;
     replace?: boolean;
 }): void;
+/**
+ * Whether `pathname` is the record at `entityPath` or somewhere below it — one
+ * of its tabs, its `/edit`. A path segment, not a string prefix:
+ * `/c/products/12` is another record, not a place inside `/c/products/1`.
+ */
+export declare function isPathWithinRecord(pathname: string, entityPath: string): boolean;

package/dist/util/view_mode.d.ts

@@ -29,32 +29,26 @@ export declare function isViewMode(value: string | null | undefined, customKeys?
  * @param customKeys keys of the collection's custom views, if any.
  */
 export declare function getViewModeFromSearch(search?: string, customKeys?: readonly string[]): ViewMode | null;
-/**
- * Append the active view mode to a URL so the target route keeps rendering the
- * view the user was last looking at.
- *
- * Every entity/collection navigation must go through this — a missed call site
- * silently resets the user's view mode mid-session.
- *
- * @param url the URL to decorate. May already contain a query string and/or hash.
- * @param search query string to read the view mode from. Defaults to the
- *        current browser location.
- */
-export declare function withViewMode(url: string, search?: string): string;
 /**
  * Carry the whole of the collection list's URL state onto a navigation target.
  *
- * `withViewMode` exists because losing the view mode mid-session is jarring.
- * Everything else the list writes to the URL — the search string, the filters,
- * the sort — is state the user built up deliberately, and losing *that* is
- * worse: opening a record from a search and pressing back returned an
- * unfiltered list with an empty search box, so the search had to be retyped
- * for every record they wanted to look at.
+ * Every navigation to the collection or one of its records goes through this —
+ * a missed call site silently resets the list mid-session. The list reads its
+ * state back from the URL on each navigation, so the view mode, the search
+ * string, the filters and the sort all have to travel: a URL without them
+ * returned an unfiltered list with an empty search box, and the search had to
+ * be retyped for every record the user wanted to look at.
  *
  * Copies every param the list currently has rather than an allowlist, because
  * filters are encoded under the field's own name — there is no fixed set to
  * list. Params already on the target win: the caller is more specific.
  *
+ * Carries whatever `__view` holds rather than validating it. These call sites
+ * are navigations with no collection in hand, so they cannot know whether
+ * `map` is one of *this* collection's custom views; checking against the
+ * built-ins here would drop every custom view on the first record click. The
+ * binding validates on read, which is where the answer is knowable.
+ *
  * @param url the URL to decorate. May carry a query string and/or a hash.
  * @param search query string to read from. Defaults to the browser location.
  */