@pstdio/ui 0.15.0 → 0.17.0

package/dist/components/kanban-renderer/kanban-renderer-grouping.d.ts

@@ -0,0 +1,23 @@
+import { AttributeDescriptor, KanbanRendererFilterState, KanbanRendererOrdering, KanbanRendererRow } from './types';
+interface GroupingOptions {
+    attributes: AttributeDescriptor[];
+    columnGrouping: string;
+    rowGrouping: string;
+    knownColumnKeys?: string[];
+}
+interface KanbanRendererRowGroup {
+    key: string;
+    label: string;
+    rows: KanbanRendererRow[];
+}
+interface KanbanRendererColumnGroup {
+    key: string;
+    label: string;
+    rows: KanbanRendererRow[];
+    subgroups: KanbanRendererRowGroup[];
+}
+export declare const orderRows: (rows: KanbanRendererRow[], ordering: KanbanRendererOrdering, attributes: AttributeDescriptor[]) => KanbanRendererRow[];
+export declare const groupRows: (rows: KanbanRendererRow[], options: GroupingOptions) => KanbanRendererColumnGroup[];
+export declare const filterRows: (rows: KanbanRendererRow[], filters: KanbanRendererFilterState, attributes: AttributeDescriptor[]) => KanbanRendererRow[];
+export declare const countFilterValues: (rows: KanbanRendererRow[], attributeId: string, attributes: AttributeDescriptor[]) => Record<string, number>;
+export type { KanbanRendererColumnGroup, KanbanRendererRowGroup };

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

@@ -1,22 +1,22 @@
 import { ReactNode } from 'react';
-import { AttributeBadge } from './data-renderer-badge-helpers';
-import { AttributeDescriptor, DataRendererFilterState, DataRendererRow, DataRendererSettings } from './types';
-export type { AttributeBadge } from './data-renderer-badge-helpers';
-export { getAttributeBadgeColorPalette } from './data-renderer-badge-helpers';
-export { enumOptionLabel, findEnumOption, getEnumOptions, toTitleCase } from './data-renderer-enum-helpers';
+import { AttributeBadge } from './kanban-renderer-badge-helpers';
+import { AttributeDescriptor, KanbanRendererFilterState, KanbanRendererRow, KanbanRendererSettings } from './types';
+export type { AttributeBadge } from './kanban-renderer-badge-helpers';
+export { getAttributeBadgeColorPalette } from './kanban-renderer-badge-helpers';
+export { enumOptionLabel, findEnumOption, getEnumOptions, toTitleCase } from './kanban-renderer-enum-helpers';
 /**
  * Read a typed attribute value out of a row. enum-multi normalizes to an array;
  * single-valued kinds normalize to undefined when missing.
  */
-export declare const getAttributeValue: (row: DataRendererRow, descriptor: AttributeDescriptor) => unknown;
-export declare const getAttributeStringValues: (row: DataRendererRow, descriptor: AttributeDescriptor) => string[];
+export declare const getAttributeValue: (row: KanbanRendererRow, descriptor: AttributeDescriptor) => unknown;
+export declare const getAttributeStringValues: (row: KanbanRendererRow, descriptor: AttributeDescriptor) => string[];
 /**
  * Per-type default cell summary used by the card / list end-content. Returns
  * null when the attribute has no displayable value.
  */
