@box/metadata-taxonomy-picker 2.18.0

package/dist/types/lib/stories/shared/generate-deep-nodes.d.ts

@@ -0,0 +1,39 @@
+import { TaxonomyNode } from '../../types';
+declare const ROOT_KEY = "__root__";
+export interface DeepTreeOptions {
+    /** Total depth of the tree (number of drillable levels). */
+    depth: number;
+    /** How many children each non-leaf level holds. Defaults to 3. */
+    branching?: number;
+    /**
+     * Optional per-level display name template applied as `${prefix} ${index}`.
+     * If not provided, levels are labelled as `L1`, `L2`, … with the row index.
+     */
+    levelLabels?: string[];
+    /**
+     * Render long, sentence-style names that force the breadcrumb to truncate
+     * even at moderate depths. Useful for visualizing the folder-tree dropdown.
+     */
+    longNames?: boolean;
+}
+/**
+ * Build a synthetic taxonomy tree with arbitrary depth for breadcrumb-truncation
+ * stories. The first child of every level is the only one whose subtree continues
+ * deeper, which guarantees a single deterministic deep path while still giving
+ * each level enough siblings to look realistic in the items list.
+ *
+ * Example for `depth: 4`, `branching: 3`:
+ *
+ *     root → L1 01, L1 02, L1 03
+ *     L1 01 → L2 01, L2 02, L2 03
+ *     L2 01 → L3 01, L3 02, L3 03
+ *     L3 01 → L4 01, L4 02, L4 03   (leaves)
+ */
+export declare function buildDeepTree({ depth, branching, levelLabels, longNames, }: DeepTreeOptions): Record<string, TaxonomyNode[]>;
+/**
+ * Returns the deterministic deep path produced by `buildDeepTree` — the chain
+ * of ids the caller must drill through to reach the deepest level. The first
+ * id is the root-level row, the last id is the deepest level reachable.
+ */
+export declare function getDeepPath(depth: number): string[];
+export { ROOT_KEY };

package/dist/types/lib/stories/shared/generate-hierarchical-nodes.d.ts

@@ -0,0 +1,3 @@
+import { TaxonomyNode } from '../../types';
+/** Three-level fixture (Region -> Country -> State) for drill-down stories. */
+export declare function buildTwoLevelTree(): Record<string, TaxonomyNode[]>;

package/dist/types/lib/stories/shared/generate-nodes.d.ts

@@ -0,0 +1,2 @@
+import { TaxonomyNode } from '../../types';
+export declare function generateNodes(count: number, options?: Partial<TaxonomyNode>): TaxonomyNode[];

package/dist/types/lib/stories/shared/generate-search-results.d.ts

@@ -0,0 +1,10 @@
+import { TaxonomySearchResult } from '../../types';
+/**
+ * Builds an array of `TaxonomySearchResult` fixtures for use in stories and
+ * interaction tests. Each result has an `ancestors` array by default so that
+ * the ancestor-breadcrumb subtitle is rendered in the row.
+ *
+ * Pass `options` to override any field across all generated items, e.g.
+ * `{ hasChildren: true }` to verify drill-down chevrons in search results.
+ */
+export declare function generateSearchResults(count: number, options?: Partial<TaxonomySearchResult>): TaxonomySearchResult[];

