@pstdio/ui 0.8.0 → 0.10.0

package/dist/components/diff-viewer/diff-drawer-scroll.d.ts

@@ -0,0 +1,47 @@
+import { Diff } from './diff-card';
+import { DiffViewMode } from './types';
+interface EstimateDiffRangeHeightInput {
+    diffs: Diff[];
+    collapsedPaths: Set<string>;
+    largeDiffOptInPaths: Set<string>;
+    diffViewMode: DiffViewMode;
+    startIndex: number;
+    endIndex: number;
+}
+interface SelectedExpansionCommand {
+    action: string;
+    id: number;
+    path?: string;
+    direction?: "up" | "down";
+}
+interface ResolveSelectedScrollStateInput {
+    diffs: Diff[];
+    selectedDiffPath: string | null;
+    collapsedPaths: Set<string>;
+    expansionCommand: SelectedExpansionCommand | null;
+    completedScrollCommandId: number | null;
+}
+export interface RenderedDiffItem {
+    element: HTMLElement;
+    index: number;
+}
+export declare const estimateDiffRangeHeight: (input: EstimateDiffRangeHeightInput) => number;
+export declare const resolveSelectedScrollState: (input: ResolveSelectedScrollStateInput) => {
+    selectedScrollPath: string | null;
+    selectedScrollKey: string | null;
+    selectedScrollCommandId: number | null;
+    selectedScrollIndex: number;
+    shouldPinSelectedScrollIndex: boolean;
+    hasCompletedSelectedScroll: boolean;
+};
+export declare const includePinnedDiffIndexes: (input: {
+    indexes: number[];
+    selectedScrollIndex: number;
+    shouldPinSelectedScrollIndex: boolean;
+}) => number[];
+export declare const getRenderedDiffItems: (scrollElement: HTMLElement | null) => RenderedDiffItem[];
+export declare const getElementScrollOffset: (input: {
+    element: HTMLElement;
+    scrollElement: HTMLElement | null;
+}) => number;
+export {};

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

@@ -13,19 +13,14 @@ export interface DiffExpansionCommand {
     action: "expand" | "collapse" | "expand-selected";
     id: number;
     path?: string;
+    direction?: "up" | "down";
 }
 export interface DiffDrawerExpansionState {
     allExpanded: boolean;
     allCollapsed: boolean;
 }
+export { estimateDiffCardHeight } from './diff-drawer-height';
 export type { Diff };
-interface EstimateDiffCardHeightInput {
-    diff: Diff;
-    isCollapsed: boolean;
-    hasOptedIntoLargeDiff?: boolean;
-    diffViewMode?: DiffViewMode;
-}
-export declare const estimateDiffCardHeight: (input: EstimateDiffCardHeightInput) => number;
 export declare const buildInitialCollapsedPaths: (diffs: Diff[]) => Set<string>;
 export declare const buildAllCollapsedPaths: (diffs: Diff[]) => Set<string>;
 export declare const toggleCollapsedPath: (collapsedPaths: Set<string>, path: string) => Set<string>;

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/diff-viewer/use-selected-diff-scroll.d.ts

@@ -0,0 +1,19 @@
+import { Diff } from './diff-card';
+import { DiffExpansionCommand } from './diff-drawer';
+import { DiffViewMode } from './types';
+interface UseSelectedDiffScrollInput {
+    diffs: Diff[];
+    selectedDiffPath: string | null;
+    collapsedPaths: Set<string>;
+    largeDiffOptInPaths: Set<string>;
+    expansionCommand: DiffExpansionCommand | null;
+    diffViewMode: DiffViewMode;
+    scrollRef: {
+        current: HTMLDivElement | null;
+    };
+}
+export declare const useSelectedDiffScroll: (input: UseSelectedDiffScrollInput) => {
+    selectedScrollIndex: number;
+    shouldPinSelectedScrollIndex: boolean;
+};
+export {};

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

