@rebasepro/cms 0.23.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

@@ -16,6 +16,10 @@ export declare function getPreviewSizeFrom(size: CollectionSize): PreviewSize;
  * 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.
  */

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;