@pstdio/ui 0.16.0 → 0.17.0

package/dist/components/{data-renderer → kanban-renderer}/types.d.ts

@@ -51,13 +51,13 @@ export interface AttributeDescriptor {
     displayable?: boolean;
     editable?: boolean;
     display?: AttributeDisplayDescriptor;
-    render?: (value: unknown, row: DataRendererRow) => ReactNode;
+    render?: (value: unknown, row: KanbanRendererRow) => ReactNode;
     compare?: (a: unknown, b: unknown) => number;
 }
 /**
  * Reactive source for an entire attribute schema. Mirrors React's
  * useSyncExternalStore contract so consumers (e.g. the workbench's
- * data-renderer bridge) can subscribe and re-resolve when the schema changes
+ * kanban-renderer bridge) can subscribe and re-resolve when the schema changes
  * — letting a contribution add/remove/edit attributes at runtime without
  * re-registering.
  */
@@ -66,7 +66,7 @@ export interface AttributesSource {
     getSnapshot: () => AttributeDescriptor[];
 }
 export declare const isAttributesSource: (attributes: AttributeDescriptor[] | AttributesSource) => attributes is AttributesSource;
-export interface DataRendererRow {
+export interface KanbanRendererRow {
     id: string;
     title: string;
     /**
@@ -77,19 +77,62 @@ export interface DataRendererRow {
     resource?: unknown;
     attributes: Record<string, unknown>;
 }
-export interface DataRendererOrdering {
+export interface KanbanRendererOrdering {
     attributeId: string | typeof MANUAL_ORDERING;
     direction: SortDirection;
 }
-export interface DataRendererSettings {
+export interface KanbanRendererSettings {
     viewMode: ViewMode;
     columnGrouping: string | typeof NO_GROUPING;
     rowGrouping: string | typeof NO_GROUPING;
-    ordering: DataRendererOrdering;
+    ordering: KanbanRendererOrdering;
     displayProperties: string[];
 }
-export type DataRendererFilterState = Record<string, string[]>;
-export declare const DEFAULT_DATA_RENDERER_SETTINGS: DataRendererSettings;
+export type KanbanRendererFilterState = Record<string, string[]>;
+export interface KanbanRendererSavedView {
+    id: string;
+    title: string;
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+    isDefault?: boolean;
+}
+export type KanbanRendererCreateFieldType = "text" | "longtext" | "markdown" | "number" | "boolean" | "select" | "multi-select" | "files";
+export interface KanbanRendererCreateField {
+    id: string;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    type: KanbanRendererCreateFieldType;
+    required?: boolean;
+    defaultValue?: unknown;
+    options?: EnumOption[];
+    /** `files` fields only. */
+    multiple?: boolean;
+    accept?: string;
+}
+/** Chrome copy is supplied by the caller so the dialog ships no strings of its own. */
+export interface KanbanRendererCreateLabels {
+    cancel: string;
+    properties: string;
+    submitError: string;
+    removeFile: string;
+}
+export interface KanbanRendererCreateRowConfig {
+    title: string;
+    submitLabel: string;
+    fields: KanbanRendererCreateField[];
+    labels: KanbanRendererCreateLabels;
+}
+export interface KanbanRendererCreateSubmission {
+    columnId: string;
+    columnAttributeId?: string;
+    /** Declared field values, excluding `files` fields — those arrive as `files`. */
+    values: Record<string, unknown>;
+    /** Every editable attribute the user set, keyed by attribute id. */
+    attributeValues: Record<string, unknown>;
+    files: File[];
+}
+export declare const DEFAULT_KANBAN_RENDERER_SETTINGS: KanbanRendererSettings;
 /**
  * Look up an attribute by id from a contribution-provided descriptor list.
  * Returns undefined for sentinels ("none", "manual") or unknown ids.

package/dist/components/kanban-renderer/use-kanban-renderer-store.d.ts

@@ -0,0 +1,78 @@
+import { KanbanRendererFilterState, KanbanRendererSavedView, KanbanRendererSettings } from './types';
+interface KanbanRendererSnapshot {
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+    expandedGroups: Record<string, boolean>;
+    views: KanbanRendererSavedView[];
+    activeViewId: string;
+}
+interface KanbanRendererStoreInitialState {
+    settings?: Partial<KanbanRendererSettings>;
+    filters?: KanbanRendererFilterState;
+    expandedGroups?: Record<string, boolean>;
+    views?: KanbanRendererSavedView[];
+    activeViewId?: string;
+}
+interface KanbanRendererState extends KanbanRendererSnapshot {
+    setViewMode: (viewMode: KanbanRendererSettings["viewMode"]) => void;
+    setColumnGrouping: (columnGrouping: KanbanRendererSettings["columnGrouping"]) => void;
+    setRowGrouping: (rowGrouping: KanbanRendererSettings["rowGrouping"]) => void;
+    setOrdering: (ordering: KanbanRendererSettings["ordering"]) => void;
+    setOrderingAttributeId: (attributeId: KanbanRendererSettings["ordering"]["attributeId"]) => void;
+    setDisplayProperties: (displayProperties: string[]) => void;
+    toggleSortDirection: () => void;
+    toggleDisplayProperty: (property: string) => void;
+    setFilter: (attributeId: string, values: string[]) => void;
+    toggleFilterValue: (attributeId: string, value: string) => void;
+    clearFilter: (attributeId: string) => void;
+    clearAllFilters: () => void;
+    setExpandedGroup: (groupId: string, isExpanded: boolean) => void;
+    activateView: (viewId: string) => void;
+    createView: (view: {
+        id: string;
+        title: string;
+    }) => void;
+    saveActiveView: () => void;
+    resetActiveView: () => void;
+    renameView: (viewId: string, title: string) => void;
+    duplicateView: (viewId: string, duplicate: {
+        id: string;
+        title: string;
+    }) => void;
+    deleteView: (viewId: string) => void;
+    setDefaultView: (viewId: string) => void;
+    reset: () => void;
+}
+interface CreateKanbanRendererStoreOptions {
+    storageKey: string;
+    initialState?: KanbanRendererStoreInitialState;
+}
+export declare const createKanbanRendererStore: (options: CreateKanbanRendererStoreOptions) => Omit<import('zustand').StoreApi<KanbanRendererState>, "setState" | "persist"> & {
+    setState(partial: KanbanRendererState | Partial<KanbanRendererState> | ((state: KanbanRendererState) => KanbanRendererState | Partial<KanbanRendererState>), replace?: false | undefined): unknown;
+    setState(state: KanbanRendererState | ((state: KanbanRendererState) => KanbanRendererState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<KanbanRendererState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: KanbanRendererState) => void) => () => void;
+        onFinishHydration: (fn: (state: KanbanRendererState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<KanbanRendererState, unknown, unknown>>;
+    };
+};
+export declare const getKanbanRendererStore: (storageKey: string, initialState?: KanbanRendererStoreInitialState) => Omit<import('zustand').StoreApi<KanbanRendererState>, "setState" | "persist"> & {
+    setState(partial: KanbanRendererState | Partial<KanbanRendererState> | ((state: KanbanRendererState) => KanbanRendererState | Partial<KanbanRendererState>), replace?: false | undefined): unknown;
+    setState(state: KanbanRendererState | ((state: KanbanRendererState) => KanbanRendererState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<KanbanRendererState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: KanbanRendererState) => void) => () => void;
+        onFinishHydration: (fn: (state: KanbanRendererState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<KanbanRendererState, unknown, unknown>>;
+    };
+};
+export declare const useKanbanRendererStore: <T>(storageKey: string, selector: (state: KanbanRendererState) => T, initialState?: KanbanRendererStoreInitialState) => T;
+export declare const isActiveKanbanRendererViewDirty: (state: Pick<KanbanRendererState, "activeViewId" | "filters" | "settings" | "views">) => boolean;
+export type { KanbanRendererSnapshot, KanbanRendererState, KanbanRendererStoreInitialState };

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

@@ -3,4 +3,5 @@ export { Header } from './header';
 export { HorizontalMenuStack } from './horizontal-menu-stack';
 export type { ItemSectionProps } from './item-section';
 export { ItemSection } from './item-section';
+export { PANEL_HEADER_CONTROL_SIZE, PANEL_HEADER_HEIGHT, PANEL_HEADER_TAB_SIZE, } from './panel-header.constants';
 export { ResizableSplitLayout } from './resizable-split-layout';

package/dist/components/layout/panel-header.constants.d.ts

@@ -1 +1,3 @@
 export declare const PANEL_HEADER_HEIGHT = "2.5rem";
+export declare const PANEL_HEADER_CONTROL_SIZE: "2xs";
+export declare const PANEL_HEADER_TAB_SIZE: "sm";

package/dist/components/layout/resizable-split-layout.d.ts

@@ -1,6 +1,6 @@
 import { FlexProps } from '@chakra-ui/react';
 import { ReactNode } from 'react';
-import { ResizableSplitSide } from './resizable-split-layout.handle';
+import { ResizableSplitSide } from './resizable-split-layout.geometry';
 interface ResizableSplitLayoutProps extends Omit<FlexProps, "children" | "onResize"> {
     resizablePanel: ReactNode;
     contentPanel: ReactNode;
@@ -12,8 +12,9 @@ interface ResizableSplitLayoutProps extends Omit<FlexProps, "children" | "onResi
     collapsed?: boolean;
     collapsible?: boolean;
     resizeLabel?: string;
+    resizeHandleSizePx?: number;
     showResizeSeparator?: boolean;
-    onSizeChange?: (width: number) => void;
+    onSizeChange?: (size: number) => void;
     onCollapsedChange?: (collapsed: boolean) => void;
 }
 export declare const ResizableSplitLayout: (props: ResizableSplitLayoutProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/layout/resizable-split-layout.geometry.d.ts

@@ -0,0 +1,56 @@
+export type ResizableSplitSide = "left" | "right" | "top" | "bottom";
+export declare const getResizableSplitAxis: (side: ResizableSplitSide) => {
+    readonly rootDirection: "row";
+    readonly dimension: "width";
+    readonly separatorOrientation: "vertical";
+    readonly cursor: "col-resize";
+    readonly pointerCoordinate: "clientX";
+    readonly deltaDirection: 1;
+    readonly panelFirst: true;
+} | {
+    readonly rootDirection: "row";
+    readonly dimension: "width";
+    readonly separatorOrientation: "vertical";
+    readonly cursor: "col-resize";
+    readonly pointerCoordinate: "clientX";
+    readonly deltaDirection: -1;
+    readonly panelFirst: false;
+} | {
+    readonly rootDirection: "column";
+    readonly dimension: "height";
+    readonly separatorOrientation: "horizontal";
+    readonly cursor: "row-resize";
+    readonly pointerCoordinate: "clientY";
+    readonly deltaDirection: 1;
+    readonly panelFirst: true;
+} | {
+    readonly rootDirection: "column";
+    readonly dimension: "height";
+    readonly separatorOrientation: "horizontal";
+    readonly cursor: "row-resize";
+    readonly pointerCoordinate: "clientY";
+    readonly deltaDirection: -1;
+    readonly panelFirst: false;
+};
+export declare const resolveResizableBounds: (input: {
+    rootSize: number;
+    fallbackRootSize: number;
+    minSize: number;
+    maxSize?: number;
+    contentMinSize: number;
+}) => {
+    minSize: number;
+    maxSize: number;
+};
+export declare const resolveDraggedPanelSize: (input: {
+    side: ResizableSplitSide;
+    startSize: number;
+    pointerDelta: number;
+    minSize: number;
+    maxSize: number;
+    collapsible: boolean;
+}) => {
+    rawSize: number;
+    size: number;
+    collapsed: boolean;
+};

package/dist/components/layout/resizable-split-layout.handle.d.ts

@@ -1,14 +1,18 @@
 import { KeyboardEvent as ReactKeyboardEvent, PointerEvent as ReactPointerEvent } from 'react';
-export type ResizableSplitSide = "left" | "right";
+import { getResizableSplitAxis } from './resizable-split-layout.geometry';
 interface ResizeHandleProps {
+    axis: ReturnType<typeof getResizableSplitAxis>;
     bounds: {
         minSize: number;
         maxSize: number;
     };
+    collapsed: boolean;
+    collapsible: boolean;
     contentPanelId: string;
     resizablePanelId: string;
+    resizeHandleSizePx: number;
     resizeLabel: string;
-    resolvedPanelWidth: number;
+    resolvedPanelSize: number;
     showResizeSeparator: boolean;
     onResizeKeyDown: (event: ReactKeyboardEvent<HTMLDivElement>) => void;
     onResizeStart: (event: ReactPointerEvent<HTMLDivElement>) => void;

package/dist/components/layout/resizable-split-layout.panels.d.ts

@@ -0,0 +1,25 @@
+import { KeyboardEvent as ReactKeyboardEvent, ReactNode, PointerEvent as ReactPointerEvent, RefObject } from 'react';
+import { getResizableSplitAxis } from './resizable-split-layout.geometry';
+interface ResizableSplitPanelsProps {
+    axis: ReturnType<typeof getResizableSplitAxis>;
+    bounds: {
+        minSize: number;
+        maxSize: number;
+    };
+    collapsed: boolean;
+    collapsible: boolean;
+    contentPanel: ReactNode;
+    contentPanelId: string;
+    contentPanelRef: RefObject<HTMLDivElement | null>;
+    resizablePanel: ReactNode;
+    resizablePanelId: string;
+    resizablePanelRef: RefObject<HTMLDivElement | null>;
+    resizeHandleSizePx: number;
+    resizeLabel: string;
+    resolvedPanelSize: number;
+    showResizeSeparator: boolean;
+    onResizeKeyDown: (event: ReactKeyboardEvent<HTMLDivElement>) => void;
+    onResizeStart: (event: ReactPointerEvent<HTMLDivElement>) => void;
+}
+export declare const ResizableSplitPanels: (props: ResizableSplitPanelsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/list-row/list-row-actions.d.ts

@@ -5,6 +5,7 @@ interface RowActionsProps {
         sectionId?: string;
         nodeId?: string;
     };
+    alwaysVisible?: boolean;
 }
 export declare const RowActions: (props: RowActionsProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/components/list-row/list-row-content.d.ts

@@ -1,4 +1,10 @@
 import { ListRowItem, ListRowProps } from './list-row.types';
+export declare const createResourceRowActions: (item: ListRowItem, showContextMenuTrigger?: boolean) => import('./list-row.types').ListRowAction[] | {
+    id: string;
+    label: string;
+    icon: import("react/jsx-runtime").JSX.Element;
+    menuItems: import('./list-row.types').ListRowActionMenuItem[];
+}[];
 export declare const ListRowContent: (props: {
     item: ListRowItem;
     isExpanded: boolean;
@@ -6,4 +12,5 @@ export declare const ListRowContent: (props: {
     isDisabled: boolean;
     tone: ListRowProps["tone"];
     variant: ListRowProps["variant"];
+    showContextMenuTrigger: boolean;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/components/list-row/list-row.types.d.ts

@@ -13,6 +13,7 @@ export interface ListRowActionContext {
 export interface ListRowActionMenuItem {
     id: string;
     label: string;
+    commandId?: string;
     description?: string;
     icon?: ReactNode | ComponentType<{
         size?: number | string;
@@ -37,7 +38,7 @@ export interface ListRowAction {
     menuItems?: ListRowActionMenuItem[];
     onAction?: (context: ListRowActionContext) => void;
 }
-export type ListRowVariant = "default" | "compact" | "full-width" | "tree" | "empty-state";
+export type ListRowVariant = "default" | "compact" | "collection" | "full-width" | "tree" | "empty-state";
 export type ListRowTone = "default" | "danger";
 export type ListRowMenuPlacement = "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "right" | "right-start" | "right-end" | "left" | "left-start" | "left-end";
 /** Data model for one reusable row, including labels, icons, menus, actions, and children. */
@@ -80,6 +81,8 @@ export interface ListRowProps extends ListRowItem, Omit<ListRowRootProps, "as" |
     isExpanded?: boolean;
     /** Forces the expand affordance when children are lazy-loaded or externally controlled. */
     showExpandToggle?: boolean;
+    /** Shows context-menu actions from an inline trigger in addition to right-click access. */
+    showContextMenuTrigger?: boolean;
     variant?: ListRowVariant;
     tone?: ListRowTone;
     selectedBg?: ListRowRootProps["bg"];

package/dist/components/overlays/attached-menu.d.ts

@@ -0,0 +1,6 @@
+import { FlexProps } from '@chakra-ui/react';
+import { ReactNode } from 'react';
+export interface AttachedMenuProps extends Omit<FlexProps, "children"> {
+    children?: ReactNode;
+}
+export declare const AttachedMenu: (props: AttachedMenuProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/overlays/attachment-chip.d.ts

@@ -0,0 +1,13 @@
+export interface AttachmentChipProps {
+    file: File;
+    /** Accessible label for the remove control; the caller owns translation. */
+    removeLabel: string;
+    disabled?: boolean;
+    onRemove: () => void;
+}
+/**
+ * A file queued for upload, before the resource it belongs to exists. Removal
+ * lives on the chip because there is no other surface between picking a file
+ * and submitting where a mistaken attachment can be taken back.
+ */
+export declare const AttachmentChip: (props: AttachmentChipProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,11 +1,15 @@
+export type { AttachedMenuProps } from './attached-menu';
+export { AttachedMenu } from './attached-menu';
 export { AttachedPanel } from './attached-panel';
+export type { AttachmentChipProps } from './attachment-chip';
+export { AttachmentChip } from './attachment-chip';
 export { BubbleButton } from './bubble-button';
 export { BubblePanel } from './bubble-panel';
 export { DeleteConfirmationModal } from './delete-confirmation-modal';
 export type { RepoPickerDialogEntry, RepoPickerDialogProps } from './repo-picker-dialog';
 export { RepoPickerDialog } from './repo-picker-dialog';
-export type { ResourceContextAction } from './resource-context-menu';
-export { ResourceContextMenu } from './resource-context-menu';
+export type { ResourceActionMenuProps, ResourceContextAction } from './resource-context-menu';
+export { ResourceActionMenu, ResourceContextMenu } from './resource-context-menu';
 export type { SearchModalContentProps } from './search-modal-content';
 export { SearchModalContent } from './search-modal-content';
 export type { SearchableMenuItem, SearchableMenuParentList } from './searchable-menu';

package/dist/components/overlays/resource-context-menu.d.ts

@@ -1,9 +1,10 @@
 import { Menu } from '@chakra-ui/react';
-import { ComponentProps, ReactNode } from 'react';
+import { ComponentProps, ReactElement, ReactNode } from 'react';
 type MenuRootProps = ComponentProps<typeof Menu.Root>;
 export interface ResourceContextAction {
     key: string;
     label: string;
+    commandId?: string;
     onClick: () => Promise<void> | void;
     isDisabled?: boolean;
     icon?: ReactNode;
@@ -18,6 +19,17 @@ interface ResourceContextMenuProps {
     positioning?: MenuRootProps["positioning"];
     /** Keep the menu open after selecting an item — useful for menus that toggle several entries in one pass. */
     closeOnSelect?: MenuRootProps["closeOnSelect"];
+    /** Preserve the trigger tree while actions load or change. */
+    keepMountedWhenEmpty?: boolean;
 }
+export interface ResourceActionMenuProps {
+    actions: ResourceContextAction[];
+    children: ReactElement;
+    contentMinWidth?: string;
+    contentBackground?: string;
+    positioning?: MenuRootProps["positioning"];
+    closeOnSelect?: MenuRootProps["closeOnSelect"];
+}
+export declare const ResourceActionMenu: (props: ResourceActionMenuProps) => import("react/jsx-runtime").JSX.Element;
 export declare const ResourceContextMenu: (props: ResourceContextMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/param-editor/index.d.ts

@@ -14,12 +14,13 @@ export { TextInput } from './inputs/text-input';
 export { VectorInput } from './inputs/vector-input';
 export type { ParamEditorProps } from './param-editor';
 export { ParamEditor } from './param-editor';
-export type { ActionOption, ActionsParam, AnchorGridParam, AnchorGridValue, BaseParam, ColorParam, DateParam, FileDropParam, FileDropValue, InputGroup, NumberParam, Param, ParamValue, ParamValueMap, PropertyParam, RangeParam, RangeValue, ResourceOption, ResourceParam, ResourceRefValue, SegmentedOption, SegmentedParam, SelectionParam, TextParam, VectorParam, VectorValue, } from './param-editor.types';
+export type { ActionOption, ActionsParam, AnchorGridParam, AnchorGridValue, BaseParam, ColorParam, DateParam, FileDropParam, FileDropValue, InputGroup, NumberParam, Param, ParamEditorReadOnlyContent, ParamEditorReadOnlyImage, ParamValue, ParamValueMap, PropertyParam, RangeParam, RangeValue, ReadOnlyParam, ResourceOption, ResourceParam, ResourceRefValue, SegmentedOption, SegmentedParam, SelectionParam, TextParam, VectorParam, VectorValue, } from './param-editor.types';
 export { ParamEditorControlItem } from './param-editor-control-item';
 export { ParamEditorControlList } from './param-editor-control-list';
 export { ParamEditorField } from './param-editor-field';
 export { ParamEditorFieldLabel } from './param-editor-field-label';
 export { ParamEditorInlineGroup } from './param-editor-inline-group';
 export { ParamEditorLabel } from './param-editor-label';
+export { ParamEditorReadOnlyField } from './param-editor-read-only-field';
 export { ParamEditorReadOnlyValue } from './param-editor-read-only-value';
 export { ParamEditorSection } from './param-editor-section';

package/dist/components/param-editor/inputs/selection-input.d.ts

@@ -1,13 +1,9 @@
-interface Option {
-    id: string;
-    name: string;
-    icon?: string;
-}
+import { SelectionMenuOption } from './selection-menu';
 interface SelectionInputProps {
     id: string;
     defaultValue: string | string[];
     name: string;
-    options: Option[];
+    options: SelectionMenuOption[];
     onChange: (id: string, value: string | string[]) => void;
     description: string;
     readOnly?: boolean;
@@ -16,6 +12,10 @@ interface SelectionInputProps {
     tooltipPlacement?: "top" | "right" | "bottom" | "left";
     placeholder?: string;
     fullWidth?: boolean;
+    /** Re-picking the selected option clears it. */
+    clearable?: boolean;
+    /** Inert, but still rendered as a control. */
+    disabled?: boolean;
 }
 export declare const SelectionInput: (props: SelectionInputProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/param-editor/inputs/selection-menu.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+export interface SelectionMenuOption {
+    id: string;
+    name: string;
+    icon?: string;
+    /** Palette key (e.g. "blue") applied to the option's icon. */
+    color?: string;
+    description?: string;
+}
+export interface SelectionMenuProps {
+    triggerLabel: ReactNode;
+    options: SelectionMenuOption[];
+    selectedIds: string[];
+    multiSelect: boolean;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    onToggle: (optionId: string) => void;
+}
+export declare const selectionIndicator: (multiSelect: boolean, selected: boolean) => import("react/jsx-runtime").JSX.Element | null;
+export declare const selectionOptionIcon: (option: SelectionMenuOption | undefined, boxSize: string) => import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The single dropdown behind every option picker in the editor — selection
+ * params and editable resource params alike. Sharing it is what keeps a
+ * resource attribute and a command param from drifting into two looks.
+ *
+ * Single-selects clear by re-picking the selected option; a dedicated "none"
+ * row would read as just another value to choose.
+ */
+export declare const SelectionMenu: (props: SelectionMenuProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/param-editor/param-editor-horizontal.d.ts

@@ -6,5 +6,6 @@ export interface ParamEditorHorizontalProps {
     onChange: (id: string, value: ParamValue) => void;
     readOnly?: boolean;
     fullWidth?: boolean;
+    variant?: "default" | "small";
 }
 export declare const ParamEditorHorizontal: (props: ParamEditorHorizontalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/param-editor/param-editor-read-only-field.d.ts

@@ -0,0 +1,9 @@
+import { Param } from './param-editor.types';
+interface ParamEditorReadOnlyFieldProps {
+    param: Extract<Param, {
+        type: "readOnly";
+    }>;
+    fullWidth?: boolean;
+}
+export declare const ParamEditorReadOnlyField: (props: ParamEditorReadOnlyFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/param-editor-section.d.ts

@@ -11,6 +11,7 @@ interface ParamEditorSectionProps {
     collapsible?: boolean;
     defaultCollapsed?: boolean;
     isFirst?: boolean;
+    variant?: "default" | "small";
 }
 export declare const ParamEditorSection: (props: ParamEditorSectionProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/param-editor/param-editor.d.ts

@@ -7,5 +7,6 @@ export interface ParamEditorProps {
     onOpenResource?: (ref: ResourceRefValue) => void;
     readOnly?: boolean;
     fullWidth?: boolean;
+    variant?: "default" | "small";
 }
 export declare const ParamEditor: (props: ParamEditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/param-editor/param-editor.types.d.ts

@@ -3,6 +3,8 @@ export interface BaseParam {
     id: string;
     name: string;
     description?: string;
+    /** Locks this one param while the rest of the editor stays editable. */
+    readOnly?: boolean;
 }
 export interface NumberParam extends BaseParam {
     type: "number";
@@ -16,16 +18,26 @@ export interface TextParam extends BaseParam {
     defaultValue: string;
     singleLine?: boolean;
 }
+export interface SelectionOption {
+    id: string;
+    name: string;
+    icon?: string;
+    /** Palette key (e.g. "blue") applied to the option's icon. */
+    color?: string;
+}
 export interface SelectionParam extends BaseParam {
     type: "selection";
     defaultValue: string | string[];
-    options: {
-        id: string;
-        name: string;
-        icon?: string;
-    }[];
+    options: SelectionOption[];
     multiSelect?: boolean;
     placeholder?: string;
+    /** Adds a "clear" row so a single-select can be returned to unset. */
+    clearable?: boolean;
+    /**
+     * Renders the control inert but still as a control — unlike `readOnly`, which
+     * collapses it to plain text and drops the option's icon.
+     */
+    disabled?: boolean;
 }
 export interface DateParam extends BaseParam {
     type: "date";
@@ -41,6 +53,23 @@ export interface PropertyParam extends BaseParam {
     type: "property";
     value: ReactNode;
 }
+export interface ParamEditorReadOnlyImage {
+    src: string;
+    alt: string;
+}
+export type ParamEditorReadOnlyContent = string | number | boolean | null | Array<string | number | boolean | null> | {
+    type: "image";
+    src: string;
+    alt: string;
+} | {
+    type: "image-gallery";
+    images: ParamEditorReadOnlyImage[];
+};
+/** Serializable display-only value rendered by the read-only Param Editor. */
+export interface ReadOnlyParam extends BaseParam {
+    type: "readOnly";
+    value: ParamEditorReadOnlyContent;
+}
 /** A reference the host can open (e.g. another resource tab). */
 export interface ResourceRefValue {
     type: string;
@@ -154,5 +183,5 @@ export interface InputGroup {
     defaultCollapsed?: boolean;
 }
 export type ParamValue = number | string | null | string[] | RangeValue | VectorValue | FileDropValue;
-export type Param = NumberParam | TextParam | SelectionParam | DateParam | ColorParam | PropertyParam | ResourceParam | RangeParam | SegmentedParam | ActionsParam | AnchorGridParam | VectorParam | FileDropParam;
+export type Param = NumberParam | TextParam | SelectionParam | DateParam | ColorParam | PropertyParam | ReadOnlyParam | ResourceParam | RangeParam | SegmentedParam | ActionsParam | AnchorGridParam | VectorParam | FileDropParam;
 export type ParamValueMap = Record<string, ParamValue>;

package/dist/components/rich-text/prompt-input/plugins/ReferenceMenuPlugin/ReferenceMenuPlugin.d.ts

@@ -1,7 +1,8 @@
+import { ReferenceResourceType } from '../../prompt-input';
 type Props = {
     items?: Array<{
         resourceId: string;
-        resourceType: "table" | "connector";
+        resourceType: ReferenceResourceType;
         name: string;
         description?: string;
     }>;

package/dist/components/rich-text/prompt-input/plugins/ReferenceMenuPlugin/hooks/useContextLookup.d.ts

@@ -1,3 +1,4 @@
+import { ReferenceResourceType } from '../../../prompt-input';
 import { ReferenceMenuOption } from '../ReferenceMenuOption';
 /**
  * Search across all resources and menu options
@@ -7,7 +8,7 @@ import { ReferenceMenuOption } from '../ReferenceMenuOption';
  */
 export declare function useContextLookup(queryString: string | null, items?: {
     resourceId: string;
-    resourceType: "table" | "connector";
+    resourceType: ReferenceResourceType;
     name: string;
     description?: string;
 }[]): ReferenceMenuOption[];

package/dist/components/rich-text/prompt-input/plugins/ReferencePlugin/ReferencePlugin.d.ts

@@ -1,6 +1,7 @@
 import { LexicalNode } from 'lexical';
 import { PropsWithChildren } from 'react';
+import { ReferenceResourceType } from '../../prompt-input';
 export declare const $insertExistingReference: (nodeToReplace: LexicalNode, resourceId: string, name: string) => void;
 export declare function ReferencePlugin(props: PropsWithChildren<{
-    onAddReference?: (resourceId: string, resourceType: "table" | "connector") => void;
+    onAddReference?: (resourceId: string, resourceType: ReferenceResourceType) => void;
 }>): null;