@floor/vlist 0.8.2 → 0.9.1

package/README.md

@@ -1,6 +1,6 @@
 # vlist
 
-Lightweight, high-performance virtual list with zero dependencies and optimal tree-shaking.
+Lightweight, high-performance virtual list with zero dependencies and dimension-agnostic architecture.
 
 [![npm version](https://img.shields.io/npm/v/%40floor%2Fvlist.svg)](https://www.npmjs.com/package/@floor/vlist)
 [![bundle size](https://img.shields.io/bundlephobia/minzip/@floor/vlist)](https://bundlephobia.com/package/@floor/vlist)
@@ -12,12 +12,20 @@ Lightweight, high-performance virtual list with zero dependencies and optimal tr
 - **8–12 KB gzipped** — pay only for features you use (vs 20 KB+ monolithic alternatives)
 - **Builder API** — composable plugins with perfect tree-shaking
 - **Grid, sections, async, selection, scale** — all opt-in
-- **Horizontal, reverse, page-scroll, wrap** — every layout mode
+- **Horizontal & vertical** — semantically correct orientation support
+- **Reverse, page-scroll, wrap** — every layout mode
 - **Accessible** — WAI-ARIA, keyboard navigation, screen-reader friendly
 - **React, Vue, Svelte** — framework adapters available
 
 **30+ interactive examples → [vlist.dev](https://vlist.dev)**
 
+## v0.9.0 Highlights
+
+- ✨ **Dimension-agnostic API** — semantically correct terminology for both orientations
+- 🎯 **Horizontal sections** — sticky headers work in horizontal carousels
+- 🎨 **Horizontal grid layouts** — 2D grids work in both orientations
+- 📐 **`orientation` not `direction`** — clearer, more intuitive configuration
+
 ## Installation
 
 ```bash
@@ -166,7 +174,9 @@ const list = vlist({
 | Pattern | Key options |
 |---------|------------|
 | **Chat UI** | `reverse: true` + `withSections({ sticky: false })` |
-| **Horizontal carousel** | `direction: 'horizontal'`, `item.width` |
+| **Horizontal carousel** | `orientation: 'horizontal'`, `item.width` |
+| **Horizontal sections** | `orientation: 'horizontal'` + `withSections()` |
+| **Horizontal grid** | `orientation: 'horizontal'` + `withGrid()` |
 | **Page-level scroll** | `withPage()` |
 | **1M+ items** | `withScale()` — auto-compresses scroll space |
 | **Wrap navigation** | `scroll: { wrap: true }` |
@@ -225,7 +235,7 @@ const list = vlist(config).use(...plugins).build()
 `list.on()` returns an unsubscribe function. You can also use `list.off(event, handler)`.
 
 ```typescript
-list.on('scroll', ({ scrollTop, direction }) => {})
+list.on('scroll', ({ scrollPosition, direction }) => {})  // v0.9.0: scrollPosition (was scrollTop)
 list.on('range:change', ({ range }) => {})
 list.on('item:click', ({ item, index, event }) => {})
 list.on('item:dblclick', ({ item, index, event }) => {})
@@ -290,6 +300,27 @@ import '@floor/vlist/styles/extras'    // optional enhancements
 
 Override with your own CSS using the `.vlist`, `.vlist-item`, `.vlist-item--selected`, `.vlist-scrollbar` selectors. See [vlist.dev](https://vlist.dev) for theming examples.
 
+## Architecture
+
+### Dimension-Agnostic Design (v0.9.0)
+
+vlist uses semantically correct terminology that works for both vertical and horizontal orientations:
+
+```typescript
+// ✅ Correct: Works for both orientations
+sizeCache.getSize(index)       // Returns height OR width
+state.scrollPosition           // scrollTop OR scrollLeft
+state.containerSize            // height OR width
+
+// Previously (v0.8.2): Semantically wrong in horizontal mode
+heightCache.getHeight(index)   // ❌ Returned WIDTH in horizontal!
+state.scrollTop                // ❌ Stored scrollLEFT!
+```
+
+This makes the codebase clearer and eliminates semantic confusion when working with horizontal lists.
+
+**Migration from v0.8.2:** See [v0.9.0 Migration Guide](https://vlist.dev/docs/refactoring/v0.9.0-migration-guide.md)
+
 ## Performance
 
 ### Bundle Size
@@ -357,9 +388,25 @@ const list: VList<Photo> = vlist<Photo>({
 
 [MIT](LICENSE)
 
+## Changelog
+
+### v0.9.0 (January 2025)
+
+**Breaking Changes:**
+- Renamed `direction` → `orientation` for semantic clarity
+- Renamed `HeightCache` → `SizeCache` and all related APIs
+- Renamed `scrollTop` → `scrollPosition` in ViewportState and events
+- See [Migration Guide](https://vlist.dev/docs/refactoring/v0.9.0-migration-guide.md)
+
+**New Features:**
+- Horizontal orientation support for grid and sections plugins
+- Complete dimension-agnostic architecture
+- Proper axis swapping for horizontal 2D grids
+
 ## Links
 
 - **Docs & Examples:** [vlist.dev](https://vlist.dev)
+- **Migration Guide:** [v0.9.0 Migration](https://vlist.dev/docs/refactoring/v0.9.0-migration-guide.md)
 - **GitHub:** [github.com/floor/vlist](https://github.com/floor/vlist)
 - **NPM:** [@floor/vlist](https://www.npmjs.com/package/@floor/vlist)
 - **Issues:** [GitHub Issues](https://github.com/floor/vlist/issues)

package/dist/builder/context.d.ts

@@ -6,7 +6,7 @@
  * registration points for handlers, methods, and cleanup callbacks.
  */
 import type { VListItem, VListEvents } from "../types";
-import type { HeightCache } from "../rendering/heights";
+import type { SizeCache } from "../rendering/sizes";
 import type { Renderer, DOMStructure } from "../rendering/renderer";
 import type { SimpleDataManager } from "./data";
 import type { ScrollController } from "../features/scrollbar/controller";
@@ -17,13 +17,13 @@ export interface CreateBuilderContextOptions<T extends VListItem = VListItem> {
     rawConfig: BuilderConfig<T>;
     resolvedConfig: ResolvedBuilderConfig;
     dom: DOMStructure;
-    heightCache: HeightCache;
+    sizeCache: SizeCache;
     dataManager: SimpleDataManager<T>;
     scrollController: ScrollController;
     renderer: Renderer<T>;
     emitter: Emitter<VListEvents<T>>;
     initialState: BuilderState;
-    initialHeightConfig: number | ((index: number) => number);
+    initialSizeConfig: number | ((index: number) => number);
 }
 /**
  * Create a BuilderContext from individual components.

package/dist/builder/core.d.ts

@@ -2,7 +2,7 @@
  * vlist/builder — Composable virtual list builder
  *
  * Pure utilities (velocity, DOM, pool, range, scroll) live in sibling files.
- * Height cache and emitter are reused from rendering/ and events/ modules.
+ * Size cache and emitter are reused from rendering/ and events/ modules.
  * Bun.build inlines everything into a single bundle automatically.
  *
  * Plugins compose features *around* the hot path via extension points:

package/dist/builder/materializectx.d.ts

@@ -13,7 +13,7 @@
  * destructured once and never re-read, so their names don't matter at runtime.
  */
 import type { VListItem, VListEvents, ItemTemplate, ItemState, Range } from "../types";
-import type { HeightCache } from "../rendering/heights";
+import type { SizeCache } from "../rendering/sizes";
 import type { Emitter } from "../events/emitter";
 import type { DOMStructure } from "./dom";
 import type { createElementPool } from "./pool";
@@ -26,7 +26,7 @@ import type { BuilderConfig, BuilderContext, BuilderState, ResolvedBuilderConfig
  * | Key  | Meaning                |
  * |------|------------------------|
  * | it   | items                  |
- * | hc   | heightCache            |
+ * | hc   | sizeCache              |
  * | ch   | containerHeight        |
  * | cw   | containerWidth         |
  * | id   | isDestroyed            |
@@ -57,8 +57,8 @@ import type { BuilderConfig, BuilderContext, BuilderState, ResolvedBuilderConfig
 export interface MRefs<T extends VListItem = VListItem> {
     /** items */
     it: T[];
-    /** heightCache */
-    hc: HeightCache;
+    /** sizeCache */
+    hc: SizeCache;
     /** containerHeight */
     ch: number;
     /** containerWidth */
@@ -99,9 +99,9 @@ export interface MRefs<T extends VListItem = VListItem> {
     /** forceRenderFn */
     ffn: () => void;
     /** getVisibleRange */
-    gvr: (scrollTop: number, cHeight: number, hc: HeightCache, total: number, out: Range) => void;
+    gvr: (scrollTop: number, cHeight: number, hc: SizeCache, total: number, out: Range) => void;
     /** getScrollToPos */
-    gsp: (index: number, hc: HeightCache, cHeight: number, total: number, align: "start" | "center" | "end") => number;
+    gsp: (index: number, hc: SizeCache, cHeight: number, total: number, align: "start" | "center" | "end") => number;
     /** positionElementFn */
     pef: (element: HTMLElement, index: number) => void;
     /** activeTemplate */
@@ -129,7 +129,7 @@ export interface MDeps<T extends VListItem = VListItem> {
     readonly isHorizontal: boolean;
     readonly classPrefix: string;
     readonly contentSizeHandlers: Array<() => void>;
-    readonly afterScroll: Array<(scrollTop: number, direction: string) => void>;
+    readonly afterScroll: Array<(scrollPosition: number, direction: string) => void>;
     readonly clickHandlers: Array<(event: MouseEvent) => void>;
     readonly keydownHandlers: Array<(event: KeyboardEvent) => void>;
     readonly resizeHandlers: Array<(width: number, height: number) => void>;

package/dist/builder/range.d.ts

@@ -3,8 +3,8 @@
  * Visible range detection, overscan application, and scroll-to-index positioning.
  */
 import type { Range } from "../types";
-import type { HeightCache } from "../rendering/heights";
-export declare const calcVisibleRange: (scrollTop: number, containerHeight: number, hc: HeightCache, totalItems: number, out: Range) => void;
+import type { SizeCache } from "../rendering/sizes";
+export declare const calcVisibleRange: (scrollPosition: number, containerHeight: number, hc: SizeCache, totalItems: number, out: Range) => void;
 export declare const applyOverscan: (visible: Range, overscan: number, totalItems: number, out: Range) => void;
-export declare const calcScrollToPosition: (index: number, hc: HeightCache, containerHeight: number, totalItems: number, align: "start" | "center" | "end") => number;
+export declare const calcScrollToPosition: (index: number, hc: SizeCache, containerHeight: number, totalItems: number, align: "start" | "center" | "end") => number;
 //# sourceMappingURL=range.d.ts.map

package/dist/builder/types.d.ts

@@ -3,7 +3,7 @@
  * Plugin interface, builder config, builder context, and return types
  */
 import type { VListItem, VListEvents, ItemConfig, ItemTemplate, Range, ViewportState, EventHandler, Unsubscribe, ScrollToOptions, ScrollSnapshot } from "../types";
-import type { DOMStructure, Renderer, HeightCache, CompressionContext } from "../rendering";
+import type { DOMStructure, Renderer, SizeCache, CompressionContext } from "../rendering";
 import type { CompressionState } from "../rendering/viewport";
 import type { SimpleDataManager } from "./data";
 import type { ScrollController } from "../features/scrollbar/controller";
@@ -23,11 +23,11 @@ export interface BuilderConfig<T extends VListItem = VListItem> {
     /** Accessible label for the listbox */
     ariaLabel?: string;
     /**
-     * Scroll direction (default: 'vertical')
+     * Layout orientation (default: 'vertical')
      * - 'vertical' — Standard top-to-bottom scrolling
      * - 'horizontal' — Left-to-right scrolling
      */
-    direction?: "vertical" | "horizontal";
+    orientation?: "vertical" | "horizontal";
     /** Reverse mode for chat UIs */
     reverse?: boolean;
     /** Scroll behavior configuration (non-scrollbar options) */
@@ -72,7 +72,7 @@ export interface BuilderState {
  */
 export interface BuilderContext<T extends VListItem = VListItem> {
     readonly dom: DOMStructure;
-    readonly heightCache: HeightCache;
+    readonly sizeCache: SizeCache;
     readonly emitter: Emitter<VListEvents<T>>;
     readonly config: ResolvedBuilderConfig;
     /** The raw user-provided builder config (for plugins that need original values) */
@@ -86,7 +86,7 @@ export interface BuilderContext<T extends VListItem = VListItem> {
      * scroll-triggered render. These are NOT on the hot path —
      * they run after DOM updates are complete.
      */
-    afterScroll: Array<(scrollTop: number, direction: string) => void>;
+    afterScroll: Array<(scrollPosition: number, direction: string) => void>;
     /**
      * Plugins register handlers for user interaction events.
      * These are attached as DOM event listeners during .build().
@@ -136,15 +136,14 @@ export interface BuilderContext<T extends VListItem = VListItem> {
      */
     setVirtualTotalFn(fn: () => number): void;
     /**
-     * Replace the effective height config.
-     * Used by groups plugin to inject grouped height function and by grid to add gap.
+     * Used by groups plugin to inject grouped size function and by grid to add gap.
      */
-    rebuildHeightCache(total?: number): void;
+    rebuildSizeCache(total?: number): void;
     /**
-     * Set a new effective height config function/value.
-     * Plugins that change heights (groups, grid) call this before rebuildHeightCache.
+     * Set a new effective size config function/value.
+     * Plugins that change sizes (groups, grid) call this before rebuildSizeCache.
      */
-    setHeightConfig(config: number | ((index: number) => number)): void;
+    setSizeConfig(config: number | ((index: number) => number)): void;
     /**
      * Update content size on the main axis (height for vertical, width for horizontal).
      */
@@ -158,12 +157,12 @@ export interface BuilderContext<T extends VListItem = VListItem> {
      * Replace the visible-range calculation function.
      * Used by withCompression to inject compressed range calculation.
      */
-    setVisibleRangeFn(fn: (scrollTop: number, containerHeight: number, hc: HeightCache, totalItems: number, out: Range) => void): void;
+    setVisibleRangeFn(fn: (scrollTop: number, containerHeight: number, sc: SizeCache, totalItems: number, out: Range) => void): void;
     /**
      * Replace the scroll-to-index position calculator.
      * Used by withCompression to inject compressed position calculation.
      */
-    setScrollToPosFn(fn: (index: number, hc: HeightCache, containerHeight: number, totalItems: number, align: "start" | "center" | "end") => number): void;
+    setScrollToPosFn(fn: (index: number, sc: SizeCache, containerHeight: number, totalItems: number, align: "start" | "center" | "end") => number): void;
     /**
      * Replace the item positioning function.
      * Used by withCompression to inject compressed item positioning.

package/dist/features/grid/plugin.d.ts

@@ -12,7 +12,7 @@
  * - CSS class — adds .vlist--grid to the root element
  *
  * Restrictions:
- * - Cannot be combined with direction: 'horizontal'
+ * - Cannot be combined with orientation: 'horizontal'
  * - Cannot be combined with reverse: true
  *
  * Can be combined with withGroups for grouped 2D layouts.

package/dist/features/grid/renderer.d.ts

@@ -3,18 +3,18 @@
  * Renders items in a 2D grid layout within the virtual scroll container.
  *
  * Extends the base renderer pattern but positions items using both
- * row offsets (translateY from the height cache) and column offsets
+ * row offsets (translateY from the size cache) and column offsets
  * (translateX calculated from column index and container width).
  *
  * Key differences from the list renderer:
  * - Items are positioned with translate(x, y) instead of just translateY(y)
  * - Item width is set to columnWidth (containerWidth / columns - gaps)
  * - The "index" in the rendered map is the FLAT ITEM INDEX (not row index)
- * - Row offsets come from the height cache (which operates on row indices)
+ * - Row offsets come from the size cache (which operates on row indices)
  * - Column offsets are calculated from itemIndex % columns
  */
 import type { VListItem, ItemTemplate, Range } from "../../types";
-import type { HeightCache } from "../../rendering/heights";
+import type { SizeCache } from "../../rendering/sizes";
 import type { CompressionContext } from "../../rendering/renderer";
 import type { GridLayout } from "./types";
 /** Grid renderer instance */
@@ -44,12 +44,12 @@ export interface GridRenderer<T extends VListItem = VListItem> {
  *
  * @param itemsContainer - The DOM element that holds rendered items
  * @param template - Item template function
- * @param heightCache - Height cache operating on ROW indices
+ * @param sizeCache - Size cache operating on ROW indices
  * @param gridLayout - Grid layout for row/col calculations
  * @param classPrefix - CSS class prefix
  * @param initialContainerWidth - Initial container width for column sizing
  * @param totalItemsGetter - Optional getter for total item count (for aria-setsize)
  * @param ariaIdPrefix - Optional unique prefix for element IDs (for aria-activedescendant)
  */
-export declare const createGridRenderer: <T extends VListItem = VListItem>(itemsContainer: HTMLElement, template: ItemTemplate<T>, heightCache: HeightCache, gridLayout: GridLayout, classPrefix: string, initialContainerWidth: number, totalItemsGetter?: () => number, ariaIdPrefix?: string) => GridRenderer<T>;
+export declare const createGridRenderer: <T extends VListItem = VListItem>(itemsContainer: HTMLElement, template: ItemTemplate<T>, sizeCache: SizeCache, gridLayout: GridLayout, classPrefix: string, initialContainerWidth: number, totalItemsGetter?: () => number, ariaIdPrefix?: string, isHorizontal?: boolean) => GridRenderer<T>;
 //# sourceMappingURL=renderer.d.ts.map

package/dist/features/page/plugin.d.ts

@@ -43,7 +43,7 @@ import type { VListPlugin } from "../../builder/types";
  * const timeline = vlist({
  *   container: '#timeline',
  *   item: { height: 100, template: renderEvent },
- *   direction: 'horizontal'
+ *   orientation: 'horizontal'
  * })
  * .use(withWindow())
  * .build()

package/dist/features/sections/index.d.ts

@@ -5,6 +5,6 @@
 export { withSections, type GroupsPluginConfig } from "./plugin";
 export type { GroupsConfig, GroupBoundary, LayoutEntry, GroupHeaderItem, GroupLayout, StickyHeader, } from "./types";
 export { isGroupHeader, isGroupHeader as isSectionHeader } from "./types";
-export { createGroupLayout, buildLayoutItems, createGroupedHeightFn, } from "./layout";
+export { createGroupLayout, buildLayoutItems, createGroupedSizeFn, } from "./layout";
 export { createStickyHeader } from "./sticky";
 //# sourceMappingURL=index.d.ts.map

package/dist/features/sections/layout.d.ts

@@ -25,14 +25,15 @@ import type { VListItem } from "../../types";
  */
 export declare const buildLayoutItems: <T extends VListItem>(items: T[], groups: readonly GroupBoundary[]) => Array<T | GroupHeaderItem>;
 /**
- * Create a height function for the layout that returns the correct height
- * for both group headers and data items.
+ * Create a size function for the layout (items + headers).
+ *
+ * Maps layout indices to sizes, accounting for both group headers and data items.
  *
  * @param layout - The group layout instance
- * @param itemHeight - Original item height config (number or function)
- * @returns A height function (layoutIndex) => number suitable for HeightCache
+ * @param itemSize - Original item size config (number or function)
+ * @returns A size function (layoutIndex) => number suitable for SizeCache
  */
-export declare const createGroupedHeightFn: (layout: GroupLayout, itemHeight: number | ((index: number) => number)) => ((layoutIndex: number) => number);
+export declare const createGroupedSizeFn: (layout: GroupLayout, itemSize: number | ((index: number) => number)) => ((layoutIndex: number) => number);
 /**
  * Create a GroupLayout instance.
  *

package/dist/features/sections/plugin.d.ts

@@ -14,11 +14,11 @@
  *
  * Restrictions:
  * - Items must be pre-sorted by group
- * - Cannot be combined with direction: 'horizontal'
  *
  * Can be combined with:
  * - withGrid for grouped 2D layouts
  * - reverse: true (sticky header shows current section as you scroll up through history)
+ * - orientation: 'horizontal' (sticky headers stick to left edge, push left when next header approaches)
  */
 import type { VListItem } from "../../types";
 import type { VListPlugin } from "../../builder/types";

package/dist/features/sections/sticky.d.ts

@@ -18,16 +18,17 @@
  *           └── .vlist-items
  */
 import type { GroupLayout, GroupsConfig, StickyHeader } from "./types";
-import type { HeightCache } from "../../rendering/heights";
+import type { SizeCache } from "../../rendering/sizes";
 /**
  * Create a sticky header manager.
  *
  * @param root - The vlist root element (.vlist) — sticky header is appended here
  * @param layout - Group layout for index/group resolution
- * @param heightCache - The LAYOUT height cache (includes headers)
+ * @param sizeCache - The LAYOUT size cache (includes headers)
  * @param config - Groups configuration (headerTemplate, headerHeight)
  * @param classPrefix - CSS class prefix (default: 'vlist')
+ * @param horizontal - Whether using horizontal scrolling mode
  * @returns StickyHeader instance
  */
-export declare const createStickyHeader: (root: HTMLElement, layout: GroupLayout, heightCache: HeightCache, config: GroupsConfig, classPrefix: string) => StickyHeader;
+export declare const createStickyHeader: (root: HTMLElement, layout: GroupLayout, sizeCache: SizeCache, config: GroupsConfig, classPrefix: string, horizontal?: boolean) => StickyHeader;
 //# sourceMappingURL=sticky.d.ts.map

package/dist/index.d.ts

@@ -16,9 +16,9 @@ export { withSelection } from "./features/selection";
 export { withSnapshots } from "./features/snapshots";
 export type { VList, VListConfig, VListItem, VListEvents, ItemTemplate, ItemState, SelectionMode, SelectionConfig, SelectionState, ScrollbarConfig, ScrollbarOptions, ScrollConfig, ScrollToOptions, ScrollSnapshot, VListAdapter, AdapterParams, AdapterResponse, Range, ViewportState, EventHandler, Unsubscribe, } from "./types";
 export type { VListBuilder, BuiltVList, BuilderConfig, VListPlugin, BuilderContext, } from "./builder";
-export { createGroupLayout as createSectionLayout, buildLayoutItems, createGroupedHeightFn as createSectionedHeightFn, createStickyHeader, isGroupHeader as isSectionHeader, type GroupsConfig as SectionsConfig, type GroupBoundary as SectionBoundary, type LayoutEntry, type GroupHeaderItem as SectionHeaderItem, type GroupLayout as SectionLayout, type StickyHeader, } from "./features/sections";
+export { createGroupLayout as createSectionLayout, buildLayoutItems, createGroupedSizeFn as createSectionedSizeFn, createStickyHeader, isGroupHeader as isSectionHeader, type GroupsConfig as SectionsConfig, type GroupBoundary as SectionBoundary, type LayoutEntry, type GroupHeaderItem as SectionHeaderItem, type GroupLayout as SectionLayout, type StickyHeader, } from "./features/sections";
 export { createGridLayout, createGridRenderer, type GridConfig, type GridLayout, type GridPosition, type GridRenderer, type ItemRange, } from "./features/grid";
-export { createHeightCache, type HeightCache, simpleVisibleRange, calculateRenderRange, calculateTotalHeight, calculateActualHeight, calculateItemOffset, calculateScrollToIndex, clampScrollPosition, rangesEqual, isInRange, getRangeCount, diffRanges, MAX_VIRTUAL_HEIGHT, getCompressionState as getScaleState, getCompression as getScale, needsCompression as needsScaling, getMaxItemsWithoutCompression as getMaxItemsWithoutScaling, getCompressionInfo as getScaleInfo, calculateCompressedVisibleRange as calculateScaledVisibleRange, calculateCompressedRenderRange as calculateScaledRenderRange, calculateCompressedItemPosition as calculateScaledItemPosition, calculateCompressedScrollToIndex as calculateScaledScrollToIndex, calculateIndexFromScrollPosition, type CompressionState as ScaleState, } from "./rendering";
+export { createSizeCache, type SizeCache, simpleVisibleRange, calculateRenderRange, calculateTotalSize, calculateActualSize, calculateItemOffset, calculateScrollToIndex, clampScrollPosition, rangesEqual, isInRange, getRangeCount, diffRanges, MAX_VIRTUAL_HEIGHT, getCompressionState as getScaleState, getCompression as getScale, needsCompression as needsScaling, getMaxItemsWithoutCompression as getMaxItemsWithoutScaling, getCompressionInfo as getScaleInfo, calculateCompressedVisibleRange as calculateScaledVisibleRange, calculateCompressedRenderRange as calculateScaledRenderRange, calculateCompressedItemPosition as calculateScaledItemPosition, calculateCompressedScrollToIndex as calculateScaledScrollToIndex, calculateIndexFromScrollPosition, type CompressionState as ScaleState, } from "./rendering";
 export { createSelectionState, selectItems, deselectItems, toggleSelection, selectAll, clearSelection, isSelected, getSelectedIds, getSelectedItems, } from "./features/selection";
 export { createEmitter, type Emitter } from "./events";
 export { createDataManager as createAsyncManager, createSparseStorage, createPlaceholderManager, isPlaceholderItem, filterPlaceholders, mergeRanges, calculateMissingRanges, type DataManager as AsyncManager, type SparseStorage, type PlaceholderManager, } from "./features/async";