-export declare const renderAttributeBadge: (descriptor: AttributeDescriptor, row: DataRendererRow) => AttributeBadge | null;
-export declare const collectDisplayBadges: (row: DataRendererRow, attributes: AttributeDescriptor[], displayProperties: string[]) => AttributeBadge[];
-export declare const collectDisplayCustomSlots: (row: DataRendererRow, attributes: AttributeDescriptor[], displayProperties: string[]) => ReactNode[];
+export declare const renderAttributeBadge: (descriptor: AttributeDescriptor, row: KanbanRendererRow) => AttributeBadge | null;
+export declare const collectDisplayBadges: (row: KanbanRendererRow, attributes: AttributeDescriptor[], displayProperties: string[]) => AttributeBadge[];
+export declare const collectDisplayCustomSlots: (row: KanbanRendererRow, attributes: AttributeDescriptor[], displayProperties: string[]) => ReactNode[];
 export interface FilterCategoryView {
     id: string;
     label: string;
@@ -33,7 +33,7 @@ export interface FilterCategoryView {
  * the data fill in the gaps for string / date / number / user attributes (so
  * filter chips for free-form fields don't require declaring every option).
  */
-export declare const buildFilterCategories: (attributes: AttributeDescriptor[], rows: DataRendererRow[]) => FilterCategoryView[];
+export declare const buildFilterCategories: (attributes: AttributeDescriptor[], rows: KanbanRendererRow[]) => FilterCategoryView[];
 export interface MenuOption {
     value: string;
     label: string;
@@ -45,13 +45,13 @@ export declare const resolveSubGroupingOptions: (options: MenuOption[], columnGr
 export declare const resolveListDropTargetColumnKey: (columnGrouping: string, placement?: {
     columnKey?: string;
 }) => string | undefined;
-export declare const resolveKnownColumnKeys: (columnGrouping: string, attributes: AttributeDescriptor[], filters?: DataRendererFilterState) => string[] | undefined;
+export declare const resolveKnownColumnKeys: (columnGrouping: string, attributes: AttributeDescriptor[], filters?: KanbanRendererFilterState) => string[] | undefined;
 export declare const normalizeFilterValues: (_descriptor: AttributeDescriptor, values: string[]) => string[];
-export declare const omitFilterCategory: (filters: DataRendererFilterState, id: string) => DataRendererFilterState;
+export declare const omitFilterCategory: (filters: KanbanRendererFilterState, id: string) => KanbanRendererFilterState;
 /**
  * Drop persisted settings entries that reference attribute ids no longer
  * declared by the contribution. Falls back to defaults for missing grouping
  * and ordering attributes so a stale saved view still loads cleanly.
  */
-export declare const sanitizeSettings: (settings: DataRendererSettings, attributes: AttributeDescriptor[]) => DataRendererSettings;
-export declare const sanitizeFilters: (filters: DataRendererFilterState, attributes: AttributeDescriptor[]) => DataRendererFilterState;
+export declare const sanitizeSettings: (settings: KanbanRendererSettings, attributes: AttributeDescriptor[]) => KanbanRendererSettings;
+export declare const sanitizeFilters: (filters: KanbanRendererFilterState, attributes: AttributeDescriptor[]) => KanbanRendererFilterState;

package/dist/components/kanban-renderer/kanban-renderer-list-items.d.ts

@@ -0,0 +1,25 @@
+import { ResourceContextAction } from '../overlays/resource-context-menu';
+import { KanbanRendererColumnGroup } from './kanban-renderer-grouping';
+import { KanbanRendererListItem } from './kanban-renderer-list';
+import { AttributeDescriptor, KanbanRendererRow, KanbanRendererSettings } from './types';
+interface BuildKanbanRendererListItemsInput<TRow extends KanbanRendererRow> {
+    settings: KanbanRendererSettings;
+    visibleRows: TRow[];
+    grouped: KanbanRendererColumnGroup[];
+    attributes: AttributeDescriptor[];
+    onRowClick?: (row: TRow) => void;
+    onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => Promise<void> | void;
+    onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
+    getRowContextMenuActions?: (row: TRow) => ResourceContextAction[];
+}
+export declare const buildKanbanRendererListItems: <TRow extends KanbanRendererRow>(input: BuildKanbanRendererListItemsInput<TRow>) => (KanbanRendererListItem | {
+    onDropRow: ((draggedId: string) => void | Promise<void>) | undefined;
+    children: KanbanRendererListItem[];
+    statusColorPalette: string | undefined;
+    statusIcon: import('react').ComponentType;
+    id: string;
+    title: string;
+    isGroup: boolean;
+    countBadge: number;
+})[];
+export {};

package/dist/components/kanban-renderer/kanban-renderer-list.d.ts

@@ -0,0 +1,43 @@
+import { ComponentType, ReactNode } from 'react';
+import { ResourceContextAction } from '../overlays/resource-context-menu';
+import { AttributeBadge } from './kanban-renderer-helpers';
+export interface KanbanRendererListItem {
+    id: string;
+    eyebrow?: string;
+    title: string;
+    isGroup?: boolean;
+    countBadge?: number;
+    countColorPalette?: string;
+    statusIcon?: ComponentType<{
+        size?: number | string;
+    }>;
+    statusColor?: string;
+    statusColorPalette?: string;
+    badges?: AttributeBadge[];
+    customSlots?: ReactNode[];
+    children?: KanbanRendererListItem[];
+    onClick?: () => void;
+    onBadgeChange?: (attributeId: string, value: unknown) => void;
+    contextMenuActions?: ResourceContextAction[];
+    draggable?: boolean;
+    onDropRow?: (rowId: string) => void;
+}
+export type KanbanRendererListExpandedState = Record<string, boolean>;
+export interface KanbanRendererListProps {
+    items: KanbanRendererListItem[];
+    selectedItemId?: string | null;
+    expandedGroups?: KanbanRendererListExpandedState;
+    onItemClick?: (item: KanbanRendererListItem) => void;
+    onExpandedGroupChange?: (rowId: string, isExpanded: boolean) => void;
+}
+interface FlattenedKanbanRendererListItem {
+    id: string;
+    item: KanbanRendererListItem;
+    depth: number;
+    isGroup: boolean;
+    canExpand: boolean;
+}
+export declare const getKanbanRendererListIndentation: (depth: number) => string | undefined;
+export declare const flattenKanbanRendererListItems: (items: KanbanRendererListItem[], expanded: KanbanRendererListExpandedState, depth?: number) => FlattenedKanbanRendererListItem[];
+export declare const KanbanRendererList: (props: KanbanRendererListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,7 +1,8 @@
-import { AttributeDescriptor, DataRendererRow } from './types';
+import { AttributeDescriptor, KanbanRendererRow } from './types';
 export declare const attributes: AttributeDescriptor[];
-export interface StoryRow extends DataRendererRow {
+export interface StoryRow extends KanbanRendererRow {
     attributes: {
+        id?: string;
         status: string;
         assignee: string;
         component: string;

package/dist/components/kanban-renderer/kanban-renderer-toolbar.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { AttributeDescriptor, KanbanRendererFilterState, KanbanRendererRow, KanbanRendererSavedView, KanbanRendererSettings } from './types';
+export interface KanbanRendererToolbarProps<TRow extends KanbanRendererRow = KanbanRendererRow> {
+    rows: TRow[];
+    storageKey: string;
+    attributes: AttributeDescriptor[];
+    defaultSettings?: Partial<KanbanRendererSettings>;
+    defaultFilters?: KanbanRendererFilterState;
+    defaultViews?: KanbanRendererSavedView[];
+    defaultActiveViewId?: string;
+    leading?: ReactNode;
+    displayControl?: ReactNode;
+    align?: "split" | "end";
+}
+export declare const KanbanRendererToolbar: <TRow extends KanbanRendererRow>(props: KanbanRendererToolbarProps<TRow>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/kanban-renderer/kanban-renderer-view-bar.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { FilterCategoryView } from './kanban-renderer-helpers';
+import { KanbanRendererFilterState } from './types';
+interface KanbanRendererViewBarProps {
+    storageKey: string;
+    categories: FilterCategoryView[];
+    filters: KanbanRendererFilterState;
+    leading?: ReactNode;
+    filterControl: ReactNode;
+    displayControl: ReactNode;
+    align?: "split" | "end";
+}
+export declare const KanbanRendererViewBar: (props: KanbanRendererViewBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/kanban-renderer/kanban-renderer-views.d.ts

@@ -0,0 +1,12 @@
+import { KanbanRendererFilterState, KanbanRendererSavedView, KanbanRendererSettings } from './types';
+interface KanbanRendererViewState {
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+}
+export declare const snapshotKanbanRendererView: (id: string, title: string, state: KanbanRendererViewState, isDefault?: boolean) => KanbanRendererSavedView;
+export declare const applyKanbanRendererView: (view: KanbanRendererSavedView) => {
+    settings: KanbanRendererSettings;
+    filters: KanbanRendererFilterState;
+};
+export declare const isKanbanRendererViewDirty: (view: KanbanRendererSavedView | undefined, state: KanbanRendererViewState) => boolean;
+export {};

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

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
-import { ResourceContextAction } from '../resource-context-menu';
-import { DataRendererBoardColumnAction } from './data-renderer-board';
-import { AttributeDescriptor, DataRendererFilterState, DataRendererRow, DataRendererSettings } from './types';
+import { ResourceContextAction } from '../overlays/resource-context-menu';
+import { KanbanRendererBoardColumnAction } from './kanban-renderer-board';
+import { AttributeDescriptor, KanbanRendererCreateRowConfig, KanbanRendererCreateSubmission, KanbanRendererFilterState, KanbanRendererRow, KanbanRendererSavedView, KanbanRendererSettings } from './types';
 /** Board-column behavior and menu configuration for a resolved column group. */
 export interface BoardColumnConfig {
     /** Chakra color palette used for the column header and group badges. */
@@ -9,10 +9,10 @@ export interface BoardColumnConfig {
     canDragIn?: boolean;
     canDragOut?: boolean;
     canCreate?: boolean;
-    actions?: DataRendererBoardColumnAction[];
+    actions?: KanbanRendererBoardColumnAction[];
 }
 /** Switchable list/board renderer for rows with typed attributes, filtering, grouping, and ordering. */
-export interface DataRendererProps<TRow extends DataRendererRow = DataRendererRow> {
+export interface KanbanRendererProps<TRow extends KanbanRendererRow = KanbanRendererRow> {
     /** Stable rows to render. Each row must have an id, title, and attributes map. */
     rows: TRow[];
     /** Persistent key used by the renderer store for view, filter, grouping, ordering, and list expansion settings. */
@@ -23,8 +23,10 @@ export interface DataRendererProps<TRow extends DataRendererRow = DataRendererRo
     emptyState?: ReactNode;
     emptyTitle?: string;
     emptyDescription?: string;
-    defaultSettings?: Partial<DataRendererSettings>;
-    defaultFilters?: DataRendererFilterState;
+    defaultSettings?: Partial<KanbanRendererSettings>;
+    defaultFilters?: KanbanRendererFilterState;
+    defaultViews?: KanbanRendererSavedView[];
+    defaultActiveViewId?: string;
     hideToolbar?: boolean;
     toolbarLeading?: ReactNode;
     onRowClick?: (row: TRow) => void;
@@ -32,9 +34,10 @@ export interface DataRendererProps<TRow extends DataRendererRow = DataRendererRo
     onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => Promise<void> | void;
     /** Called for manual row ordering when a dragged row is dropped before another row. */
     onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
-    onCreateRow?: (columnId: string) => void;
+    createRow?: KanbanRendererCreateRowConfig;
+    onCreateRow?: (submission: KanbanRendererCreateSubmission) => Promise<void> | void;
     onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
     getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig;
     getRowContextMenuActions?: (row: TRow) => ResourceContextAction[];
 }
-export declare const DataRenderer: <TRow extends DataRendererRow>(props: DataRendererProps<TRow>) => import("react/jsx-runtime").JSX.Element;
+export declare const KanbanRenderer: <TRow extends KanbanRendererRow>(props: KanbanRendererProps<TRow>) => import("react/jsx-runtime").JSX.Element;

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,25 +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 declare const isEnumType: (type: AttributeType) => type is Extract<AttributeType, {
-    kind: "enum";
-}>;
-export declare const isMultiEnumType: (type: AttributeType) => type is Extract<AttributeType, {
-    kind: "enum-multi";
-}>;
+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

@@ -0,0 +1,7 @@
+export type { HeaderProps, HeaderVariant } from './header';
+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

@@ -0,0 +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/{resizable-split-layout.d.ts → 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/{resizable-split-layout.handle.d.ts → 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" | "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;