@carto/ps-react-ui 4.9.0 → 4.11.0

package/dist/types/chat/feedback/styles.d.ts

@@ -0,0 +1,211 @@
+import { Theme } from '@mui/material';
+export declare const styles: {
+    thinking: {
+        display: "flex";
+        alignItems: "center";
+        minHeight: ({ spacing }: Theme) => string;
+        background: ({ palette }: Theme) => string;
+        backgroundSize: string;
+        backgroundClip: "text";
+        WebkitBackgroundClip: "text";
+        WebkitTextFillColor: "transparent";
+        animation: `${{
+            name: string;
+            styles: string;
+            anim: 1;
+            toString: () => string;
+        } & string} 2s ease-in-out infinite`;
+        animationDuration: "2s";
+    };
+    loader: {
+        display: "flex";
+        alignItems: "center";
+        justifyContent: "center";
+        position: "relative";
+        p: number;
+    };
+    loaderOuterCircle: {
+        position: "absolute";
+        inset: number;
+        margin: string;
+        borderRadius: string;
+        backgroundColor: ({ palette }: Theme) => string;
+        animation: `${{
+            name: string;
+            styles: string;
+            anim: 1;
+            toString: () => string;
+        } & string} 1s ease-in-out infinite`;
+    };
+    loaderInnerCircle: {
+        position: "absolute";
+        inset: number;
+        margin: string;
+        borderRadius: string;
+        backgroundColor: ({ palette }: Theme) => string;
+        animation: `${{
+            name: string;
+            styles: string;
+            anim: 1;
+            toString: () => string;
+        } & string} 1s ease-in-out infinite`;
+    };
+    traceHeader: {
+        display: "flex";
+        alignItems: "center";
+        padding: number;
+        paddingLeft: ({ spacing }: Theme) => string;
+        borderRadius: ({ spacing }: Theme) => string;
+        width: string;
+        color: ({ palette }: Theme) => string;
+        '&:hover': {
+            backgroundColor: ({ palette }: Theme) => string;
+        };
+    };
+    traceChevron: {
+        color: ({ palette }: Theme) => string;
+        transition: "transform 0.2s";
+    };
+    traceDetailsWrapper: {
+        marginTop: ({ spacing }: Theme) => string;
+        padding: ({ spacing }: Theme) => string;
+        border: "1px solid";
+        borderColor: "divider";
+        borderRadius: ({ spacing }: Theme) => string;
+    };
+    traceField: {
+        display: "flex";
+        alignItems: "flex-start";
+        gap: ({ spacing }: Theme) => string;
+    };
+    traceFieldLabel: {
+        flexShrink: number;
+    };
+    traceReference: {
+        display: "flex";
+        borderRadius: ({ spacing }: Theme) => string;
+        padding: ({ spacing }: Theme) => string;
+        gap: ({ spacing }: Theme) => string;
+        backgroundColor: ({ palette }: Theme) => string;
+        color: ({ palette }: Theme) => string;
+    };
+    traceStatusSuccess: {
+        color: ({ palette }: Theme) => string;
+    };
+    traceStatusError: {
+        color: ({ palette }: Theme) => string;
+    };
+    codeArea: {
+        position: "relative";
+        width: string;
+    };
+    codeAreaPre: {
+        margin: number;
+        padding: ({ spacing }: Theme) => string;
+        borderRadius: ({ spacing }: Theme) => string;
+        backgroundColor: ({ palette }: Theme) => string;
+        fontSize: string;
+        fontFamily: "monospace";
+        whiteSpace: "pre-wrap";
+        wordBreak: "break-word";
+        overflowY: "auto";
+    };
+    codeAreaPreError: {
+        borderLeft: ({ palette }: Theme) => string;
+        backgroundColor: ({ palette }: Theme) => string;
+    };
+    codeAreaFullViewButton: {
+        position: "absolute";
+        top: ({ spacing }: Theme) => string;
+        right: ({ spacing }: Theme) => string;
+    };
+    fullViewDialog: {
+        margin: ({ spacing }: Theme) => string;
+    };
+    fullViewPaper: {
+        borderRadius: number;
+    };
+    fullViewTitle: {
+        display: "flex";
+        alignItems: "center";
+        justifyContent: "space-between";
+        padding: ({ spacing }: Theme) => string;
+        borderBottom: string;
+        borderBottomColor: "divider";
+    };
+    fullViewDialogContent: {
+        padding: number;
+        '&:first-of-type': {
+            paddingTop: number;
+        };
+    };
+    fullViewPre: {
+        margin: number;
+        padding: ({ spacing }: Theme) => string;
+        background: ({ palette, spacing }: Theme) => string;
+        fontFamily: "monospace";
+        fontSize: string;
+        whiteSpace: "pre-wrap";
+        wordBreak: "break-word";
+        lineHeight: number;
+        counterReset: "line";
+    };
+    fullViewLine: {
+        display: "block";
+        '&::before': {
+            counterIncrement: "line";
+            content: "counter(line)";
+            display: "inline-block";
+            width: string;
+            marginRight: string;
+            textAlign: "right";
+            color: ({ palette }: Theme) => string;
+            userSelect: "none";
+        };
+    };
+    groupHeader: {
+        textAlign: "left";
+        display: "flex";
+        alignItems: "center";
+        borderRadius: number;
+        gap: ({ spacing }: Theme) => string;
+    };
+    errorBadge: {
+        color: ({ palette }: Theme) => string;
+        fontWeight: number;
+        display: "flex";
+        alignItems: "center";
+        gap: ({ spacing }: Theme) => string;
+    };
+    syntaxToken_key: {
+        color: "#881280";
+    };
+    syntaxToken_string: {
+        color: "#c41a16";
+    };
+    syntaxToken_number: {
+        color: "#1c00cf";
+    };
+    syntaxToken_boolean: {
+        color: "#1c00cf";
+    };
+    syntaxToken_null: {
+        color: "#808080";
+    };
+    syntaxToken_punctuation: {
+        color: ({ palette }: Theme) => string;
+    };
+    groupListItem: {
+        borderBottom: string;
+        borderColor: "divider";
+        '&:first-of-type .MuiButton-root': {
+            borderRadius: ({ spacing }: Theme) => string;
+        };
+        '&:last-of-type:not([aria-expanded=true]) .MuiButton-root': {
+            borderRadius: ({ spacing }: Theme) => string;
+        };
+        '&:last-of-type': {
+            borderBottomWidth: number;
+        };
+    };
+};

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