@@ -0,0 +1,29 @@
+import { ComponentType } from 'react';
+export interface IconColorPickerIconOption {
+    value: string | null;
+    label: string;
+    icon: ComponentType;
+}
+export declare const optionColors: readonly ["gray", "red", "orange", "yellow", "green", "teal", "blue", "cyan", "purple", "pink"];
+export declare const optionIcons: ({
+    value: null;
+    label: string;
+    icon: import('react').ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & import('react').RefAttributes<SVGSVGElement>>;
+} | {
+    value: string;
+    label: string;
+    icon: import('react').ForwardRefExoticComponent<Omit<import('lucide-react').LucideProps, "ref"> & import('react').RefAttributes<SVGSVGElement>>;
+})[];
+export declare const getIconComponent: (name: string | null | undefined, iconOptions?: readonly IconColorPickerIconOption[]) => ComponentType;
+export interface IconColorPickerProps {
+    color: string;
+    colorOptions?: readonly string[];
+    icon?: string | null;
+    iconOptions?: readonly IconColorPickerIconOption[];
+    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;
@@ -71,6 +72,8 @@ export interface ListRowProps extends ListRowItem, Omit<ListRowRootProps, "as" |
     showExpandToggle?: boolean;
     variant?: ListRowVariant;
     tone?: ListRowTone;
+    selectedBg?: ListRowRootProps["bg"];
+    hoverBg?: ListRowRootProps["bg"];
     /** Wrap content into a single child element. Used for `<Menu.Item asChild><ListRow asChild>…</ListRow></Menu.Item>` and link components. */
     asChild?: boolean;
     onToggleExpand?: () => void;

package/dist/components/palette.d.ts

@@ -41,6 +41,7 @@ export interface PaletteProps<T extends PaletteEntry = PaletteEntry> {
     footerEnd?: ReactNode;
     filterEntries?: (entries: T[], query: string, mode?: string) => T[];
     onActiveEntryChange?: (entry: T | null, index: number) => void;
+    onQueryChange?: (query: string) => void;
     onClose: () => void;
     onEscape?: (ctx: PaletteEscapeContext<T>) => boolean | undefined;
 }

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

@@ -0,0 +1,2 @@
+export type { ParamEditorProps } from './param-editor';
+export { ParamEditor } from './param-editor';

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/tab-strip/tab-visibility-filter.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { ResourceContextAction } from '../resource-context-menu';
+import { VisibilityOverride } from '../tree-list/tree-list-visibility.store';
+export interface TabVisibilityPlacement {
+    closable?: boolean;
+    hiddenByDefault?: boolean;
+    title?: string;
+    contributionId: string;
+}
+export declare const filterVisibleTabs: <T extends TabVisibilityPlacement>(placements: T[], tabOverrides: Record<string, VisibilityOverride>, getKey: (placement: T) => string) => T[];
+export interface TabVisibilityMenuActions {
+    onToggleTab: (key: string, hiddenByDefault: boolean) => void;
+    onResetAll: () => void;
+}
+interface BuildTabMenuOptions {
+    checkmark: ReactNode;
+}
+export declare const buildTabVisibilityMenuActions: <T extends TabVisibilityPlacement>(placements: T[], tabOverrides: Record<string, VisibilityOverride>, actions: TabVisibilityMenuActions, getKey: (placement: T) => string, options: BuildTabMenuOptions) => ResourceContextAction[];
+export {};

package/dist/components/tab-strip/tab-visibility.store.d.ts

@@ -0,0 +1,41 @@
+import { VisibilityOverride } from '../tree-list/tree-list-visibility.store';
+interface TabVisibilitySnapshot {
+    tabOverrides: Record<string, VisibilityOverride>;
+}
+interface TabVisibilityState extends TabVisibilitySnapshot {
+    setTab: (key: string, value: VisibilityOverride | undefined) => void;
+    toggleTab: (key: string, hiddenByDefault: boolean) => void;
+    clearTab: (key: string) => void;
+    reset: () => void;
+}
+interface CreateTabVisibilityStoreOptions {
+    storageKey: string;
+}
+export declare const createTabVisibilityStore: (options: CreateTabVisibilityStoreOptions) => Omit<import('zustand').StoreApi<TabVisibilityState>, "setState" | "persist"> & {
+    setState(partial: TabVisibilityState | Partial<TabVisibilityState> | ((state: TabVisibilityState) => TabVisibilityState | Partial<TabVisibilityState>), replace?: false | undefined): unknown;
+    setState(state: TabVisibilityState | ((state: TabVisibilityState) => TabVisibilityState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<TabVisibilityState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TabVisibilityState) => void) => () => void;
+        onFinishHydration: (fn: (state: TabVisibilityState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<TabVisibilityState, unknown, unknown>>;
+    };
+};
+export declare const getTabVisibilityStore: (storageKey: string) => Omit<import('zustand').StoreApi<TabVisibilityState>, "setState" | "persist"> & {
+    setState(partial: TabVisibilityState | Partial<TabVisibilityState> | ((state: TabVisibilityState) => TabVisibilityState | Partial<TabVisibilityState>), replace?: false | undefined): unknown;
+    setState(state: TabVisibilityState | ((state: TabVisibilityState) => TabVisibilityState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<TabVisibilityState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TabVisibilityState) => void) => () => void;
+        onFinishHydration: (fn: (state: TabVisibilityState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<TabVisibilityState, unknown, unknown>>;
+    };
+};
+export declare const useTabVisibilityStore: <T>(storageKey: string, selector: (state: TabVisibilityState) => T) => T;
+export type { TabVisibilitySnapshot, TabVisibilityState };

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

@@ -0,0 +1,4 @@
+export { TagEditor } from './tag-editor';
+export type { TagEditorAction, TagEditorProps, TagEditorValue } from './tag-editor.types';
+export type { SaveTagSettingsInput, TagSettingsPanelProps } from './tag-settings-panel';
+export { TagSettingsPanel } from './tag-settings-panel';

package/dist/components/tag-editor/tag-editor-row.d.ts

@@ -0,0 +1,19 @@
+import { IconColorPickerIconOption } from '../icon-color-picker';
+import { TagEditorAction, TagEditorValue } from './tag-editor.types';
+interface TagEditorRowProps {
+    actionOptions?: TagEditorAction[];
+    colorOptions?: readonly string[];
+    iconOptions?: readonly IconColorPickerIconOption[];
+    value: TagEditorValue;
+    isSaving?: boolean;
+    showDefault?: boolean;
+    showIcons?: boolean;
+    onActionsChange: (actions: string[]) => void;
+    onColorChange: (color: string) => void;
+    onDelete: () => void;
+    onIconChange: (icon: string | null) => void;
+    onNameChange: (name: string) => void;
+    onSetDefault: () => void;
+}
+export declare const TagEditorRow: (props: TagEditorRowProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,44 @@
+import { IconColorPickerIconOption } from '../icon-color-picker';
+export interface TagEditorValue {
+    id: string;
+    name: string;
+    color: string;
+    sortOrder: number;
+    actions?: string[];
+    icon?: string | null;
+    isDefault?: boolean;
+    isNew?: boolean;
+}
+export interface TagEditorAction {
+    value: string;
+    label: string;
+}
+export interface TagEditorProps {
+    title: string;
+    description?: string;
+    values: TagEditorValue[];
+    onValuesChange: (values: TagEditorValue[]) => void;
+    onSave: () => void | Promise<void>;
+    onCancel: () => void;
+    onDeleteValue?: (value: TagEditorValue) => void;
+    onSetDefault?: (value: TagEditorValue) => void;
+    hasChanges?: boolean;
+    isSaving?: boolean;
+    addLabel?: string;
+    addPlaceholder?: string;
+    actionOptions?: TagEditorAction[];
+    actionsColumnLabel?: string;
+    cancelLabel?: string;
+    defaultAddColor?: string;
+    defaultAddIcon?: string | null;
+    defaultColumnLabel?: string;
+    deleteButtonText?: string;
+    deleteHeadline?: string;
+    deleteNotificationText?: (value: TagEditorValue) => string;
+    colorOptions?: readonly string[];
+    iconOptions?: readonly IconColorPickerIconOption[];
+    saveLabel?: string;
+    showDefault?: boolean;
+    showIcons?: boolean;
+    valueColumnLabel?: string;
+}

package/dist/components/tag-editor/tag-settings-panel.d.ts

@@ -0,0 +1,24 @@
+import { QueryKey } from '@tanstack/react-query';
+import { TagEditorProps, TagEditorValue } from './tag-editor.types';
+export interface SaveTagSettingsInput<TValue> {
+    deletedIds: Set<string>;
+    drafts: TagEditorValue[];
+    values: TValue[];
+}
+type EditorLabels = Pick<TagEditorProps, "actionOptions" | "actionsColumnLabel" | "addLabel" | "addPlaceholder" | "colorOptions" | "deleteButtonText" | "deleteHeadline" | "deleteNotificationText" | "description" | "iconOptions" | "showIcons" | "title" | "valueColumnLabel">;
+type SortableValue = {
+    id: string;
+    sortOrder: number;
+};
+export interface TagSettingsPanelProps<TValue extends SortableValue, TSource> extends EditorLabels {
+    errorTitle: string;
+    loadingText?: string;
+    queryKey: QueryKey;
+    readValues: (source: TSource) => Promise<TValue[]>;
+    saveValues: (source: TSource, input: SaveTagSettingsInput<TValue>) => Promise<void>;
+    source: TSource;
+    toEditorValue: (value: TValue) => TagEditorValue;
+    valueNeedsUpdate: (original: TValue, draft: TagEditorValue) => boolean;
+}
+export declare const TagSettingsPanel: <TValue extends SortableValue, TSource>(props: TagSettingsPanelProps<TValue, TSource>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tree-list/tree-list-model.d.ts

@@ -0,0 +1,58 @@
+import { TreeListNode, TreeListSection } from './tree-list.types';
+export declare const isInList: (id: string, values: string[]) => boolean;
+export declare const isActiveNode: (id: string, activeNodeId?: string | string[] | null) => boolean;
+export declare const isNavigableNode: (node: TreeListNode) => boolean;
+export declare const getNodeChildren: (node: TreeListNode) => TreeListNode[];
+export declare const hasExpandableChildren: (node: TreeListNode) => boolean;
+export type VirtualRow = {
+    kind: "section-header";
+    key: string;
+    sectionId: string;
+    section: TreeListSection;
+    collapsible: boolean;
+    expanded: boolean;
+} | {
+    kind: "node";
+    key: string;
+    sectionId: string;
+    node: TreeListNode;
+    level: number;
+    parentNodeId?: string;
+} | {
+    kind: "section-empty";
+    key: string;
+    sectionId: string;
+    emptyState: TreeListSection["emptyState"];
+};
+export type VirtualNodeRow = Extract<VirtualRow, {
+    kind: "node";
+}>;
+export type VirtualSectionHeaderRow = Extract<VirtualRow, {
+    kind: "section-header";
+}>;
+/** Rows the keyboard can land on: enabled nodes and collapsible section headers. */
+export type FocusableRow = VirtualNodeRow | VirtualSectionHeaderRow;
+export declare const buildVirtualRows: (sections: TreeListSection[], expandedSectionIds: string[], expandedNodeIds: string[]) => VirtualRow[];
+/** Stable id used to track keyboard focus across renders. */
+export declare const getRowFocusId: (row: FocusableRow) => string;
+export declare const isFocusableRow: (row: VirtualRow) => row is FocusableRow;
+export declare const getFocusableRows: (rows: VirtualRow[]) => FocusableRow[];
+export declare const resolveTreeListFocusRowId: (focusedRowId: string | undefined, activeNodeId: string | string[] | null | undefined, rows: VirtualRow[]) => string | undefined;
+export declare const resolveTreeListKeyboardNavigation: (input: {
+    rows: VirtualRow[];
+    focusedRowId: string | undefined;
+    activeNodeId?: string | string[] | null;
+    expandedNodeIds: string[];
+    key: string;
+}) => {
+    type: "toggle-section";
+    sectionId: string;
+    rowId?: undefined;
+} | {
+    type: "toggle-node";
+    nodeId: string;
+    rowId?: undefined;
+} | {
+    type: "focus";
+    rowId: string;
+} | null;

package/dist/components/tree-list/tree-list-node-row.d.ts

@@ -0,0 +1,20 @@
+import { StackProps } from '@chakra-ui/react';
+import { FocusEventHandler } from 'react';
+import { TreeListLinkComponent, TreeListNavigateEvent, TreeListNode } from './tree-list.types';
+type TreeListRowVariant = "compact" | "tree";
+interface TreeListNodeRowProps {
+    sectionId: string;
+    node: TreeListNode;
+    level: number;
+    expandedNodeIds: string[];
+    activeNodeId?: string | string[] | null;
+    rowVariant: TreeListRowVariant;
+    nodeGap: StackProps["gap"];
+    linkComponent?: TreeListLinkComponent;
+    tabIndex?: number;
+    onFocus?: FocusEventHandler<HTMLElement>;
+    onNavigate?: (event: TreeListNavigateEvent) => void;
+    onToggleNode?: (nodeId: string) => void;
+}
+export declare const TreeListNodeRow: (props: TreeListNodeRowProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tree-list/tree-list-order-filter.d.ts

@@ -0,0 +1,3 @@
+import { TreeListNode, TreeListSection } from './tree-list.types';
+export declare const applyTreeListOrder: (sections: TreeListSection[], sectionOrder: string[], nodeOrderBySection: Record<string, string[]>) => TreeListSection[];
+export declare const reorderNodesById: (nodes: TreeListNode[], order: string[]) => TreeListNode[];

package/dist/components/tree-list/tree-list-order.store.d.ts

@@ -0,0 +1,42 @@
+interface TreeListOrderSnapshot {
+    sectionOrder: string[];
+    nodeOrderBySection: Record<string, string[]>;
+}
+interface TreeListOrderState extends TreeListOrderSnapshot {
+    setSectionOrder: (nextSectionIds: string[]) => void;
+    setNodeOrder: (sectionId: string, nextNodeIds: string[]) => void;
+    resetSectionOrder: () => void;
+    resetNodeOrder: (sectionId: string) => void;
+    reset: () => void;
+}
+interface CreateTreeListOrderStoreOptions {
+    storageKey: string;
+}
+export declare const createTreeListOrderStore: (options: CreateTreeListOrderStoreOptions) => Omit<import('zustand').StoreApi<TreeListOrderState>, "setState" | "persist"> & {
+    setState(partial: TreeListOrderState | Partial<TreeListOrderState> | ((state: TreeListOrderState) => TreeListOrderState | Partial<TreeListOrderState>), replace?: false | undefined): unknown;
+    setState(state: TreeListOrderState | ((state: TreeListOrderState) => TreeListOrderState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<TreeListOrderState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TreeListOrderState) => void) => () => void;
+        onFinishHydration: (fn: (state: TreeListOrderState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<TreeListOrderState, unknown, unknown>>;
+    };
+};
+export declare const getTreeListOrderStore: (storageKey: string) => Omit<import('zustand').StoreApi<TreeListOrderState>, "setState" | "persist"> & {
+    setState(partial: TreeListOrderState | Partial<TreeListOrderState> | ((state: TreeListOrderState) => TreeListOrderState | Partial<TreeListOrderState>), replace?: false | undefined): unknown;
+    setState(state: TreeListOrderState | ((state: TreeListOrderState) => TreeListOrderState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<TreeListOrderState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TreeListOrderState) => void) => () => void;
+        onFinishHydration: (fn: (state: TreeListOrderState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<TreeListOrderState, unknown, unknown>>;
+    };
+};
+export declare const useTreeListOrderStore: <T>(storageKey: string, selector: (state: TreeListOrderState) => T) => T;
+export type { TreeListOrderSnapshot, TreeListOrderState };

package/dist/components/tree-list/tree-list-reorder.d.ts

@@ -0,0 +1,13 @@
+import { TreeListSection } from './tree-list.types';
+export declare const toSectionDragId: (sectionId: string) => string;
+export declare const isSectionDragId: (id: string) => boolean;
+export declare const fromSectionDragId: (id: string) => string;
+export type ReorderResult = {
+    kind: "section";
+    nextSectionIds: string[];
+} | {
+    kind: "node";
+    sectionId: string;
+    nextNodeIds: string[];
+};
+export declare const computeReorderResult: (sections: TreeListSection[], activeId: string, overId: string) => ReorderResult | null;

package/dist/components/tree-list/tree-list-section-header.d.ts

@@ -0,0 +1,14 @@
+import { FocusEventHandler, MouseEvent as ReactMouseEvent } from 'react';
+import { TreeListSection } from './tree-list.types';
+interface TreeListSectionHeaderProps {
+    section: TreeListSection;
+    collapsible: boolean;
+    expanded: boolean;
+    focusId: string;
+    tabIndex: number;
+    onFocus: FocusEventHandler<HTMLElement>;
+    onToggle: () => void;
+    onContextMenu?: (event: ReactMouseEvent<HTMLElement>, sectionId: string) => void;
+}
+export declare const TreeListSectionHeader: (props: TreeListSectionHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tree-list/tree-list-sortable.d.ts

@@ -0,0 +1,22 @@
+import { StackProps } from '@chakra-ui/react';
+import { MouseEvent as ReactMouseEvent } from 'react';
+import { TreeListLinkComponent, TreeListNavigateEvent, TreeListSection } from './tree-list.types';
+type TreeListRowVariant = "compact" | "tree";
+interface TreeListSortableProps {
+    sections: TreeListSection[];
+    expandedSectionIds?: string[];
+    expandedNodeIds?: string[];
+    activeNodeId?: string | string[] | null;
+    rowVariant?: TreeListRowVariant;
+    sectionGap?: StackProps["gap"];
+    nodeGap?: StackProps["gap"];
+    linkComponent?: TreeListLinkComponent;
+    onNavigate?: (event: TreeListNavigateEvent) => void;
+    onToggleSection?: (sectionId: string) => void;
+    onToggleNode?: (nodeId: string) => void;
+    onSectionContextMenu?: (event: ReactMouseEvent<HTMLElement>, sectionId: string) => void;
+    onReorderSections?: (nextSectionIds: string[]) => void;
+    onReorderNodes?: (sectionId: string, nextNodeIds: string[]) => void;
+}
+export declare const TreeListSortable: (props: TreeListSortableProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tree-list/tree-list-visibility-filter.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { ResourceContextAction } from '../resource-context-menu';
+import { TreeListSection } from './tree-list.types';
+import { VisibilityOverride } from './tree-list-visibility.store';
+export declare const resolveVisibility: (override: VisibilityOverride | undefined, hiddenByDefault: boolean | undefined) => VisibilityOverride;
+export declare const filterVisibleSections: (sections: TreeListSection[], sectionOverrides: Record<string, VisibilityOverride>, nodeOverrides: Record<string, VisibilityOverride>) => TreeListSection[];
+export interface TreeVisibilityMenuActions {
+    onToggleSection: (id: string, hiddenByDefault: boolean) => void;
+    onToggleNode: (id: string, hiddenByDefault: boolean) => void;
+    onResetAll: () => void;
+    onResetOrder?: () => void;
+}
+interface BuildMenuOptions {
+    checkmark: ReactNode;
+}
+export declare const buildTreeVisibilityMenuActions: (sections: TreeListSection[], sectionOverrides: Record<string, VisibilityOverride>, nodeOverrides: Record<string, VisibilityOverride>, actions: TreeVisibilityMenuActions, options: BuildMenuOptions) => ResourceContextAction[];
+export {};

package/dist/components/tree-list/tree-list-visibility.store.d.ts

@@ -0,0 +1,45 @@
+export type VisibilityOverride = "hidden" | "shown";
+interface TreeListVisibilitySnapshot {
+    sectionOverrides: Record<string, VisibilityOverride>;
+    nodeOverrides: Record<string, VisibilityOverride>;
+}
+interface TreeListVisibilityState extends TreeListVisibilitySnapshot {
+    setSection: (id: string, value: VisibilityOverride | undefined) => void;
+    setNode: (id: string, value: VisibilityOverride | undefined) => void;
+    toggleSection: (id: string, hiddenByDefault: boolean) => void;
+    toggleNode: (id: string, hiddenByDefault: boolean) => void;
+    clearSection: (id: string) => void;
+    clearNode: (id: string) => void;
+    reset: () => void;
+}
+interface CreateTreeListVisibilityStoreOptions {
+    storageKey: string;
+}
+export declare const createTreeListVisibilityStore: (options: CreateTreeListVisibilityStoreOptions) => Omit<import('zustand').StoreApi<TreeListVisibilityState>, "setState" | "persist"> & {
+    setState(partial: TreeListVisibilityState | Partial<TreeListVisibilityState> | ((state: TreeListVisibilityState) => TreeListVisibilityState | Partial<TreeListVisibilityState>), replace?: false | undefined): unknown;
+    setState(state: TreeListVisibilityState | ((state: TreeListVisibilityState) => TreeListVisibilityState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<TreeListVisibilityState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TreeListVisibilityState) => void) => () => void;
+        onFinishHydration: (fn: (state: TreeListVisibilityState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<TreeListVisibilityState, unknown, unknown>>;
+    };
+};
+export declare const getTreeListVisibilityStore: (storageKey: string) => Omit<import('zustand').StoreApi<TreeListVisibilityState>, "setState" | "persist"> & {
+    setState(partial: TreeListVisibilityState | Partial<TreeListVisibilityState> | ((state: TreeListVisibilityState) => TreeListVisibilityState | Partial<TreeListVisibilityState>), replace?: false | undefined): unknown;
+    setState(state: TreeListVisibilityState | ((state: TreeListVisibilityState) => TreeListVisibilityState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<TreeListVisibilityState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TreeListVisibilityState) => void) => () => void;
+        onFinishHydration: (fn: (state: TreeListVisibilityState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<TreeListVisibilityState, unknown, unknown>>;
+    };
+};
+export declare const useTreeListVisibilityStore: <T>(storageKey: string, selector: (state: TreeListVisibilityState) => T) => T;
+export type { TreeListVisibilitySnapshot, TreeListVisibilityState };

package/dist/components/tree-list/tree-list.d.ts

@@ -1,6 +1,7 @@
 import { StackProps } from '@chakra-ui/react';
-import { RefObject } from 'react';
-import { TreeListLinkComponent, TreeListNavigateEvent, TreeListNode, TreeListSection } from './tree-list.types';
+import { MouseEvent as ReactMouseEvent, RefObject } from 'react';
+import { TreeListLinkComponent, TreeListNavigateEvent, TreeListSection } from './tree-list.types';
+export { buildVirtualRows } from './tree-list-model';
 type TreeListRowVariant = "compact" | "tree";
 interface TreeListProps {
     sections: TreeListSection[];
@@ -14,32 +15,11 @@ interface TreeListProps {
     onNavigate?: (event: TreeListNavigateEvent) => void;
     onToggleSection?: (sectionId: string) => void;
     onToggleNode?: (nodeId: string) => void;
-    /**
-     * When set, the tree's rows are virtualized via @tanstack/react-virtual.
-     * Requires `scrollRef` to point at the ancestor scroll viewport.
-     */
+    onSectionContextMenu?: (event: ReactMouseEvent<HTMLElement>, sectionId: string) => void;
     virtualize?: boolean;
     scrollRef?: RefObject<HTMLDivElement | null>;
+    draggable?: boolean;
+    onReorderSections?: (nextSectionIds: string[]) => void;
+    onReorderNodes?: (sectionId: string, nextNodeIds: string[]) => void;
 }
-export type VirtualRow = {
-    kind: "section-header";
-    key: string;
-    sectionId: string;
-    section: TreeListSection;
-    collapsible: boolean;
-    expanded: boolean;
-} | {
-    kind: "node";
-    key: string;
-    sectionId: string;
-    node: TreeListNode;
-    level: number;
-} | {
-    kind: "section-empty";
-    key: string;
-    sectionId: string;
-    emptyState: TreeListSection["emptyState"];
-};
-export declare const buildVirtualRows: (sections: TreeListSection[], expandedSectionIds: string[], expandedNodeIds: string[]) => VirtualRow[];
 export declare const TreeList: (props: TreeListProps) => import("react/jsx-runtime").JSX.Element;
-export {};