package/dist/types/lib/stories/shared/story-container.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+/** Fixed-width framed wrapper used by TaxonomyItemsList stories. */
+export declare function StoryContainer({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/lib/stories/shared/taxonomy-items-list-fixtures.d.ts

@@ -0,0 +1,7 @@
+import { TaxonomyAncestor } from '../../types';
+/** Realistic single-line names for browse-mode rows. */
+export declare const BROWSE_NAMES: string[];
+/** Realistic names for search-mode rows (paired with `ANCESTOR_PATHS`). */
+export declare const SEARCH_NAMES: string[];
+/** Ancestor breadcrumb paths from depth 1 to depth 7, used to vary search-row height. */
+export declare const ANCESTOR_PATHS: TaxonomyAncestor[][];

package/dist/types/lib/stories/taxonomy-ancestor-breadcrumb.stories.d.ts

@@ -0,0 +1,28 @@
+import { StoryObj } from '@storybook/react-vite';
+import { TaxonomyAncestorBreadcrumb } from '../components/taxonomy-ancestor-breadcrumb';
+import { TaxonomyAncestor } from '../types';
+declare const _default: {
+    title: string;
+    component: import('react').NamedExoticComponent<import('../components/taxonomy-ancestor-breadcrumb').TaxonomyAncestorBreadcrumbProps>;
+    decorators: ((Story: import('storybook/internal/csf').PartialStoryFn<import('@storybook/react').ReactRenderer, {
+        ancestors: TaxonomyAncestor[];
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+    parameters: {
+        docs: {
+            description: {
+                component: string;
+            };
+        };
+        layout: string;
+    };
+};
+export default _default;
+type Story = StoryObj<typeof TaxonomyAncestorBreadcrumb>;
+export declare const SingleAncestor: Story;
+export declare const TwoAncestors: Story;
+/** Plenty of width — full trail fits without truncation. */
+export declare const FullTrailFits: Story;
+/** Narrow container — the trail collapses to `first / … / last`. */
+export declare const TruncatedToFirstAndLast: Story;
+/** Long segment names — truncated form still applies CSS ellipsis on the leaf segment. */
+export declare const VeryLongSegments: Story;

package/dist/types/lib/stories/taxonomy-items-list.stories.d.ts

@@ -0,0 +1,77 @@
+import { StoryObj } from '@storybook/react-vite';
+import { TaxonomyItemsList } from '../components/taxonomy-items-list';
+declare const _default: {
+    title: string;
+    component: import('react').ForwardRefExoticComponent<import('../components/taxonomy-items-list').TaxonomyItemsListProps & import('react').RefAttributes<import('../components/taxonomy-items-list').TaxonomyItemsListRef>>;
+    decorators: ((Story: import('storybook/internal/csf').PartialStoryFn<import('@storybook/react').ReactRenderer, {
+        items: import('../components/taxonomy-menu-item').TaxonomyMenuItemProps[];
+        multiSelect: boolean;
+        selectedValue: string;
+        estimatedRowHeight?: number | undefined;
+        hasVariableRowHeight?: boolean | undefined;
+        isSearchMode?: boolean | undefined;
+        isFetching: boolean;
+        error: string | null;
+        loadMoreError?: string | null | undefined;
+        onRetry: () => void;
+        listboxId?: string | undefined;
+        onFocusExit?: (() => void) | undefined;
+        hasMore?: boolean | undefined;
+        isFetchingMore?: boolean | undefined;
+        onLoadMore?: (() => void) | undefined;
+        ref?: import('react').LegacyRef<import('../components/taxonomy-items-list').TaxonomyItemsListRef> | undefined;
+        key?: import('react').Key | null | undefined;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+    parameters: {
+        docs: {
+            description: {
+                component: string;
+            };
+        };
+        layout: string;
+        modernizedComponents: boolean;
+    };
+};
+export default _default;
+type Story = StoryObj<typeof TaxonomyItemsList>;
+/** 1 000 single-select browse items — validates scrolling and virtualization at scale. */
+export declare const BrowseLargeDataset: Story;
+/** 3 000 multi-select browse items with checkboxes. */
+export declare const BrowseLargeDatasetMultiSelect: Story;
+/** Small browse list — 5 items, no scrollbar. */
+export declare const BrowseFewItems: Story;
+/** 1 000 search results with 1–7 level ancestor breadcrumbs. Rows vary in height. */
+export declare const SearchLargeDataset: Story;
+/** 3 000 multi-select search results with breadcrumbs and checkboxes. */
+export declare const SearchLargeDatasetMultiSelect: Story;
+/** Search results with drill-down chevrons — results that have children. */
+export declare const SearchWithDrillDown: Story;
+/**
+ * Browse rows where only deeper levels are selectable. Rows render the
+ * display name and drill-down chevron only — no radio or checkbox.
+ */
+export declare const BrowseNonSelectableParentLevel: Story;
+/**
+ * Search results matching a parent-only level — breadcrumbs are shown,
+ * the row exposes no selection control, but the drill-down chevron
+ * remains so users can navigate into selectable children.
+ */
+export declare const SearchNonSelectableResults: Story;
+/** Full-area skeleton while data is loading. */
+export declare const Loading: Story;
+/** Error state with a retry button. */
+export declare const Error: Story;
+/** Empty state when the level contains no items. */
+export declare const Empty: Story;
+/** Items already loaded with ghost rows shown at the bottom while the next page loads. */
+export declare const LoadingMore: Story;
+/**
+ * Load-more error: already-loaded items remain visible while an inline
+ * "Loading failed" notice with a Reload action sits at the bottom of the list.
+ */
+export declare const LoadMoreError: Story;
+/**
+ * Same load-more error variant, but in search mode — verifies the inline
+ * error renders at the bottom of variable-height search rows too.
+ */
+export declare const SearchLoadMoreError: Story;

package/dist/types/lib/stories/taxonomy-menu-item.stories.d.ts

@@ -0,0 +1,67 @@
+import { StoryObj } from '@storybook/react-vite';
+import { TaxonomyMenuItem, TaxonomyMenuItemProps } from '../components/taxonomy-menu-item';
+declare const _default: {
+    title: string;
+    component: import('react').NamedExoticComponent<TaxonomyMenuItemProps>;
+    render: (props: TaxonomyMenuItemProps) => import("react/jsx-runtime").JSX.Element;
+    args: {
+        id: string;
+        displayName: string;
+        selectable: true;
+        multiSelect: false;
+        isSelected: false;
+        showDrillDown: false;
+        onSelect: import('storybook/actions').HandlerFunction;
+        onDrillDown: import('storybook/actions').HandlerFunction;
+    };
+    decorators: ((Story: import('storybook/internal/csf').PartialStoryFn<import('@storybook/react').ReactRenderer, {
+        id: string;
+        displayName: string;
+        isSearchMode?: boolean | undefined;
+        selectable: boolean;
+        multiSelect: boolean;
+        isSelected: boolean;
+        showDrillDown: boolean;
+        ancestors?: import('../types').TaxonomyAncestor[] | undefined;
+        onSelect: (id: string, closeAfterSelect?: boolean) => void;
+        onDrillDown?: ((id: string) => void) | undefined;
+        onFocusExit?: (() => void) | undefined;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+    parameters: {
+        docs: {
+            description: {
+                component: string;
+            };
+        };
+        viewport: {
+            defaultViewport: string;
+        };
+        layout: string;
+    };
+};
+export default _default;
+type Story = StoryObj<typeof TaxonomyMenuItem>;
+/** Radio selection control, unselected. */
+export declare const RadioUnselected: Story;
+/** Radio selection control, selected. */
+export declare const RadioSelected: Story;
+/** Checkbox selection control, unselected (multi-select mode). */
+export declare const CheckboxUnselected: Story;
+/** Checkbox selection control, selected (multi-select mode). */
+export declare const CheckboxSelected: Story;
+/** Non-selectable item rendered as a plain label — no radio or checkbox. */
+export declare const NonSelectablePlainLabel: Story;
+/** Radio item with drill-down chevron for navigating into child levels. */
+export declare const WithDrillDownChevron: Story;
+/** Non-selectable item with drill-down chevron — acts as a navigation-only row. */
+export declare const NonSelectableWithDrillDown: Story;
+/** Item with a single ancestor in the breadcrumb subtitle. */
+export declare const WithSingleAncestor: Story;
+/** Item with multiple ancestors forming a breadcrumb path (Region > Country > State). */
+export declare const WithMultipleAncestors: Story;
+/** Checkbox item with ancestors and drill-down chevron — full combined variant. */
+export declare const CheckboxWithAncestorsAndDrillDown: Story;
+/** Selected radio with ancestors and drill-down — the other full combined variant. */
+export declare const RadioWithAncestorsAndDrillDown: Story;
+/** Long display name and long ancestor path — verifies text truncation. */
+export declare const LongTextTruncation: Story;

package/dist/types/lib/stories/tests/breadcrumb-navigation.interaction-tests.stories.d.ts

@@ -0,0 +1,78 @@
+import { StoryObj } from '@storybook/react-vite';
+import { MetadataTaxonomyPicker } from '../../../index';
+import { MetadataTaxonomyPickerProps, TaxonomyPickerMode, TaxonomyValue } from '../../types';
+declare const _default: {
+    parameters: {
+        docs: {
+            page: () => import("react/jsx-runtime").JSX.Element;
+        };
+        controls: {
+            exclude: RegExp;
+        };
+    };
+    title: string;
+    component: import('react').ForwardRefExoticComponent<MetadataTaxonomyPickerProps & import('react').RefAttributes<HTMLInputElement>>;
+    decorators: ((Story: import('storybook/internal/csf').PartialStoryFn<import('@storybook/react').ReactRenderer, {
+        mode: TaxonomyPickerMode;
+        multiSelect: boolean;
+        value: TaxonomyValue[];
+        onValueChange: (values: TaxonomyValue[]) => void;
+        itemsService: import('../../types').TaxonomyItemsService;
+        eventService?: import('../../types').TaxonomyPickerEventService | undefined;
+        levels?: import('../../types').TaxonomyLevel[] | undefined;
+        placeholder?: string | undefined;
+        disabled?: boolean | undefined;
+        label?: string | undefined;
+        containerClassName?: string | undefined;
+        portalElement?: (HTMLElement | (() => HTMLElement | null) | null) | undefined;
+        ref?: import('react').LegacyRef<HTMLInputElement> | undefined;
+        key?: import('react').Key | null | undefined;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+};
+export default _default;
+type Story = StoryObj<typeof MetadataTaxonomyPicker>;
+/**
+ * At the root level the breadcrumb is intentionally absent — there is nowhere
+ * to navigate "back" to. The popover shows only the items list.
+ */
+export declare const HidesBreadcrumbAtRootLevel: Story;
+/**
+ * After drilling into a child level the breadcrumb appears inside the popover
+ * and the current page (the level the user is browsing) is shown as the
+ * trailing, non-interactive crumb.
+ */
+export declare const RendersBreadcrumbAfterDrillDown: Story;
+/**
+ * Drilling deeper appends the new level to the breadcrumb trail and the
+ * previously-current crumb becomes a clickable button.
+ */
+export declare const AppendsCrumbsAsTheUserDrillsDeeper: Story;
+/**
+ * Clicking an ancestor crumb navigates the picker back to that level and the
+ * children of the chosen ancestor reappear in the items list.
+ */
+export declare const NavigatesBackToAncestorWhenCrumbClicked: Story;
+/**
+ * Clicking the synthetic root crumb ("All") returns the picker to the
+ * top-level list and removes the breadcrumb entirely.
+ */
+export declare const NavigatesBackToRootWhenRootCrumbClicked: Story;
+/**
+ * Eight-level drill-down. The current page reflects the deepest level the user
+ * navigated into, and the synthetic root crumb is still reachable through the
+ * folder-tree dropdown (the trail is too long to render every crumb inline).
+ */
+export declare const NavigatesThroughEightLevelsAndReportsCurrentPage: Story;
+/**
+ * From a deep level the user can jump straight back to any ancestor in a single
+ * click — even when that ancestor lives inside the folder-tree truncation
+ * dropdown. The trail trims to that ancestor and its children reappear in the
+ * list.
+ */
+export declare const JumpsToMidTrailAncestorFromDeepLevel: Story;
+/**
+ * In a narrow popover with long display names, the folder-tree truncation
+ * collapses older ancestors into a dropdown that the user can open to surface
+ * the hidden ancestors.
+ */
+export declare const FolderTreeTruncationExposesHiddenAncestors: Story;

package/dist/types/lib/stories/tests/error-handling.interaction-tests.stories.d.ts

@@ -0,0 +1,50 @@
+import { StoryObj } from '@storybook/react-vite';
+import { MetadataTaxonomyPicker } from '../../../index';
+declare const _default: {
+    parameters: {
+        docs: {
+            page: () => import("react/jsx-runtime").JSX.Element;
+        };
+        controls: {
+            exclude: RegExp;
+        };
+    };
+    title: string;
+    component: import('react').ForwardRefExoticComponent<import('../../types').MetadataTaxonomyPickerProps & import('react').RefAttributes<HTMLInputElement>>;
+};
+export default _default;
+type Story = StoryObj<typeof MetadataTaxonomyPicker>;
+/**
+ * Acceptance: clicking retry on the initial load error calls `actions.retry()`,
+ * which re-runs `initialLoad`. The full-area error is replaced by the items
+ * once the retry succeeds.
+ */
+export declare const InitialLoadErrorRecoversOnRetry: Story;
+/**
+ * Acceptance: load-more error displays as an inline row at the bottom of the
+ * existing list, already-loaded items remain visible, and clicking retry
+ * re-attempts from the current marker.
+ */
+export declare const BrowseLoadMoreErrorRecoversOnRetry: Story;
+/**
+ * Acceptance: search error fills the search results area with a retry button,
+ * and clicking retry re-runs the last committed query.
+ */
+export declare const SearchErrorRecoversOnRetry: Story;
+/**
+ * Acceptance: search load-more error shows an inline error row at the bottom
+ * of the search results, already-loaded results remain visible, and clicking
+ * retry re-attempts from the current marker.
+ */
+export declare const SearchLoadMoreErrorRecoversOnRetry: Story;
+/**
+ * Acceptance: `lastFailedOp` is set on each error action and cleared on the
+ * corresponding success — so retry is always unambiguous, even if the user
+ * has changed the search input between the failure and the retry click.
+ *
+ * Scenario: initial browse load fails → user types into the search input
+ * (committing a search) → user clears the search → user clicks retry. The
+ * retry must re-run the initial browse load (the only operation still in
+ * the failed state) and not get confused by the intermediate search.
+ */
+export declare const RetryRemainsUnambiguousAcrossStateDrift: Story;

package/dist/types/lib/stories/tests/interaction-tests.stories.d.ts

@@ -0,0 +1,47 @@
+import { StoryObj } from '@storybook/react-vite';
+import { MetadataTaxonomyPicker } from '../../../index';
+import { MetadataTaxonomyPickerProps, TaxonomyPickerMode, TaxonomyValue } from '../../types';
+declare const _default: {
+    parameters: {
+        docs: {
+            page: () => import("react/jsx-runtime").JSX.Element;
+        };
+        controls: {
+            exclude: RegExp;
+        };
+    };
+    title: string;
+    component: import('react').ForwardRefExoticComponent<MetadataTaxonomyPickerProps & import('react').RefAttributes<HTMLInputElement>>;
+    decorators: ((Story: import('storybook/internal/csf').PartialStoryFn<import('@storybook/react').ReactRenderer, {
+        mode: TaxonomyPickerMode;
+        multiSelect: boolean;
+        value: TaxonomyValue[];
+        onValueChange: (values: TaxonomyValue[]) => void;
+        itemsService: import('../../types').TaxonomyItemsService;
+        eventService?: import('../../types').TaxonomyPickerEventService | undefined;
+        levels?: import('../../types').TaxonomyLevel[] | undefined;
+        placeholder?: string | undefined;
+        disabled?: boolean | undefined;
+        label?: string | undefined;
+        containerClassName?: string | undefined;
+        portalElement?: (HTMLElement | (() => HTMLElement | null) | null) | undefined;
+        ref?: import('react').LegacyRef<HTMLInputElement> | undefined;
+        key?: import('react').Key | null | undefined;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+};
+export default _default;
+type Story = StoryObj<typeof MetadataTaxonomyPicker>;
+export declare const OpensPopoverOnClick: Story;
+export declare const ClosesOnEscape: Story;
+export declare const ClosesOnClickOutside: Story;
+export declare const ShowsSkeletonWhileLoading: Story;
+export declare const ShowsEmptyStateWhenNoData: Story;
+export declare const SingleSelectPicksItemAndClosesPopover: Story;
+export declare const MultiSelectTogglesItemsWithoutClosingPopover: Story;
+export declare const SingleSelectArrowNavigationKeepsPopoverOpen: Story;
+export declare const MultiSelectDeselectsAlreadySelectedItem: Story;
+export declare const NonSelectableItemRendersWithoutSelectionControl: Story;
+export declare const DrillsDownMultipleLevels: Story;
+export declare const DrillDownShowsLoadingSkeleton: Story;
+export declare const RightArrowAndSpacebarKeyboardDrillDown: Story;
+export declare const ChipDismiss: Story;

package/dist/types/lib/stories/tests/level-filter-interaction-tests.stories.d.ts

@@ -0,0 +1,99 @@
+import { StoryObj } from '@storybook/react-vite';
+import { MetadataTaxonomyPickerProps, TaxonomyLevel, TaxonomyPickerMode, TaxonomyValue } from '../../types';
+interface ControlledPickerProps extends Omit<MetadataTaxonomyPickerProps, 'value' | 'onValueChange'> {
+    initialValue?: TaxonomyValue[];
+}
+declare function ControlledPicker({ initialValue, ...props }: ControlledPickerProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: {
+    parameters: {
+        docs: {
+            page: () => import("react/jsx-runtime").JSX.Element;
+        };
+        controls: {
+            exclude: RegExp;
+        };
+    };
+    title: string;
+    component: import('react').ForwardRefExoticComponent<MetadataTaxonomyPickerProps & import('react').RefAttributes<HTMLInputElement>>;
+    render: (args: MetadataTaxonomyPickerProps & import('react').RefAttributes<HTMLInputElement>) => import("react/jsx-runtime").JSX.Element;
+    args: {
+        itemsService: import('../../types').TaxonomyItemsService;
+        levels: TaxonomyLevel[];
+        mode: TaxonomyPickerMode.MultiLevel;
+        multiSelect: false;
+        placeholder: string;
+    };
+    decorators: ((Story: import('storybook/internal/csf').PartialStoryFn<import('@storybook/react').ReactRenderer, {
+        mode: TaxonomyPickerMode;
+        multiSelect: boolean;
+        value: TaxonomyValue[];
+        onValueChange: (values: TaxonomyValue[]) => void;
+        itemsService: import('../../types').TaxonomyItemsService;
+        eventService?: import('../../types').TaxonomyPickerEventService | undefined;
+        levels?: TaxonomyLevel[] | undefined;
+        placeholder?: string | undefined;
+        disabled?: boolean | undefined;
+        label?: string | undefined;
+        containerClassName?: string | undefined;
+        portalElement?: (HTMLElement | (() => HTMLElement | null) | null) | undefined;
+        ref?: import('react').LegacyRef<HTMLInputElement> | undefined;
+        key?: import('react').Key | null | undefined;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+};
+export default _default;
+type Story = StoryObj<typeof ControlledPicker>;
+/**
+ * The level filter only appears once the user starts typing — it is invisible
+ * in browse mode.
+ */
+export declare const LevelFilterHiddenInBrowseMode: Story;
+/**
+ * Once any character is typed the level filter becomes visible, even before
+ * the debounced search request completes.
+ */
+export declare const LevelFilterAppearsImmediatelyOnFirstKeystroke: Story;
+/**
+ * Taxonomies with only one level do not display the level filter — there is
+ * nothing meaningful to filter by.
+ */
+export declare const LevelFilterHiddenForSingleLevelTaxonomy: Story;
+/**
+ * When the search input is cleared, the picker returns to browse mode and the
+ * level filter disappears.
+ */
+export declare const LevelFilterHiddenAfterClearingSearch: Story;
+/**
+ * When the user starts typing from the root level (no drill-down), the filter
+ * defaults to "All levels" — no level is pre-selected.
+ */
+export declare const LevelFilterDefaultsToAllLevelsAtRoot: Story;
+/**
+ * When the user is one level deep (drilled into a Region) and then types,
+ * the filter automatically pre-selects the child level ("Country").
+ */
+export declare const LevelFilterAutoSelectsChildLevelAfterDrillDown: Story;
+/**
+ * The dropdown lists "All levels" first, then a separator, then one item per
+ * available taxonomy level.
+ */
+export declare const LevelFilterDropdownListsAllLevels: Story;
+/**
+ * Selecting a level from the dropdown re-runs the search restricted to that
+ * level, so only matching nodes from that level appear.
+ */
+export declare const SelectingALevelFiltersSearchResults: Story;
+/**
+ * After selecting a level, the trigger button updates its label to reflect the
+ * active filter.
+ */
+export declare const LevelFilterTriggerReflectsActiveSelection: Story;
+/**
+ * With no `levels`, the filter dropdown is hidden and a drill-down search
+ * must not silently apply a synthetic filter — results span every level.
+ */
+export declare const SearchAfterDrillDownWithNoAvailableLevelsIsUnfiltered: Story;
+/**
+ * Selecting "All levels" removes the level restriction, causing results from
+ * every level to appear again.
+ */
+export declare const SelectingAllLevelsRemovesFilter: Story;

package/dist/types/lib/stories/tests/level-transitions.interaction-tests.stories.d.ts

@@ -0,0 +1,60 @@
+import { StoryObj } from '@storybook/react-vite';
+import { TaxonomyItemsService } from '../../types';
+declare function LevelTransitionsHarness({ itemsService }: {
+    itemsService: TaxonomyItemsService;
+}): import("react/jsx-runtime").JSX.Element;
+declare const _default: {
+    parameters: {
+        docs: {
+            page: () => import("react/jsx-runtime").JSX.Element;
+        };
+        controls: {
+            exclude: RegExp;
+        };
+    };
+    title: string;
+    component: typeof LevelTransitionsHarness;
+    decorators: ((Story: import('storybook/internal/csf').PartialStoryFn<import('@storybook/react').ReactRenderer, {
+        itemsService: TaxonomyItemsService;
+    }>) => import("react/jsx-runtime").JSX.Element)[];
+};
+export default _default;
+type Story = StoryObj<typeof LevelTransitionsHarness>;
+/**
+ * Cache-hit path: after drilling into a level whose parent level was previously
+ * fetched, navigating back rehydrates from cache without issuing a new request.
+ */
+export declare const NavigatesBackFromCacheWithoutRefetch: Story;
+/**
+ * Cache-miss path: when the user lands on a deep level via a search result
+ * (whose ancestor level was never browsed), navigating back to that ancestor
+ * has no cached snapshot to seed from. The reducer transitions the level via
+ * `transitionToLevel` (clears items, shows the skeleton), and the controller
+ * issues a fresh `getNodes(region-a)` request.
+ */
+export declare const NavigatesBackWithRefetchWhenCacheMisses: Story;
+/**
+ * Reset-on-close: closing the popover wipes the per-level cache and reducer
+ * state, so the next open re-fetches the root.
+ */
+export declare const ResetsStateOnCloseAndRefetchesRootOnReopen: Story;
+/**
+ * Stale-response guard: drilling into one level and then immediately drilling
+ * into a different level must show the second level's data even though the
+ * first level's response resolves first (with the longer delay it would
+ * otherwise overwrite it).
+ */
+export declare const DropsStaleFetchResponseAfterRapidDrillDown: Story;
+/**
+ * Happy-path error reporting: when the network request for the current level
+ * fails, the reducer surfaces the message via `initialLoadError`, stops the
+ * fetching spinner, and tags the last failed op as `browse` so retry UI can
+ * target the right operation.
+ */
+export declare const SurfacesFetchErrorForCurrentLevel: Story;
+/**
+ * Stale-response guard for errors: drilling into a slow-failing level and
+ * immediately navigating back must NOT pollute the root level with the late
+ * Region A error. The reducer's `forParentId` guard drops the stale failure.
+ */
+export declare const DropsStaleFetchErrorAfterRapidNavigateBack: Story;