@@ -0,0 +1,20 @@
+export type { ChatSxProps, ChatErrorAction, ChatUserMessageProps, ChatAgentMessageProps, ChatErrorMessageProps, ChatSuggestionButtonProps, ChatThinkingProps, ChatLoaderProps, ChatContentProps, ChatContentRef, ChatHeaderProps, ChatFooterProps, ChatStarterItem, ChatStarterProps, ChatRatingActionProps, ChatToolItem, ChatToolTraceProps, ChatToolCodeAreaProps, ChatToolFullViewDialogProps, ChatToolGroupProps, } from './types';
+export { CHAT_MAX_WIDTH, CHAT_SCROLL_DELAY, CHAT_DIVIDER_DELAY, CHAT_TOOL_CODE_AREA_MAX_HEIGHT, } from './const';
+export { useTypewriter } from './use-typewriter';
+export { ChatUserMessage } from './bubbles/chat-user-message';
+export { ChatAgentMessage } from './bubbles/chat-agent-message';
+export { ChatErrorMessage } from './bubbles/chat-error-message';
+export { ChatSuggestionButton } from './bubbles/chat-suggestion-button';
+export { ChatMessageOverflow } from './bubbles/styles';
+export { ChatThinking } from './feedback/chat-thinking';
+export { ChatLoader } from './feedback/chat-loader';
+export { ChatContent } from './containers/chat-content';
+export { ChatHeader } from './containers/chat-header';
+export { ChatFooter } from './containers/chat-footer';
+export { ChatStarter } from './containers/chat-starter';
+export { ChatActionsContainer } from './feedback/chat-actions-container';
+export { ChatRatingAction } from './feedback/chat-rating-action';
+export { ChatToolTrace } from './feedback/chat-tool-trace';
+export { ChatToolCodeArea } from './feedback/chat-tool-code-area';
+export { ChatToolFullViewDialog } from './feedback/chat-tool-full-view-dialog';
+export { ChatToolGroup } from './feedback/chat-tool-group';

