@pstdio/ui 0.16.0 → 0.17.0

package/dist/components/data-table/types.d.ts

@@ -5,11 +5,80 @@ export type DisplayValue = {
     display: ReactNode;
     sortValue?: unknown;
 };
+export interface DataTableThemeColor {
+    light: string;
+    dark: string;
+    foreground?: {
+        light: string;
+        dark: string;
+    };
+}
+export interface DataTableColorScaleStop {
+    value: number;
+    color: DataTableThemeColor;
+}
+export type DataTableCategoricalValue = string | number | boolean | null;
+export interface DataTableCategoricalColor {
+    value: DataTableCategoricalValue;
+    color: DataTableThemeColor;
+}
+export type DataTableColumnRenderer = {
+    type: "json";
+} | {
+    type: "color-scale";
+    stops: DataTableColorScaleStop[];
+} | {
+    type: "categorical-color";
+    categories: DataTableCategoricalColor[];
+};
+export type DataTableColumnStat = {
+    type: "unique";
+} | {
+    type: "histogram";
+    bins?: number;
+} | {
+    type: "top-values";
+    limit?: number;
+};
+export interface DataTableSelectionAction {
+    label: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    onSelect: (rows: RowData[]) => void;
+}
+export interface DataTableRowAction {
+    label: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    onSelect: (row: RowData) => void;
+}
+export interface DataTableCellContext {
+    row: RowData;
+    rowId: string;
+    columnId: string;
+    value: unknown;
+}
+export interface DataTableCellContextAction {
+    label: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    onSelect: (context: DataTableCellContext) => void;
+}
 export interface DataTableProps {
     data: RowData[];
     isReadOnly?: boolean;
     noBorder?: boolean;
     fullWidth?: boolean;
+    initialPageSize?: number;
+    pageSizeOptions?: number[];
+    selectionMode?: "none" | "multiple";
+    selectionActions?: DataTableSelectionAction[];
+    rowActions?: DataTableRowAction[];
+    compactHeaders?: Partial<Record<string, string>>;
+    getRowId?: (row: RowData, index: number) => string;
+    toolbarStorageKey?: string;
+    enableRowActivation?: boolean;
+    getCellContextMenuActions?: (context: DataTableCellContext) => DataTableCellContextAction[];
     onCSVUpload?: (csv: string) => Promise<void>;
     onCSVDownload?: (scenarios: string[]) => void;
     hiddenColumns?: string[];
@@ -17,4 +86,7 @@ export interface DataTableProps {
     isRowInteractive?: (row: RowData) => boolean;
     activeRowId?: string | null;
     columnIcons?: Partial<Record<string, ReactNode>>;
+    columnDescriptions?: Partial<Record<string, string>>;
+    columnStats?: Partial<Record<string, DataTableColumnStat>>;
+    columnRenderers?: Partial<Record<string, DataTableColumnRenderer>>;
 }

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

@@ -1,11 +1,11 @@
-import { MenuOption } from './data-renderer-helpers';
-import { DataRendererSettings } from './types';
+import { MenuOption } from './kanban-renderer-helpers';
+import { KanbanRendererSettings } from './types';
 interface DisplayMenuProps {
-    settings: DataRendererSettings;
+    settings: KanbanRendererSettings;
     groupingOptions: MenuOption[];
     orderingOptions: MenuOption[];
     displayPropertyOptions: MenuOption[];
-    onViewModeChange: (value: DataRendererSettings["viewMode"]) => void;
+    onViewModeChange: (value: KanbanRendererSettings["viewMode"]) => void;
     onColumnGroupingChange: (value: string) => void;
     onRowGroupingChange: (value: string) => void;
     onOrderingAttributeIdChange: (value: string) => void;

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

@@ -1,8 +1,8 @@
-import { FilterCategoryView } from './data-renderer-helpers';
-import { DataRendererFilterState } from './types';
+import { FilterCategoryView } from './kanban-renderer-helpers';
+import { KanbanRendererFilterState } from './types';
 interface FilterMenuProps {
     categories: FilterCategoryView[];
-    filters: DataRendererFilterState;
+    filters: KanbanRendererFilterState;
     countsByCategory: Record<string, Record<string, number>>;
     onToggleFilterValue: (attributeId: string, value: string) => void;
     onClearFilter: (attributeId: string) => void;

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

@@ -0,0 +1,19 @@
+export { DisplayMenu } from './display-menu';
+export { FilterMenu } from './filter-menu';
+export type { BoardColumnConfig, KanbanRendererProps } from './kanban-renderer';
+export { KanbanRenderer } from './kanban-renderer';
+export type { KanbanRendererBoardColumn, KanbanRendererBoardColumnAction, KanbanRendererBoardItem, } from './kanban-renderer-board';
+export { KanbanRendererBoard } from './kanban-renderer-board';
+export type { KanbanRendererCardProps } from './kanban-renderer-card';
+export { KanbanRendererCard } from './kanban-renderer-card';
+export { KanbanRendererCreateDialog } from './kanban-renderer-create-dialog';
+export type { AttributeBadge, FilterCategoryView, MenuOption } from './kanban-renderer-helpers';
+export { buildDisplayPropertyOptions, buildFilterCategories, buildGroupingOptions, buildOrderingOptions, collectDisplayBadges, getAttributeStringValues, getAttributeValue, getEnumOptions, renderAttributeBadge, sanitizeFilters, sanitizeSettings, } from './kanban-renderer-helpers';
+export type { KanbanRendererListItem } from './kanban-renderer-list';
+export { KanbanRendererList } from './kanban-renderer-list';
+export type { KanbanRendererToolbarProps } from './kanban-renderer-toolbar';
+export { KanbanRendererToolbar } from './kanban-renderer-toolbar';
+export type { AttributeDescriptor, AttributeDisplayDescriptor, AttributeKind, AttributesSource, AttributeType, EnumOption, EnumOptions, EnumOptionsSource, KanbanRendererCreateField, KanbanRendererCreateFieldType, KanbanRendererCreateRowConfig, KanbanRendererCreateSubmission, KanbanRendererFilterState, KanbanRendererOrdering, KanbanRendererRow, KanbanRendererSavedView, KanbanRendererSettings, SortDirection, ViewMode, } from './types';
+export { findAttribute, isAttributesSource, isEnumOptionsSource, MANUAL_ORDERING, NO_GROUPING, } from './types';
+export { isActiveKanbanRendererViewDirty, useKanbanRendererStore } from './use-kanban-renderer-store';
+export { resolveAttributeOptions, useResolvedAttributes } from './use-resolved-attributes';

package/dist/components/kanban-renderer/kanban-renderer-attribute-badge.d.ts

@@ -0,0 +1,7 @@
+import { AttributeBadge } from './kanban-renderer-helpers';
+interface KanbanRendererAttributeBadgeProps {
+    badge: AttributeBadge;
+    onChange?: (attributeId: string, value: unknown) => void;
+}
+export declare const KanbanRendererAttributeBadge: (props: KanbanRendererAttributeBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -1,6 +1,6 @@
-import { DataRendererBoardColumn } from './data-renderer-board';
+import { KanbanRendererBoardColumn } from './kanban-renderer-board';
 interface ColumnHeaderProps {
-    column: DataRendererBoardColumn;
+    column: KanbanRendererBoardColumn;
     onCreateStart?: (columnId: string) => void;
     onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
 }

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

@@ -1,8 +1,8 @@
 import { DragEvent } from 'react';
-import { DataRendererBoardGroup } from './data-renderer-board';
+import { KanbanRendererBoardGroup } from './kanban-renderer-board';
 interface GroupSectionProps {
     columnId: string;
-    group: DataRendererBoardGroup;
+    group: KanbanRendererBoardGroup;
     selectedItemId: string | null;
     canDragIn: boolean;
     canDragOut: boolean;

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

@@ -1,6 +1,6 @@
-import { DataRendererSettings } from './types';
+import { KanbanRendererSettings } from './types';
 interface ApplyBoardMoveItemInput {
-    settings: Pick<DataRendererSettings, "columnGrouping" | "ordering" | "rowGrouping">;
+    settings: Pick<KanbanRendererSettings, "columnGrouping" | "ordering" | "rowGrouping">;
     rowId: string;
     targetColumnId: string;
     targetGroupKey?: string;
@@ -9,7 +9,7 @@ interface ApplyBoardMoveItemInput {
     onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
 }
 interface ApplyBoardMoveToGroupInput {
-    settings: Pick<DataRendererSettings, "ordering" | "rowGrouping">;
+    settings: Pick<KanbanRendererSettings, "ordering" | "rowGrouping">;
     rowId: string;
     targetGroupKey: string;
     beforeItemId?: string;

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

@@ -1,38 +1,39 @@
 import { ComponentProps, ComponentType } from 'react';
 import { ResourceContextAction } from '../overlays/resource-context-menu';
-import { DataRendererCard } from './data-renderer-card';
-type DataRendererCardProps = ComponentProps<typeof DataRendererCard>;
-export interface DataRendererBoardItem {
+import { KanbanRendererCard } from './kanban-renderer-card';
+type KanbanRendererCardProps = ComponentProps<typeof KanbanRendererCard>;
+export interface KanbanRendererBoardItem {
     id: string;
-    cardProps: Omit<DataRendererCardProps, "draggable" | "onDragStart" | "onDragEnd" | "isSelected">;
+    cardProps: Omit<KanbanRendererCardProps, "draggable" | "onDragStart" | "onDragEnd" | "isSelected">;
     contextMenuActions?: ResourceContextAction[];
 }
-export interface DataRendererBoardColumnAction {
+export interface KanbanRendererBoardColumnAction {
     id: string;
     label: string;
     icon: ComponentType<{
         size?: number | string;
     }>;
 }
-export interface DataRendererBoardGroup {
+export interface KanbanRendererBoardGroup {
     key: string;
     label: string;
-    items: DataRendererBoardItem[];
+    items: KanbanRendererBoardItem[];
 }
-export interface DataRendererBoardColumn {
+export interface KanbanRendererBoardColumn {
     id: string;
     label: string;
     createLabel?: string;
     color?: string;
-    items: DataRendererBoardItem[];
-    groups?: DataRendererBoardGroup[];
+    icon?: string | null;
+    items: KanbanRendererBoardItem[];
+    groups?: KanbanRendererBoardGroup[];
     canDragIn: boolean;
     canDragOut: boolean;
     canCreate: boolean;
-    actions: DataRendererBoardColumnAction[];
+    actions: KanbanRendererBoardColumnAction[];
 }
-interface DataRendererBoardProps {
-    columns: DataRendererBoardColumn[];
+interface KanbanRendererBoardProps {
+    columns: KanbanRendererBoardColumn[];
     selectedItemId?: string | null;
     onMoveItem?: (itemId: string, targetColumnId: string, context?: {
         beforeItemId?: string;
@@ -44,5 +45,5 @@ interface DataRendererBoardProps {
     onCreateStart?: (columnId: string) => void;
     onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
 }
-export declare const DataRendererBoard: (props: DataRendererBoardProps) => import("react/jsx-runtime").JSX.Element;
+export declare const KanbanRendererBoard: (props: KanbanRendererBoardProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,7 +1,8 @@
 import { DragEventHandler, ReactNode } from 'react';
 import { WorkspaceBadgeProps } from '../primitives/workspace-badge';
-import { AttributeBadge } from './data-renderer-helpers';
-export interface DataRendererCardProps {
+import { AttributeBadge } from './kanban-renderer-helpers';
+export interface KanbanRendererCardProps {
+    eyebrow?: string;
     title: string;
     badges?: AttributeBadge[];
     customSlots?: ReactNode[];
@@ -13,4 +14,4 @@ export interface DataRendererCardProps {
     onDragEnd?: DragEventHandler<HTMLDivElement>;
     onClick?: () => void;
 }
-export declare const DataRendererCard: (props: DataRendererCardProps) => import("react/jsx-runtime").JSX.Element;
+export declare const KanbanRendererCard: (props: KanbanRendererCardProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,11 +1,11 @@
 import { ReactNode } from 'react';
-import { DataRendererBoardColumn } from './data-renderer-board';
-import { DataRendererListItem } from './data-renderer-list';
-import { DataRendererSettings } from './types';
-interface DataRendererContentProps {
-    viewMode: DataRendererSettings["viewMode"];
-    boardColumns: DataRendererBoardColumn[];
-    listItems: DataRendererListItem[];
+import { KanbanRendererBoardColumn } from './kanban-renderer-board';
+import { KanbanRendererListItem } from './kanban-renderer-list';
+import { KanbanRendererSettings } from './types';
+interface KanbanRendererContentProps {
+    viewMode: KanbanRendererSettings["viewMode"];
+    boardColumns: KanbanRendererBoardColumn[];
+    listItems: KanbanRendererListItem[];
     listExpandedGroups: Record<string, boolean>;
     selectedRowId: string | null;
     emptyState?: ReactNode;
@@ -23,5 +23,5 @@ interface DataRendererContentProps {
     onListExpandedGroupChange: (rowId: string, isExpanded: boolean) => void;
     listKey: string;
 }
-export declare const DataRendererContent: (props: DataRendererContentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const KanbanRendererContent: (props: KanbanRendererContentProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/kanban-renderer/kanban-renderer-create-dialog.d.ts

@@ -0,0 +1,12 @@
+import { AttributeDescriptor, KanbanRendererCreateRowConfig, KanbanRendererCreateSubmission } from './types';
+interface KanbanRendererCreateDialogProps {
+    open: boolean;
+    columnId: string;
+    columnAttributeId?: string;
+    attributes: AttributeDescriptor[];
+    config: KanbanRendererCreateRowConfig;
+    onClose: () => void;
+    onSubmit: (submission: KanbanRendererCreateSubmission) => Promise<void> | void;
+}
+export declare const KanbanRendererCreateDialog: (props: KanbanRendererCreateDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/kanban-renderer/kanban-renderer-create-field.d.ts

@@ -0,0 +1,10 @@
+import { KanbanRendererCreateField } from './types';
+interface CreateFieldControlProps {
+    disabled: boolean;
+    field: KanbanRendererCreateField;
+    removeLabel: string;
+    value: unknown;
+    onChange: (value: unknown) => void;
+}
+export declare const CreateFieldControl: (props: CreateFieldControlProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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 '../overlays/resource-context-menu';
-import { DataRendererBoardColumnAction } from './data-renderer-board';
-import { AttributeDescriptor, DataRendererFilterState, DataRendererRow, DataRendererSettings } from './types';
+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;