react-semaphor 0.1.549 → 0.1.550

package/dist/surfboard/index.js

@@ -1,4 +1,4 @@
-import { a, R as s, D as o } from "../chunks/report-preferences-dialog-B9oYQ6OJ.js";
+import { a, R as s, D as o } from "../chunks/report-preferences-dialog-D_fEDaS4.js";
 import { C as f, E as D } from "../chunks/table-settings-WysCBj62.js";
 export {
   f as CONTROL_CARD_DEFAULT_VALUE,

package/dist/types/components/assistant/assistant-entry-points.d.ts

@@ -3,7 +3,10 @@ import { AssistantLayout } from '../../shared/assistant-protocol/conversation.js
 export type AssistantPanelSurface = 'dashboard' | 'none';
 /** Where the panel shows now: the viewer's layout, or beside the asked-about card (Phase 10, D10-1). */
 export type AssistantPlacement = AssistantLayout | 'beside-card';
-/** Opens and closes the panel. Named after the assistant; no other wording. */
+/**
+ * Opens and closes the panel. Named after the assistant; no other wording.
+ * Below a wide toolbar it keeps its place as an icon (responsive toolbars).
+ */
 export declare function AssistantToolbarButton(): import("react").JSX.Element | null;
 /**
  * The panel. Beside a dashboard (`surface="dashboard"`), the chat mounts on

package/dist/types/components/dashboard/favorites/dashboard-favorite-toggle.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The open dashboard's favorite star for a toolbar (dashboard favorites,
+ * FAV-D14, FAV-D17). Access and the server's `isFavorite` come from the
+ * dashboard's viewer state; this viewer's own writes win over it (the
+ * favorites store, ledger R-05). Nothing for a session that saves nothing (no
+ * person in the token, or a PDF render), a read-only star while signed in as
+ * someone else. Mounted in this package's toolbar and in the app's own toolbar.
+ */
+export declare function DashboardFavoriteToggle({ dashboardId }: {
+    dashboardId: string;
+}): import("react").JSX.Element | null;

package/dist/types/components/dashboard/favorites/favorite-star-button.d.ts

@@ -0,0 +1,16 @@
+/** Shown on a read-only star: the session is signed in as someone else (FAV-D3). */
+export declare const FAVORITES_READ_ONLY_MESSAGE = "Favorites can't be changed while you're signed in as someone else.";
+/**
+ * The one favorite star (dashboard favorites, FAV-D13): monochrome, an outline
+ * in muted ink when off, filled with foreground ink when on. On rows it shows
+ * on hover or keyboard focus and stays visible once on.
+ */
+export declare function FavoriteStarButton({ isFavorite, onToggle, readOnly, pending, variant, className, }: {
+    isFavorite: boolean;
+    onToggle: () => void;
+    readOnly?: boolean;
+    pending?: boolean;
+    /** `row`: hub and list rows, revealed on hover. `toolbar`: always shown. */
+    variant?: 'row' | 'toolbar';
+    className?: string;
+}): import("react").JSX.Element;

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

@@ -37,6 +37,14 @@ export { AssistantProvider } from './assistant/assistant-provider.js';
 export { AssistantPanel, AssistantToolbarButton } from './assistant/assistant-entry-points.js';
 export { ArrangeLayoutButton } from './surfboard/arrange-layout-button.js';
 export { ScreenSizePreviewButton } from './surfboard/screen-size-preview-button.js';
+export { DashboardFavoriteToggle } from './dashboard/favorites/dashboard-favorite-toggle.js';
+export { FavoriteStarButton, FAVORITES_READ_ONLY_MESSAGE, } from './dashboard/favorites/favorite-star-button.js';
+export { ToolbarOverflowAnchorSlot, ToolbarProvider } from './surfboard/toolbar/toolbar-overflow.js';
+export { TOOLBAR_LG_MIN, TOOLBAR_MD_MIN, fitsToolbar, toolbarWidthFor, useMeasuredToolbarWidth, useToolbarItem, useToolbarOverflowItems, useToolbarWidth, } from './surfboard/toolbar/toolbar-context.js';
+export type { ToolbarOverflowItem, ToolbarTier, ToolbarWidth, } from './surfboard/toolbar/toolbar-context.js';
+export { useDefaultDashboardToggle } from '../lib/hooks/use-default-dashboard-toggle.js';
+export { useDashboardFavorite } from '../lib/hooks/use-dashboard-favorite.js';
+export type { DashboardFavorites } from '../lib/hooks/use-dashboard-favorite.js';
 export type { AssistantPanelSurface } from './assistant/assistant-entry-points.js';
 export { useAssistant } from './assistant/use-assistant.js';
 export * from '../lib/types/common-types.js';

package/dist/types/components/sharing-and-management/hooks/use-resource-management.d.ts

@@ -1,6 +1,7 @@
 import { ResourceType, ShareRole, ShareScope } from '../utils/types.js';
 import { TDashboard, TFrame } from '../../../lib/types/index.js';
 import { AppearanceSpec } from '../../../lib/appearance/index.js';
+import { DashboardListViewer } from '../../../shared/dashboard-viewer/index.js';
 export interface ResourceListItem {
     id: string;
     title: string;
@@ -38,6 +39,9 @@ export interface ResourceListItem {
             email: string;
         };
     };
+    /** Dashboard lists only (dashboard favorites, FAV-D5); absent from older servers, read as false. */
+    isFavorite?: boolean;
+    favoritedAt?: string | null;
 }
 export interface CreateResourceRequest {
     title: string;
@@ -115,6 +119,10 @@ export declare function useResourceUpdateState(): {
 export declare function useResourceManagement(resourceType: ResourceType, onDeleteSuccess?: () => void, onCreateSuccess?: (data?: any) => void): {
     resources: any;
     organizationAppearance: AppearanceSpec | null;
+    /** When the list arrived (client clock, ms); favorites resolve against it (FAV-D20). */
+    listFetchedAt: number;
+    /** Dashboard lists: whether this session can change favorites (FAV-D18). */
+    listViewer: DashboardListViewer | null;
     isLoading: boolean;
     isError: boolean;
     isFetching: boolean;
@@ -152,6 +160,10 @@ export declare function useResourceManagement(resourceType: ResourceType, onDele
 export declare function useDashboardManagement(onDeleteSuccess?: () => void, onCreateSuccess?: (data?: any) => void): {
     resources: any;
     organizationAppearance: AppearanceSpec | null;
+    /** When the list arrived (client clock, ms); favorites resolve against it (FAV-D20). */
+    listFetchedAt: number;
+    /** Dashboard lists: whether this session can change favorites (FAV-D18). */
+    listViewer: DashboardListViewer | null;
     isLoading: boolean;
     isError: boolean;
     isFetching: boolean;
@@ -189,6 +201,10 @@ export declare function useDashboardManagement(onDeleteSuccess?: () => void, onC
 export declare function useVisualManagement(onDeleteSuccess?: () => void, onCreateSuccess?: (data?: any) => void): {
     resources: any;
     organizationAppearance: AppearanceSpec | null;
+    /** When the list arrived (client clock, ms); favorites resolve against it (FAV-D20). */
+    listFetchedAt: number;
+    /** Dashboard lists: whether this session can change favorites (FAV-D18). */
+    listViewer: DashboardListViewer | null;
     isLoading: boolean;
     isError: boolean;
     isFetching: boolean;

package/dist/types/components/surfboard/toolbar/toolbar-context.d.ts

@@ -0,0 +1,86 @@
+import { ReactNode } from 'react';
+/**
+ * Responsive dashboard toolbars (design: semaphor-app `/design/responsive-toolbars`).
+ *
+ * Both toolbars, this package's and the app's navbar, follow one rule set. A
+ * toolbar measures its own width (an embed lives in a host column of any
+ * size, so the viewport says nothing). Every item has a tier: `always`, `md`
+ * (shown from 640px of toolbar) or `lg` (from 960px). As the toolbar narrows,
+ * labels collapse to icons first, then an item below its tier stops rendering
+ * its button and registers its menu form here, which the toolbar's existing
+ * ⋯ menu renders in toolbar order. A `menu` item lives in ⋯ at every width.
+ * Editing controls cannot move, so their group scrolls when it still does not
+ * fit, and ⋯ stays in view.
+ *
+ * Outside a toolbar (for example the Activity bell on the Briefings page) the
+ * context reads as `lg` with no menu, so every control renders as before.
+ */
+export type ToolbarWidth = 'sm' | 'md' | 'lg';
+export type ToolbarTier = 'always' | 'md' | 'lg' | 'menu';
+/** Toolbar widths (px) where the `md` and `lg` tiers start. */
+export declare const TOOLBAR_MD_MIN = 640;
+export declare const TOOLBAR_LG_MIN = 960;
+export declare function toolbarWidthFor(px: number): ToolbarWidth;
+/** Whether an item of `tier` shows its button at `width`. */
+export declare function fitsToolbar(tier: ToolbarTier, width: ToolbarWidth): boolean;
+/** The menu form an item registers while its button does not fit. */
+export type ToolbarOverflowItem = {
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: ReactNode;
+    /** A short right-aligned note: a count, a current value. */
+    readonly hint?: string;
+    /** Shown as a check, for a toggle. */
+    readonly checked?: boolean;
+    /** Toolbar order, so the menu lists moved items as the toolbar did. */
+    readonly order: number;
+    readonly onSelect: () => void;
+};
+export type ToolbarContextValue = {
+    readonly width: ToolbarWidth;
+    /** Inside a toolbar that has a ⋯ menu for moved items. */
+    readonly hasOverflowMenu: boolean;
+    readonly overflowItems: readonly ToolbarOverflowItem[];
+    register(item: ToolbarOverflowItem): () => void;
+    /** Which moved control's popover is open from the menu. */
+    readonly openOverflowId: string | null;
+    setOpenOverflowId(id: string | null): void;
+    /** Beside the ⋯ button: where a moved control anchors its popover. */
+    readonly anchorSlot: HTMLElement | null;
+    setAnchorSlot(element: HTMLElement | null): void;
+};
+export declare const ToolbarContext: import('react').Context<ToolbarContextValue>;
+/**
+ * Measures an element's width: pass `measure` as the element's `ref`. Starts
+ * at `lg` so a wide first paint never jumps.
+ */
+export declare function useMeasuredToolbarWidth<T extends HTMLElement>(): {
+    measure: (element: T | null) => void;
+    width: ToolbarWidth;
+};
+/** The toolbar's width (`lg` outside a toolbar). */
+export declare function useToolbarWidth(): ToolbarWidth;
+/** The moved items, for a toolbar's ⋯ menu. */
+export declare function useToolbarOverflowItems(): readonly ToolbarOverflowItem[];
+/**
+ * One toolbar item. `collapsed` means it should not render its button. While
+ * collapsed and `menu` is given, its menu form is registered. Popover controls
+ * use `popoverOpen` and `setPopoverOpen`: from the menu they open anchored at
+ * the ⋯ menu, which is where the item now lives.
+ */
+export declare function useToolbarItem(id: string, tier: ToolbarTier, menu?: Omit<ToolbarOverflowItem, 'id' | 'onSelect'> & {
+    /** Defaults to opening the item's popover from the menu. */
+    readonly onSelect?: () => void;
+    /**
+     * Runs when the menu opens the item's popover. Radix calls `onOpenChange`
+     * only for its own trigger, not when the `open` prop changes, so work a
+     * control does on open (Activity marks finished work seen) goes here too.
+     */
+    readonly onOpen?: () => void;
+}): {
+    collapsed: boolean;
+    popoverOpen: boolean;
+    setPopoverOpen(open: boolean): void;
+    /** Where to portal a collapsed popover's anchor (`null` outside a toolbar). */
+    anchorSlot: HTMLElement | null;
+};

package/dist/types/components/surfboard/toolbar/toolbar-overflow.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { ToolbarWidth } from './toolbar-context.js';
+/** Wraps one toolbar: its width, and the moved items its ⋯ menu renders. */
+export declare function ToolbarProvider({ width, hasOverflowMenu, children, }: {
+    width: ToolbarWidth;
+    /** False while the toolbar shows no ⋯ menu: then nothing moves into one. */
+    hasOverflowMenu?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Place right before the toolbar's ⋯ button: a moved control's popover
+ * anchors here, so it opens under the menu it was chosen from.
+ */
+export declare function ToolbarOverflowAnchorSlot(): import("react").JSX.Element;

package/dist/types/lib/dashboard-viewer/viewer-store-state.d.ts

@@ -18,6 +18,13 @@ export type DashboardViewerState = {
     /** Live table settings per card. Never written into `card.config` or `tablePrefs`. */
     readonly tableSettings: Readonly<Record<string, ViewerTableSettings>>;
     readonly notices: readonly ViewerNotice[];
+    /**
+     * The server's answer from the dashboard's viewer payload (FAV-D17). Read
+     * through the favorites store, where this viewer's later writes win.
+     */
+    readonly isFavorite: boolean;
+    /** When the dashboard response this state came from arrived (client clock, ms; 0 when unknown). */
+    readonly fetchedAt: number;
 };
 /** Session-only until the dashboard load says otherwise (TECH-SPEC 7). */
 export declare const INITIAL_DASHBOARD_VIEWER_STATE: DashboardViewerState;

package/dist/types/lib/hooks/use-dashboard-favorite.d.ts

@@ -0,0 +1,24 @@
+export type SetDashboardFavoriteInput = {
+    readonly dashboardId: string;
+    readonly isFavorite: boolean;
+};
+export type DashboardFavorites = {
+    /**
+     * What to show: this viewer's write while in flight or newer than the
+     * server data, else the server's value. `serverFetchedAt` is when that data
+     * arrived (client clock, ms).
+     */
+    isFavorite(dashboardId: string, serverIsFavorite: boolean, serverFetchedAt?: number): boolean;
+    /** A write for this dashboard is waiting for the server. */
+    isPending(dashboardId: string): boolean;
+    /** Resolves true when the server saved it; false after it was put back. */
+    setFavorite(input: SetDashboardFavoriteInput): Promise<boolean>;
+};
+/**
+ * Dashboard favorites for the viewer the token names (FAV-D15). Reads and
+ * writes go through one viewer-scoped store (`dashboard-favorites-store.ts`);
+ * server responses are read as they are and never edited, so a cached list or
+ * dashboard response cannot disagree with a write made since (ledger R-01,
+ * R-02, R-05).
+ */
+export declare function useDashboardFavorite(): DashboardFavorites;

package/dist/types/lib/hooks/use-dashboard-query.d.ts

@@ -6,6 +6,8 @@ export declare function useDashboardQuery(): {
         organizationAppearance?: import('../types/index.js').AppearanceSpec | null;
         viewer?: import('../types/index.js').DashboardViewerPayload;
     } | null | undefined;
+    /** When `data` arrived (client clock, ms); dashboard favorites read it (FAV-D20). */
+    dataUpdatedAt: number;
     isLoading: boolean;
     isFetching: boolean;
     isError: boolean;

package/dist/types/lib/hooks/use-default-dashboard-toggle.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The viewer's default dashboard, as one ⋯ menu item in both dashboard
+ * toolbars (responsive toolbars: the DEFAULT chip and house button left the
+ * toolbar). The hub list keeps its Default chip.
+ */
+export declare function useDefaultDashboardToggle(dashboardId: string | null | undefined): {
+    available: boolean;
+    isDefault: boolean;
+    /** True until the preference has loaded, and while a change is saving. */
+    disabled: boolean;
+    toggle(): void;
+};

package/dist/types/shared/dashboard-viewer/viewer-contract.d.ts

@@ -63,6 +63,24 @@ export type DashboardViewerPayload = {
         readonly teamScope?: 'tenant' | 'organization';
         readonly canPublish: boolean;
     };
+    /**
+     * Whether the person has favorited this dashboard (dashboard favorites,
+     * FAV-D17). Read with the rest of the preference row; `false` for
+     * session-only access.
+     */
+    readonly isFavorite: boolean;
+};
+/**
+ * The dashboard list's top-level `viewer` (`GET /api/management/v1/dashboards`,
+ * FAV-D18): whether the person the token names can change favorites.
+ */
+export type DashboardListViewer = Pick<DashboardViewerPayload, 'access' | 'accessReason'>;
+/** `PUT` and `DELETE /api/management/v1/dashboards/{id}/favorite` (FAV-D4). */
+export type DashboardFavoriteState = {
+    readonly dashboardId: string;
+    readonly isFavorite: boolean;
+    /** ISO 8601; `null` when not a favorite. */
+    readonly favoritedAt: string | null;
 };
 /**
  * How many saved bookmarks and remembered table settings reference each part

package/package.json

@@ -5,7 +5,7 @@
     "email": "support@semaphor.cloud"
   },
   "license": "MIT",
-  "version": "0.1.549",
+  "version": "0.1.550",
   "description": "Fully interactive and customizable dashboards for your apps.",
   "keywords": [
     "react",