package/dist/types/chat/types.d.ts

@@ -0,0 +1,184 @@
+import { ReactNode } from 'react';
+import { ButtonBaseProps, SxProps, Theme } from '@mui/material';
+export interface ChatSxProps {
+    sx?: SxProps<Theme>;
+}
+export interface ChatErrorAction {
+    label: string;
+    onClick: () => void;
+}
+export interface ChatUserMessageProps extends ChatSxProps {
+    children: ReactNode;
+    /** enabled to render text with a lighter color for indicating things like an error sending the message */
+    muted?: boolean;
+    /** content to render on top of the message for user attachments */
+    topContext?: ReactNode;
+}
+export interface ChatAgentMessageProps extends ChatSxProps {
+    children: ReactNode;
+}
+export interface ChatErrorMessageProps extends ChatSxProps {
+    errors: string[];
+    icon?: ReactNode;
+    actions?: ChatErrorAction[];
+}
+export interface ChatSuggestionButtonProps extends ChatSxProps, Omit<ButtonBaseProps, 'children'> {
+    label: ReactNode;
+    color?: string;
+}
+export interface ChatThinkingProps extends ChatSxProps {
+    duration?: number;
+    children?: ReactNode;
+}
+export interface ChatLoaderProps extends ChatSxProps {
+    size?: number;
+    labels?: {
+        loading?: string;
+    };
+}
+export interface ChatContentProps extends ChatSxProps {
+    children: ReactNode;
+    /**
+     * Smooth-scrolls to the bottom whenever new content is added — but only if
+     * the user was already at (or near) the bottom. Readers who scrolled up to
+     * revisit older messages are left alone. Defaults to `true`; pass `false`
+     * to opt out and manage scroll yourself via the ref.
+     */
+    autoScroll?: boolean;
+    labels?: {
+        jumpToLatest?: string;
+    };
+}
+/**
+ * Imperative handle exposed by `ChatContent` via `ref`. Use it to drive scroll
+ * from the parent — for example, calling `scrollToBottom()` when a new agent
+ * message arrives.
+ */
+export interface ChatContentRef {
+    /** Smooth-scrolls the content area to the bottom. */
+    scrollToBottom: () => void;
+    /** Smooth-scrolls the content area to the top. */
+    scrollToTop: () => void;
+    /** `true` when the content area is scrolled to (or near) its bottom edge. */
+    isAtBottom: boolean;
+    /** `true` when the content area is scrolled to (or near) its top edge. */
+    isAtTop: boolean;
+}
+export interface ChatHeaderProps extends ChatSxProps {
+    leftSlot?: ReactNode;
+    title: ReactNode;
+    rightSlot?: ReactNode;
+    onClose?: () => void;
+}
+export interface ChatFooterProps extends ChatSxProps {
+    /** Current value of the chat message area. */
+    value: string;
+    /** Called with the new textarea value on every keystroke. */
+    onChange: (value: string) => void;
+    /** Called when the send button is clicked or Enter is pressed (without Shift). */
+    onSend: () => void;
+    /** Called when the stop button is clicked. Only shown while `isGenerating` is true. */
+    onStop?: () => void;
+    /** When true, swaps the send button for a stop button and disables the textarea. */
+    isGenerating?: boolean;
+    /** Disables the textarea and both send/stop buttons. */
+    disabled?: boolean;
+    /** Placeholder text for the textarea. Defaults to `'Type a message...'`. */
+    placeholder?: string;
+    /** Accessible labels for the send and stop buttons (used as `aria-label`). */
+    labels?: {
+        /** Defaults to `'Send'`. */
+        send?: string;
+        /** Defaults to `'Stop'`. */
+        stop?: string;
+    };
+    /** Helper text rendered under the input. Defaults to an AI disclaimer; pass `null` to hide. */
+    caption?: ReactNode;
+}
+export interface ChatStarterItem {
+    label: string;
+    color?: string;
+}
+export interface ChatStarterProps extends ChatSxProps {
+    icon?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    items: string[] | ChatStarterItem[];
+    size?: 'small' | 'medium';
+    onSelect?: (prompt: string) => void;
+}
+export interface ChatRatingActionProps {
+    onRatingChange?: (rating: 'up' | 'down' | null) => void;
+    rating?: 'up' | 'down' | null;
+    labels?: {
+        thumbUp?: string;
+        thumbDown?: string;
+    };
+}
+export interface ChatToolItem {
+    id: string;
+    name: string;
+    status: 'running' | 'complete' | 'error';
+    /** Display label shown while status is 'running'. Falls back to a capitalized `name`. */
+    runningLabel?: string;
+    /** Display label shown for non-running statuses. Falls back to a capitalized `name`. */
+    label?: string;
+    /** Friendly reference name for the tool (e.g. "add_marker"). Displayed with icon. */
+    reference?: string;
+    /** Execution duration in seconds (e.g. 1.8) */
+    duration?: number;
+    /** Input arguments as a JSON string or plain text */
+    inputArguments?: string;
+    /** Output as a JSON string or plain text */
+    output?: string;
+}
+export interface ChatToolTraceProps extends ChatSxProps {
+    tool: ChatToolItem;
+    /** Whether the trace accordion is expanded */
+    expanded?: boolean;
+    /** Callback when accordion expansion state changes */
+    onExpandedChange?: (expanded: boolean) => void;
+    labels?: {
+        toolExecuted?: string;
+        reference?: string;
+        duration?: string;
+        status?: string;
+        inputArguments?: string;
+        output?: string;
+        fullView?: string;
+        success?: string;
+        error?: string;
+        running?: string;
+    };
+}
+export interface ChatToolCodeAreaProps extends ChatSxProps {
+    /** Code content to display */
+    content: string;
+    /** Label for the full view dialog title */
+    title?: string;
+    /** Render with error styling (red left border, tinted background) */
+    isError?: boolean;
+    labels?: {
+        fullView?: string;
+    };
+}
+export interface ChatToolFullViewDialogProps {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    content: string;
+}
+export interface ChatToolGroupProps extends ChatSxProps {
+    tools: ChatToolItem[];
+    /** Whether the group accordion is expanded */
+    expanded?: boolean;
+    /** Callback when group expansion state changes */
+    onExpandedChange?: (expanded: boolean) => void;
+    /** Map of tool IDs to their individual expanded state. Used to preserve expansion state during grouping. */
+    expandedTools?: Record<string, boolean>;
+    /** Callback when an individual tool's expansion state changes */
+    onToolExpandedChange?: (value: Record<string, boolean>, toolId?: string) => void;
+    labels?: ChatToolTraceProps['labels'] & {
+        toolsUsed?: string;
+    };
+}

