@pstdio/ui 0.8.0 → 0.9.0

package/dist/components/data-renderer/data-renderer-board.d.ts

@@ -22,6 +22,7 @@ export interface DataRendererBoardGroup {
 export interface DataRendererBoardColumn {
     id: string;
     label: string;
+    createLabel?: string;
     color?: string;
     items: DataRendererBoardItem[];
     groups?: DataRendererBoardGroup[];

package/dist/components/data-renderer/data-renderer-card.d.ts

@@ -1,30 +1,15 @@
-import { DragEventHandler } from 'react';
+import { DragEventHandler, ReactNode } from 'react';
 import { WorkspaceBadgeProps } from '../workspace-badge';
-import { DataRendererTagOption } from './types';
-export interface DataRendererCardBadge {
-    label: string;
-    color?: string;
-}
-export interface DataRendererCardTagBadge {
-    tagName: string;
-    label: string;
-    value: string | null;
-    color?: string;
-    options: DataRendererTagOption[];
-}
-interface DataRendererCardProps {
-    ticketId: string;
-    parentPath?: string[];
+import { AttributeBadge } from './data-renderer-helpers';
+export interface DataRendererCardProps {
     title: string;
-    badges?: DataRendererCardBadge[];
-    tagBadges?: DataRendererCardTagBadge[];
+    badges?: AttributeBadge[];
+    customSlots?: ReactNode[];
     workspaceBadge?: WorkspaceBadgeProps;
     isSelected?: boolean;
     draggable?: boolean;
     onDragStart?: DragEventHandler<HTMLDivElement>;
     onDragEnd?: DragEventHandler<HTMLDivElement>;
     onClick?: () => void;
-    onTagChange?: (tagName: string, newValue: string) => void;
 }
 export declare const DataRendererCard: (props: DataRendererCardProps) => import("react/jsx-runtime").JSX.Element;
-export {};

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

@@ -1,22 +1,23 @@
-import { DataRendererFilterState, DataRendererOrdering, DataRendererRow, DataRendererTagDefinition, FilterCategory, GroupingField } from './types';
+import { AttributeDescriptor, DataRendererFilterState, DataRendererOrdering, DataRendererRow } from './types';
 interface GroupingOptions {
-    columnGrouping: GroupingField;
-    rowGrouping: GroupingField;
+    attributes: AttributeDescriptor[];
+    columnGrouping: string;
+    rowGrouping: string;
     knownColumnKeys?: string[];
 }
 interface DataRendererRowGroup {
     key: string;
     label: string;
-    tickets: DataRendererRow[];
+    rows: DataRendererRow[];
 }
 interface DataRendererColumnGroup {
     key: string;
     label: string;
-    tickets: DataRendererRow[];
-    rows: DataRendererRowGroup[];
+    rows: DataRendererRow[];
+    subgroups: DataRendererRowGroup[];
 }
-export declare const orderRows: (tickets: DataRendererRow[], ordering: DataRendererOrdering, tagDefinitions?: DataRendererTagDefinition[]) => DataRendererRow[];
-export declare const groupRows: (tickets: DataRendererRow[], options: GroupingOptions) => DataRendererColumnGroup[];
-export declare const filterRows: (tickets: DataRendererRow[], filters: DataRendererFilterState) => DataRendererRow[];
-export declare const countFilterValues: (tickets: DataRendererRow[], category: FilterCategory) => Record<string, number>;
+export declare const orderRows: (rows: DataRendererRow[], ordering: DataRendererOrdering, attributes: AttributeDescriptor[]) => DataRendererRow[];
+export declare const groupRows: (rows: DataRendererRow[], options: GroupingOptions) => DataRendererColumnGroup[];
+export declare const filterRows: (rows: DataRendererRow[], filters: DataRendererFilterState, attributes: AttributeDescriptor[]) => DataRendererRow[];
+export declare const countFilterValues: (rows: DataRendererRow[], attributeId: string, attributes: AttributeDescriptor[]) => Record<string, number>;
 export type { DataRendererColumnGroup, DataRendererRowGroup };

package/dist/components/data-renderer/data-renderer-helpers.d.ts

@@ -1,18 +1,66 @@
-import { DataRendererCardBadge, DataRendererCardTagBadge } from './data-renderer-card';
-import { DataRendererFilterCategory, DataRendererFilterState, DataRendererOption, DataRendererRow, DataRendererTagDefinition, DisplayProperty, FilterCategory, GroupingField, OrderingField } from './types';
+import { ReactNode } from 'react';
+import { AttributeDescriptor, AttributeType, DataRendererFilterState, DataRendererRow, DataRendererSettings, EnumOption } from './types';
+/**
+ * Normalize an enum / enum-multi attribute's `options` to a plain `EnumOption[]`.
+ * Sources resolve via `getSnapshot()` on every call, so callers naturally see
+ * the latest values — pair with `useResolvedAttributes` to also rerender on
+ * source change.
+ */
+export declare const getEnumOptions: (type: AttributeType) => EnumOption[];
 export declare const toTitleCase: (value: string) => string;
-export declare const buildDefaultFilterCategories: (tickets: DataRendererRow[], tagDefinitions: DataRendererTagDefinition[]) => DataRendererFilterCategory[];
-export declare const toBadges: (ticket: DataRendererRow, displayProperties: DisplayProperty[]) => DataRendererCardBadge[];
-export declare const toTagBadges: (ticket: DataRendererRow, displayProperties: DisplayProperty[], tagDefinitions: DataRendererTagDefinition[]) => DataRendererCardTagBadge[];
-export declare const buildTagOptions: (tagDefinitions: DataRendererTagDefinition[]) => {
-    grouping: DataRendererOption<GroupingField>[];
-    ordering: DataRendererOption<OrderingField>[];
-    display: DataRendererOption<DisplayProperty>[];
-};
-export declare const orderGroupingOptions: <TValue extends string>(options: DataRendererOption<TValue>[]) => DataRendererOption<TValue>[];
-export declare const resolveSubGroupingOptions: (options: DataRendererOption<GroupingField>[], columnGrouping: GroupingField) => DataRendererOption<GroupingField>[];
-export declare const resolveListDropTargetColumnKey: (columnGrouping: GroupingField, placement?: {
+/**
+ * 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 findEnumOption: (type: AttributeType, value: string) => EnumOption | undefined;
+export declare const enumOptionLabel: (type: AttributeType, value: string) => string;
+export interface AttributeBadge {
+    attributeId: string;
+    label: string;
+    color?: 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 interface FilterCategoryView {
+    id: string;
+    label: string;
+    options: {
+        value: string;
+        label: string;
+        color?: string;
+    }[];
+}
+/**
+ * Build the filter menu's category list from the declared attributes. Enum
+ * descriptors expose their declared options first; auto-derived values from
+ * 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 interface MenuOption {
+    value: string;
+    label: string;
+}
+export declare const buildGroupingOptions: (attributes: AttributeDescriptor[]) => MenuOption[];
+export declare const buildOrderingOptions: (attributes: AttributeDescriptor[]) => MenuOption[];
+export declare const buildDisplayPropertyOptions: (attributes: AttributeDescriptor[]) => MenuOption[];
+export declare const resolveSubGroupingOptions: (options: MenuOption[], columnGrouping: string) => MenuOption[];
+export declare const resolveListDropTargetColumnKey: (columnGrouping: string, placement?: {
     columnKey?: string;
 }) => string | undefined;
-export declare const resolveKnownColumnKeys: (columnGrouping: GroupingField, knownColumnKeys: string[] | undefined, categories: DataRendererFilterCategory[], filters?: DataRendererFilterState) => string[] | undefined;
-export declare const omitFilterCategory: (filters: DataRendererFilterState, category: FilterCategory) => DataRendererFilterState;
+export declare const resolveKnownColumnKeys: (columnGrouping: string, attributes: AttributeDescriptor[], filters?: DataRendererFilterState) => string[] | undefined;
+export declare const omitFilterCategory: (filters: DataRendererFilterState, id: string) => DataRendererFilterState;
+/**
+ * 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;

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

@@ -1,25 +1,22 @@
 import { ComponentType, ReactNode } from 'react';
 import { ResourceContextAction } from '../resource-context-menu';
-import { DataRendererCardBadge, DataRendererCardTagBadge } from './data-renderer-card';
+import { AttributeBadge } from './data-renderer-helpers';
 export interface DataRendererListItem {
     id: string;
-    ticketId: string;
     title: string;
     countBadge?: number;
+    countColorPalette?: string;
     statusIcon?: ComponentType<{
         size?: number | string;
     }>;
     statusColor?: string;
-    badges?: DataRendererCardBadge[];
-    tagBadges?: DataRendererCardTagBadge[];
-    date?: string;
-    assigneeIcon?: ReactNode;
+    badges?: AttributeBadge[];
+    customSlots?: ReactNode[];
     children?: DataRendererListItem[];
     onClick?: () => void;
-    onTagChange?: (tagName: string, newValue: string) => void;
     contextMenuActions?: ResourceContextAction[];
     draggable?: boolean;
-    onDropTicket?: (ticketId: string) => void;
+    onDropRow?: (rowId: string) => void;
 }
 interface DataRendererListProps {
     items: DataRendererListItem[];

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

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { AttributeDescriptor, DataRendererFilterState, DataRendererRow, DataRendererSettings } from './types';
+export interface DataRendererToolbarProps<TRow extends DataRendererRow = DataRendererRow> {
+    rows: TRow[];
+    storageKey: string;
+    attributes: AttributeDescriptor[];
+    defaultSettings?: Partial<DataRendererSettings>;
+    defaultFilters?: DataRendererFilterState;
+    leading?: ReactNode;
+    align?: "split" | "end";
+}
+export declare const DataRendererToolbar: <TRow extends DataRendererRow>(props: DataRendererToolbarProps<TRow>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/data-renderer/data-renderer.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
 import { DataRendererBoardColumnAction } from './data-renderer-board';
-import { DataRendererFilterCategory, DataRendererOption, DataRendererRow, DataRendererTagDefinition, DisplayProperty, GroupingField, OrderingField } from './types';
+import { AttributeDescriptor, DataRendererFilterState, DataRendererRow, DataRendererSettings } from './types';
 export interface BoardColumnConfig {
     color?: string;
     canDragIn?: boolean;
@@ -8,33 +8,22 @@ export interface BoardColumnConfig {
     canCreate?: boolean;
     actions?: DataRendererBoardColumnAction[];
 }
-interface DataRendererProps<TTicket extends DataRendererRow = DataRendererRow> {
-    tickets: TTicket[];
+export interface DataRendererProps<TRow extends DataRendererRow = DataRendererRow> {
+    rows: TRow[];
     storageKey: string;
-    tagDefinitions?: DataRendererTagDefinition[];
-    selectedTicketId?: string | null;
-    groupingOptions?: DataRendererOption<GroupingField>[];
-    orderingOptions?: DataRendererOption<OrderingField>[];
-    displayPropertyOptions?: DataRendererOption<DisplayProperty>[];
-    filterCategories?: DataRendererFilterCategory[];
-    knownColumnKeys?: string[];
+    attributes: AttributeDescriptor[];
+    selectedRowId?: string | null;
     emptyTitle?: string;
     emptyDescription?: string;
+    defaultSettings?: Partial<DataRendererSettings>;
+    defaultFilters?: DataRendererFilterState;
     hideToolbar?: boolean;
     toolbarLeading?: ReactNode;
-    onTicketClick?: (ticket: TTicket) => void;
-    onTagChange?: (ticketId: string, tagName: string, newValue: string) => void;
-    onMoveTicket?: (ticketId: string, targetColumnId: string, context?: {
-        columnGrouping: GroupingField;
-        beforeTicketId?: string;
-    }) => void;
-    onMoveToGroup?: (ticketId: string, targetGroupKey: string, context?: {
-        rowGrouping: GroupingField;
-        beforeTicketId?: string;
-    }) => void;
-    onCreateTicket?: (columnId: string) => void;
+    onRowClick?: (row: TRow) => void;
+    onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => void;
+    onReorder?: (rowId: string, beforeRowId?: string) => void;
+    onCreateRow?: (columnId: string) => void;
     onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
     getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig;
 }
-export declare const DataRenderer: <TTicket extends DataRendererRow>(props: DataRendererProps<TTicket>) => import("react/jsx-runtime").JSX.Element;
-export type { DataRendererProps };
+export declare const DataRenderer: <TRow extends DataRendererRow>(props: DataRendererProps<TRow>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/data-renderer/display-menu.d.ts

@@ -1,15 +1,16 @@
-import { DataRendererOption, DataRendererSettings, DisplayProperty, GroupingField, OrderingField } from './types';
+import { MenuOption } from './data-renderer-helpers';
+import { DataRendererSettings } from './types';
 interface DisplayMenuProps {
     settings: DataRendererSettings;
-    groupingOptions: DataRendererOption<GroupingField>[];
-    orderingOptions: DataRendererOption<OrderingField>[];
-    displayPropertyOptions: DataRendererOption<DisplayProperty>[];
+    groupingOptions: MenuOption[];
+    orderingOptions: MenuOption[];
+    displayPropertyOptions: MenuOption[];
     onViewModeChange: (value: DataRendererSettings["viewMode"]) => void;
-    onColumnGroupingChange: (value: GroupingField) => void;
-    onRowGroupingChange: (value: GroupingField) => void;
-    onOrderingFieldChange: (value: OrderingField) => void;
+    onColumnGroupingChange: (value: string) => void;
+    onRowGroupingChange: (value: string) => void;
+    onOrderingAttributeIdChange: (value: string) => void;
     onSortDirectionToggle: () => void;
-    onDisplayPropertyToggle: (property: DisplayProperty) => void;
+    onDisplayPropertyToggle: (property: string) => void;
 }
 export declare const DisplayMenu: (props: DisplayMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-renderer/filter-menu.d.ts

@@ -1,10 +1,11 @@
-import { DataRendererFilterCategory, DataRendererFilterState } from './types';
+import { FilterCategoryView } from './data-renderer-helpers';
+import { DataRendererFilterState } from './types';
 interface FilterMenuProps {
-    categories: DataRendererFilterCategory[];
+    categories: FilterCategoryView[];
     filters: DataRendererFilterState;
     countsByCategory: Record<string, Record<string, number>>;
-    onToggleFilterValue: (category: DataRendererFilterCategory["id"], value: string) => void;
-    onClearFilter: (category: DataRendererFilterCategory["id"]) => void;
+    onToggleFilterValue: (attributeId: string, value: string) => void;
+    onClearFilter: (attributeId: string) => void;
     onClearAll: () => void;
 }
 export declare const FilterMenu: (props: FilterMenuProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,64 +1,98 @@
+import { ReactNode } from 'react';
 export type ViewMode = "board" | "list";
-export type GroupingField = "status" | "assignee" | "none" | `tag:${string}`;
-export type OrderingField = "manual" | "updated" | "title" | "ticketId" | `tag:${string}`;
 export type SortDirection = "asc" | "desc";
-export type DisplayProperty = "id" | "status" | "assignee" | "updated" | `tag:${string}`;
-export type FilterCategory = "status" | "assignee" | `tag:${string}`;
-export interface DataRendererOrdering {
-    field: OrderingField;
-    direction: SortDirection;
-}
-export interface DataRendererSettings {
-    viewMode: ViewMode;
-    columnGrouping: GroupingField;
-    rowGrouping: GroupingField;
-    ordering: DataRendererOrdering;
-    displayProperties: DisplayProperty[];
-}
-export type DataRendererFilterState = Partial<Record<FilterCategory, string[]>>;
-export interface DataRendererOption<TValue extends string> {
-    value: TValue;
-    label: string;
-}
-export interface DataRendererFilterOption {
-    value: string;
-    label: string;
-}
-export interface DataRendererFilterCategory {
-    id: FilterCategory;
-    label: string;
-    options: DataRendererFilterOption[];
-}
-export interface DataRendererTagOption {
+export declare const NO_GROUPING = "none";
+export declare const MANUAL_ORDERING = "manual";
+export interface EnumOption {
     value: string;
     label: string;
     color?: string;
     icon?: string | null;
 }
-export interface DataRendererTagDefinition {
-    name: string;
+/**
+ * Reactive options source for enum / enum-multi attributes. Mirrors React's
+ * useSyncExternalStore contract so a contribution can hand its options off as
+ * a live collection (e.g. a project-scoped resource) instead of a frozen
+ * array, and the renderer subscribes to it the same way it subscribes to rows.
+ */
+export interface EnumOptionsSource {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => EnumOption[];
+}
+export type EnumOptions = EnumOption[] | EnumOptionsSource;
+export type AttributeType = {
+    kind: "enum";
+    options: EnumOptions;
+} | {
+    kind: "enum-multi";
+    options: EnumOptions;
+} | {
+    kind: "string";
+} | {
+    kind: "date";
+} | {
+    kind: "number";
+} | {
+    kind: "user";
+};
+export declare const isEnumOptionsSource: (options: EnumOptions) => options is EnumOptionsSource;
+export type AttributeKind = AttributeType["kind"];
+export interface AttributeDescriptor {
+    id: string;
     label: string;
-    options: DataRendererTagOption[];
+    type: AttributeType;
+    filterable?: boolean;
+    groupable?: boolean;
+    sortable?: boolean;
+    displayable?: boolean;
+    editable?: boolean;
+    render?: (value: unknown, row: DataRendererRow) => ReactNode;
+    compare?: (a: unknown, b: unknown) => number;
 }
-export interface DataRendererTag {
-    name: string;
-    value: string;
+/**
+ * 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
+ * — letting a contribution add/remove/edit attributes at runtime without
+ * re-registering.
+ */
+export interface AttributesSource {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => AttributeDescriptor[];
 }
+export declare const isAttributesSource: (attributes: AttributeDescriptor[] | AttributesSource) => attributes is AttributesSource;
 export interface DataRendererRow {
     id: string;
-    ticketId: string;
     title: string;
-    status?: string | null;
-    statusColor?: string;
-    assignee?: string | null;
-    tags?: DataRendererTag[];
-    updatedAt?: string | null;
-    parentPath?: string[];
-    isSubIssue?: boolean;
+    /**
+     * Optional navigation handle. When set, the renderer's default click handler
+     * routes through the contribution's onRowClick (which typically opens the
+     * resource via the workbench).
+     */
+    resource?: unknown;
+    attributes: Record<string, unknown>;
+}
+export interface DataRendererOrdering {
+    attributeId: string | typeof MANUAL_ORDERING;
+    direction: SortDirection;
+}
+export interface DataRendererSettings {
+    viewMode: ViewMode;
+    columnGrouping: string | typeof NO_GROUPING;
+    rowGrouping: string | typeof NO_GROUPING;
+    ordering: DataRendererOrdering;
+    displayProperties: string[];
 }
+export type DataRendererFilterState = Record<string, string[]>;
 export declare const DEFAULT_DATA_RENDERER_SETTINGS: DataRendererSettings;
-export declare const DEFAULT_GROUPING_OPTIONS: DataRendererOption<GroupingField>[];
-export declare const DEFAULT_ORDERING_OPTIONS: DataRendererOption<OrderingField>[];
-export declare const DEFAULT_DISPLAY_PROPERTY_OPTIONS: DataRendererOption<DisplayProperty>[];
-export declare const isTagKey: (key: string) => key is `tag:${string}`;
-export declare const toTagName: (key: `tag:${string}`) => string;
+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";
+}>;
+/**
+ * Look up an attribute by id from a contribution-provided descriptor list.
+ * Returns undefined for sentinels ("none", "manual") or unknown ids.
+ */
+export declare const findAttribute: (attributes: AttributeDescriptor[], id: string | undefined) => AttributeDescriptor | undefined;

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

@@ -1,26 +1,30 @@
-import { DataRendererFilterState, DataRendererSettings, DisplayProperty, FilterCategory } from './types';
+import { DataRendererFilterState, DataRendererSettings } from './types';
 interface DataRendererSnapshot {
     settings: DataRendererSettings;
     filters: DataRendererFilterState;
 }
+interface DataRendererStoreInitialState {
+    settings?: Partial<DataRendererSettings>;
+    filters?: DataRendererFilterState;
+}
 interface DataRendererState extends DataRendererSnapshot {
     setViewMode: (viewMode: DataRendererSettings["viewMode"]) => void;
     setColumnGrouping: (columnGrouping: DataRendererSettings["columnGrouping"]) => void;
     setRowGrouping: (rowGrouping: DataRendererSettings["rowGrouping"]) => void;
     setOrdering: (ordering: DataRendererSettings["ordering"]) => void;
-    setOrderingField: (field: DataRendererSettings["ordering"]["field"]) => void;
-    setDisplayProperties: (displayProperties: DisplayProperty[]) => void;
+    setOrderingAttributeId: (attributeId: DataRendererSettings["ordering"]["attributeId"]) => void;
+    setDisplayProperties: (displayProperties: string[]) => void;
     toggleSortDirection: () => void;
-    toggleDisplayProperty: (property: DataRendererSettings["displayProperties"][number]) => void;
-    setFilter: (category: FilterCategory, values: string[]) => void;
-    toggleFilterValue: (category: FilterCategory, value: string) => void;
-    clearFilter: (category: FilterCategory) => void;
+    toggleDisplayProperty: (property: string) => void;
+    setFilter: (attributeId: string, values: string[]) => void;
+    toggleFilterValue: (attributeId: string, value: string) => void;
+    clearFilter: (attributeId: string) => void;
     clearAllFilters: () => void;
     reset: () => void;
 }
 interface CreateDataRendererStoreOptions {
     storageKey: string;
-    initialState?: Partial<DataRendererSnapshot>;
+    initialState?: DataRendererStoreInitialState;
 }
 export declare const createDataRendererStore: (options: CreateDataRendererStoreOptions) => Omit<import('zustand').StoreApi<DataRendererState>, "setState" | "persist"> & {
     setState(partial: DataRendererState | Partial<DataRendererState> | ((state: DataRendererState) => DataRendererState | Partial<DataRendererState>), replace?: false | undefined): unknown;
@@ -35,7 +39,7 @@ export declare const createDataRendererStore: (options: CreateDataRendererStoreO
         getOptions: () => Partial<import('zustand/middleware').PersistOptions<DataRendererState, unknown, unknown>>;
     };
 };
-export declare const getDataRendererStore: (storageKey: string) => Omit<import('zustand').StoreApi<DataRendererState>, "setState" | "persist"> & {
+export declare const getDataRendererStore: (storageKey: string, initialState?: DataRendererStoreInitialState) => Omit<import('zustand').StoreApi<DataRendererState>, "setState" | "persist"> & {
     setState(partial: DataRendererState | Partial<DataRendererState> | ((state: DataRendererState) => DataRendererState | Partial<DataRendererState>), replace?: false | undefined): unknown;
     setState(state: DataRendererState | ((state: DataRendererState) => DataRendererState), replace: true): unknown;
     persist: {
@@ -48,5 +52,5 @@ export declare const getDataRendererStore: (storageKey: string) => Omit<import('
         getOptions: () => Partial<import('zustand/middleware').PersistOptions<DataRendererState, unknown, unknown>>;
     };
 };
-export declare const useDataRendererStore: <T>(storageKey: string, selector: (state: DataRendererState) => T) => T;
-export type { DataRendererState };
+export declare const useDataRendererStore: <T>(storageKey: string, selector: (state: DataRendererState) => T, initialState?: DataRendererStoreInitialState) => T;
+export type { DataRendererSnapshot, DataRendererState, DataRendererStoreInitialState };

package/dist/components/data-renderer/use-resolved-attributes.d.ts

@@ -0,0 +1,14 @@
+import { AttributeDescriptor } from './types';
+/**
+ * Returns the same descriptors with every source-backed enum's options
+ * replaced by a fresh `getSnapshot()` array. Pure — call from anywhere that
+ * needs a normalized view of the schema.
+ */
+export declare const resolveAttributeOptions: (attributes: AttributeDescriptor[]) => AttributeDescriptor[];
+/**
+ * Subscribes to every source-backed enum in `attributes` and returns the
+ * resolved descriptors (options materialized to plain arrays). When any
+ * source's listener fires the component rerenders, so downstream renders see
+ * the new snapshot automatically.
+ */
+export declare const useResolvedAttributes: (attributes: AttributeDescriptor[]) => AttributeDescriptor[];

package/dist/components/diff-viewer/diff-card-body.d.ts

@@ -15,10 +15,19 @@ interface DiffCardBodyModelInput extends DiffCardBodyProps {
     buildViewData?: typeof buildDiffViewData;
 }
 export declare const createDiffCardBodyModel: (input: DiffCardBodyModelInput) => {
+    kind: "binary";
+    filePath: string;
+    isImage: boolean;
+    renderedLineCount?: undefined;
+    onShowFullDiff?: undefined;
+    diffViewData?: undefined;
+    sideBySide?: undefined;
+} | {
     kind: "placeholder";
     filePath: string;
     renderedLineCount: number;
     onShowFullDiff: (() => void) | undefined;
+    isImage?: undefined;
     diffViewData?: undefined;
     sideBySide?: undefined;
 } | {
@@ -26,6 +35,7 @@ export declare const createDiffCardBodyModel: (input: DiffCardBodyModelInput) =>
     diffViewData: BuiltDiffViewData;
     sideBySide: boolean;
     filePath?: undefined;
+    isImage?: undefined;
     renderedLineCount?: undefined;
     onShowFullDiff?: undefined;
 };

package/dist/components/diff-viewer/diff-card-content.d.ts

@@ -8,6 +8,7 @@ interface DiffCardContentProps {
     isExpanded: boolean;
     isLargeDiff: boolean;
     isGeneratedDiff: boolean;
+    isBinaryDiff: boolean;
     hasDiffContent: boolean;
     canLoadDiff: boolean;
     shouldAutoLoadDiff: boolean;

package/dist/components/diff-viewer/diff-card.d.ts

@@ -30,6 +30,7 @@ export declare const shouldAutoLoadDiffContent: (input: {
     hasDiffContent: boolean;
     isLargeDiff: boolean;
     isGeneratedDiff: boolean;
+    isBinaryDiff: boolean;
     requestedPath: string | null;
     filePath: string;
 }) => boolean;

package/dist/components/diff-viewer/diff-size.d.ts

@@ -12,3 +12,5 @@ export declare const isLargeDiffContent: (input: {
     newContent?: string;
 }) => boolean;
 export declare const isGeneratedDiffPath: (path: string) => boolean;
+export declare const isBinaryDiffPath: (path: string) => boolean;
+export declare const isImageDiffPath: (path: string) => boolean;

package/dist/components/icon-color-picker.d.ts

@@ -0,0 +1,13 @@
+import { ComponentType } from 'react';
+export declare const optionColors: readonly ["gray", "red", "orange", "yellow", "green", "teal", "blue", "cyan", "purple", "pink"];
+export declare const getIconComponent: (name: string | null | undefined) => ComponentType;
+export interface IconColorPickerProps {
+    color: string;
+    icon?: string | null;
+    onColorChange: (color: string) => void;
+    onIconChange?: (icon: string | null) => void;
+    disabled?: boolean;
+    showIcons?: boolean;
+    "aria-label"?: string;
+}
+export declare const IconColorPicker: (props: IconColorPickerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { ListRowItem, ListRowProps } from './list-row.types';
+export declare const ListRowContent: (props: {
+    item: ListRowItem;
+    isExpanded: boolean;
+    showChevron: boolean;
+    isDisabled: boolean;
+    tone: ListRowProps["tone"];
+    variant: ListRowProps["variant"];
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -16,6 +16,7 @@ export interface ListRowActionMenuItem {
         size?: number | string;
     }>;
     disabled?: boolean;
+    readOnly?: boolean;
     /** Trailing content rendered after the label. Use for Kbd shortcuts, counts, or badges. */
     endContent?: ReactNode;
     onAction?: () => void;

package/dist/components/rich-text/shared/lexical-code.d.ts

@@ -0,0 +1,2 @@
+import { $createCodeNode, $isCodeNode, CodeHighlightNode, CodeNode, registerCodeHighlighting } from '@lexical/code';
+export { $createCodeNode, $isCodeNode, CodeHighlightNode, CodeNode, registerCodeHighlighting };

package/dist/components/rich-text/shared/plugins/CodePlugin/CodeBlockPlugin.d.ts

@@ -1,3 +1,3 @@
-import { CodeNode } from '@lexical/code';
+import { CodeNode } from '../../lexical-code';
 export declare function replaceCodeNodeWithMermaidNode(node: CodeNode): boolean;
 export declare function ImportCodeBlocksPlugin(): null;

package/dist/components/rich-text/shared/prism-global.d.ts

@@ -0,0 +1,2 @@
+import { default as Prism } from 'prismjs';
+export { Prism };

package/dist/components/status-option-editor/index.d.ts

@@ -0,0 +1,2 @@
+export { StatusOptionEditor } from './status-option-editor';
+export type { StatusOptionEditorItem, StatusOptionEditorProps } from './status-option-editor.types';

package/dist/components/status-option-editor/status-option-editor.d.ts

@@ -0,0 +1,2 @@
+import { StatusOptionEditorProps } from './status-option-editor.types';
+export declare const StatusOptionEditor: (props: StatusOptionEditorProps) => import("react/jsx-runtime").JSX.Element;