package/dist/types/chat/use-typewriter.d.ts

@@ -0,0 +1,30 @@
+interface UseTypewriterOptions {
+    /** Characters revealed per second (default: `500`). */
+    speed?: number;
+    /** When true on mount, skip the animation and reveal the full text immediately. */
+    skipAnimation?: boolean;
+}
+interface UseTypewriterResult {
+    /** The portion of `fullText` revealed so far. */
+    displayedText: string;
+    /** `true` while characters are still being revealed. */
+    isTyping: boolean;
+}
+/**
+ * Reveals a string character-by-character at a steady rate via
+ * `requestAnimationFrame`. Useful for smoothing out bursty WebSocket-streamed
+ * agent message text — pair it with `ChatAgentMessage`.
+ *
+ * @example
+ * ```tsx
+ * const { displayedText, isTyping } = useTypewriter(message)
+ * return (
+ *   <ChatAgentMessage>
+ *     <Markdown>{displayedText}</Markdown>
+ *     {isTyping ? <Cursor /> : null}
+ *   </ChatAgentMessage>
+ * )
+ * ```
+ */
+export declare function useTypewriter(fullText: string, options?: UseTypewriterOptions): UseTypewriterResult;
+export {};

package/dist/types/components/copy-button/copy-button.d.ts

@@ -0,0 +1,2 @@
+import { CopyButtonProps } from './types';
+export declare function CopyButton({ copyText, onSuccess, onError, 'aria-label': ariaLabel, ...props }: CopyButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/copy-button/types.d.ts

@@ -0,0 +1,6 @@
+import { IconButtonProps } from '@mui/material/IconButton';
+export interface CopyButtonProps extends Omit<IconButtonProps, 'onError' | 'onClick'> {
+    copyText: string;
+    onSuccess?: () => void;
+    onError?: (err: Error) => void;
+}

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

@@ -18,3 +18,5 @@ export { BasemapsUI } from './basemaps/basemaps';
 export type { BasemapsUIProps } from './basemaps/types';
 export { Tooltip, setTooltipEnterDelay } from './tooltip/tooltip';
 export { SmartTooltip } from './smart-tooltip/smart-tooltip';
+export type { CopyButtonProps } from './copy-button/types';
+export { CopyButton } from './copy-button/copy-button';

package/dist/types/components/lasso-tool/styles.d.ts

@@ -6,6 +6,7 @@ export declare const styles: {
         alignItems: "center";
         justifyContent: "flex-start";
         overflow: "hidden";
+        width: string;
         '&.inline': {
             flexDirection: "column";
             alignItems: "flex-start";

package/dist/types/components/measurement-tools/styles.d.ts

@@ -7,6 +7,7 @@ export declare const styles: {
         justifyContent: "flex-start";
         gap: ({ spacing }: Theme) => string;
         overflow: "hidden";
+        width: string;
     };
     actions: {
         icon: {

package/dist/types/widgets-v2/actions/index.d.ts

@@ -1,5 +1,6 @@
 export { Searcher, SearcherToggle, setSearcherText, filterBySearchText, DEFAULT_SEARCHER_LABELS, type SearcherProps, type SearcherToggleProps, type SearcherLabels, } from './searcher';
 export { StackToggle, addStack, DEFAULT_STACK_TOGGLE_LABELS, type StackToggleProps, type StackToggleLabels, } from './stack-toggle';
+export { ShowAllToggle, setShowAll, SHOW_ALL_ID, DEFAULT_SHOW_ALL_LABELS, type ShowAllToggleProps, type ShowAllLabels, } from './show-all';
 export { ZoomToggle, addZoom, createAddZoom, ZOOM_LAYOUT, DEFAULT_ZOOM_TOGGLE_LABELS, type ZoomToggleProps, type ZoomToggleLabels, } from './zoom-toggle';
 export { BrushToggle, addBrush, DEFAULT_BRUSH_TOGGLE_LABELS, type BrushToggleProps, type BrushToggleLabels, } from './brush-toggle';
 export { RelativeData, toRelativeData, createPercentFormatter, DEFAULT_RELATIVE_DATA_LABELS, type RelativeDataProps, type RelativeDataLabels, } from './relative-data';

package/dist/types/widgets-v2/actions/show-all/index.d.ts

@@ -0,0 +1,2 @@
+export { ShowAllToggle, setShowAll, SHOW_ALL_ID, type ShowAllToggleProps, } from './show-all';
+export { DEFAULT_SHOW_ALL_LABELS, type ShowAllLabels } from './labels';

package/dist/types/widgets-v2/actions/show-all/labels.d.ts

@@ -0,0 +1,5 @@
+export interface ShowAllLabels {
+    /** Tooltip + aria-label for the collapse (✕) button shown while expanded. */
+    toggle: string;
+}
+export declare const DEFAULT_SHOW_ALL_LABELS: ShowAllLabels;

package/dist/types/widgets-v2/actions/show-all/show-all.d.ts

@@ -0,0 +1,33 @@
+import { ComponentType } from 'react';
+import { SvgIconProps } from '@mui/material';
+import { ShowAllLabels } from './labels';
+/**
+ * The `show-all` flag is a pure UI signal (no data/config transform): the
+ * Category overflow row writes it `true` via {@link setShowAll}, the
+ * composer reads it with `useTransformEnabled(id, SHOW_ALL_ID)` to drop the
+ * row cap, and this button writes it back `false` to collapse. Stored under
+ * `transformStates` so `useTransformEnabled` can observe it like any other
+ * action flag — but it never registers a pipeline transform, so toggling it
+ * never re-runs the data pipeline.
+ */
+export declare const SHOW_ALL_ID = "show-all";
+export interface ShowAllToggleProps {
+    labels?: Partial<ShowAllLabels>;
+    icon?: ComponentType<SvgIconProps>;
+    iconProps?: SvgIconProps;
+}
+/**
+ * Collapse (✕) affordance shown while a widget is expanded into its
+ * "show all" state. Clicking it clears the `show-all` flag, returning the
+ * widget to its capped view. Mount it conditionally (only while the flag is
+ * set) so it doesn't occupy a `Widget.Toolbox` visibility-budget slot when
+ * the widget is collapsed.
+ */
+export declare function ShowAllToggle({ labels, icon: Icon, iconProps, }: ShowAllToggleProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Imperatively writes the `show-all` flag into the widget store. Mirrors
+ * {@link setSearcherText} — used by the Category overflow row (to expand)
+ * and the {@link ShowAllToggle} button (to collapse) without routing through
+ * a re-rendered subscription.
+ */
+export declare function setShowAll(widgetId: string, value: boolean): void;

package/dist/types/widgets-v2/actions/show-all/style.d.ts

@@ -0,0 +1,8 @@
+export declare const styles: {
+    toggle: {
+        p: number;
+        '& .MuiSvgIcon-root': {
+            fontSize: number;
+        };
+    };
+};

package/dist/types/widgets-v2/category/category-ui.d.ts

@@ -23,7 +23,7 @@ export interface CategoryUIProps {
      * Caps the number of visible category rows.
      *
      * - `undefined` (omitted) — caps at {@link DEFAULT_MAX_ITEMS} (20).
-     *   Surplus rows fold into a single italic "Other (X more)" footer.
+     *   Surplus rows fold into a single "Others <count>" footer row.
      *   `undefined` cannot mean "no cap" because it's consumed by the
      *   default-parameter syntax — pass `null` instead.
      * - positive finite N — same as the default but with a custom cap.
@@ -44,6 +44,13 @@ export interface CategoryUIProps {
     maxItems?: number | null;
     /** Labels for the "Other" overflow row. `{count}` placeholder is replaced. */
     labels?: CategoryLabels;
+    /**
+     * When provided, the "Other" overflow row becomes a button — clicking it
+     * fires `onShowAll`, which a composer typically wires to expand the widget
+     * (drop the row cap) so every category becomes reachable. When omitted the
+     * overflow row stays a static summary.
+     */
+    onShowAll?: () => void;
     /** Manual override for the bar-width denominator. */
     maxOverride?: number;
     /**
@@ -78,4 +85,4 @@ export interface CategoryUIProps {
  * Returns `null` when there's nothing to render — `Widget.State` is the
  * empty-state authority in the canonical compositor.
  */
-export declare function CategoryUI({ data, selection, onSelectionChange, formatter, labelFormatter, series, maxItems, labels, maxOverride, size, stacked, }: CategoryUIProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function CategoryUI({ data, selection, onSelectionChange, formatter, labelFormatter, series, maxItems, labels, onShowAll, maxOverride, size, stacked, }: CategoryUIProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/widgets-v2/category/category.d.ts

@@ -7,7 +7,7 @@ export interface CategoryProps {
     /** Per-series metadata. Enables the legend + overrides palette per index. */
     series?: readonly CategorySeriesConfig[];
     /**
-     * Cap visible rows; overflow folds into "Other (X more)". Default 20
+     * Cap visible rows; overflow folds into an "Others <count>" row. Default 20
      * (when omitted). Pass `0` to swap the cap for a scrollable viewport
      * (composers use this when the user opens the SearcherToggle —
      * `maxItems = searcherOpen ? 0 : userMaxItems`). Pass `null` to disable
@@ -16,6 +16,13 @@ export interface CategoryProps {
     maxItems?: number | null;
     /** Labels for the "Other" overflow row. */
     labels?: CategoryLabels;
+    /**
+     * When provided, the "Other" overflow row becomes a button that fires this
+     * callback. Composers wire it to expand the widget (e.g. flip the
+     * `show-all` flag) so every category is shown. Forwarded to
+     * {@link CategoryUI}.
+     */
+    onShowAll?: () => void;
     /**
      * Manual override for the bar-width denominator. When omitted, the
      * bridge auto-fills from the widget store's `rawData` so bar widths
@@ -45,4 +52,4 @@ export interface CategoryProps {
  * `onSelectionChange` follow the destination-owned principle: the
  * consumer keeps the list in their own store and passes it through.
  */
-export declare function Category({ selection, onSelectionChange, series, maxItems, labels, maxOverride, size, stacked, }: CategoryProps): import("react/jsx-runtime").JSX.Element;
+export declare function Category({ selection, onSelectionChange, series, maxItems, labels, onShowAll, maxOverride, size, stacked, }: CategoryProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/widgets-v2/category/components/category-row-other.d.ts

@@ -1,13 +1,26 @@
 export interface CategoryRowOtherProps {
     hiddenCount: number;
-    /** Label for the overflow row. Defaults to `'Other'`. */
+    /** Label for the overflow row. Defaults to `'Others'`. */
     otherLabel?: string;
-    /** Count text with `{count}` placeholder. Defaults to `'{count} more'`. */
+    /** Count text with `{count}` placeholder. Defaults to `'{count}'`. */
     otherCountLabel?: string;
+    /**
+     * When provided, the row becomes a button: clicking it (or Enter/Space)
+     * fires `onShowAll`, expanding the widget to reveal every category. When
+     * omitted the row renders as a static, non-interactive summary.
+     */
+    onShowAll?: () => void;
+    /** Tooltip shown over the button form. Defaults to `'Show all'`. */
+    showAllLabel?: string;
 }
 /**
- * Static "Other (X more)" overflow summary row. Rendered after the last
- * visible category row when `data.length > maxItems`. Non-interactive —
- * no selection, no keyboard target.
+ * Overflow summary row rendered after the last visible category row when
+ * `data.length > maxItems`. Shows `Others <count>` (count muted, no
+ * parentheses).
+ *
+ * When `onShowAll` is supplied the row is an interactive button — clicking
+ * it (or Enter/Space) expands the widget to show all categories, mirroring
+ * the Searcher's full-list view. Without `onShowAll` it stays a static,
+ * non-interactive summary (backward-compatible default).
  */
-export declare function CategoryRowOther({ hiddenCount, otherLabel, otherCountLabel, }: CategoryRowOtherProps): import("react/jsx-runtime").JSX.Element;
+export declare function CategoryRowOther({ hiddenCount, otherLabel, otherCountLabel, onShowAll, showAllLabel, }: CategoryRowOtherProps): import("react/jsx-runtime").JSX.Element;