@floor/vlist 0.5.1

package/dist/adapters/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * vlist adapters — Framework integration wrappers
+ *
+ * Each adapter is exported from its own subpath for tree-shaking:
+ *   - `vlist/react`  — React hook
+ *   - `vlist/vue`    — Vue 3 composable
+ *   - `vlist/svelte` — Svelte action
+ *
+ * This barrel file is NOT intended for direct import.
+ * Import from the framework-specific subpath instead.
+ *
+ * @packageDocumentation
+ */
+export { useVList as useVListReact, useVListEvent } from "./react";
+export type { UseVListConfig as UseVListConfigReact, UseVListReturn as UseVListReturnReact, } from "./react";
+export { useVList as useVListVue, useVListEvent as useVListEventVue } from "./vue";
+export type { UseVListConfig as UseVListConfigVue, UseVListConfigInput as UseVListConfigInputVue, UseVListReturn as UseVListReturnVue, } from "./vue";
+export { vlist, onVListEvent } from "./svelte";
+export type { VListActionConfig, VListActionOptions, VListActionReturn, OnInstanceCallback, } from "./svelte";
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAE,QAAQ,IAAI,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnE,YAAY,EACV,cAAc,IAAI,mBAAmB,EACrC,cAAc,IAAI,mBAAmB,GACtC,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,QAAQ,IAAI,WAAW,EAAE,aAAa,IAAI,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACnF,YAAY,EACV,cAAc,IAAI,iBAAiB,EACnC,mBAAmB,IAAI,sBAAsB,EAC7C,cAAc,IAAI,iBAAiB,GACpC,MAAM,OAAO,CAAC;AAGf,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC/C,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,UAAU,CAAC"}

package/dist/adapters/react.d.ts

@@ -0,0 +1,119 @@
+/**
+ * vlist/react — Thin React wrapper for vlist
+ *
+ * Provides a `useVList` hook that manages the vlist lifecycle
+ * within React's component model. The hook creates a vlist instance
+ * on mount, syncs items reactively, and destroys on unmount.
+ *
+ * @packageDocumentation
+ */
+import type { VListConfig, VListItem, VList, VListEvents, EventHandler } from "vlist";
+/** Configuration for useVList (VListConfig without container) */
+export type UseVListConfig<T extends VListItem = VListItem> = Omit<VListConfig<T>, "container">;
+/** Return value from the useVList hook */
+export interface UseVListReturn<T extends VListItem = VListItem> {
+    /**
+     * Ref to attach to your container element.
+     *
+     * ```tsx
+     * const { containerRef } = useVList(config);
+     * return <div ref={containerRef} style={{ height: 400 }} />;
+     * ```
+     */
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    /**
+     * Ref holding the underlying vlist instance.
+     * Populated after mount, `null` before.
+     *
+     * Use `.current` to access vlist methods:
+     * ```tsx
+     * const handleJump = () => instanceRef.current?.scrollToIndex(100);
+     * ```
+     */
+    instanceRef: React.RefObject<VList<T> | null>;
+    /**
+     * Stable helper to get the vlist instance (or null).
+     * Convenient for inline usage without `.current`:
+     * ```tsx
+     * onClick={() => getInstance()?.scrollToIndex(0)}
+     * ```
+     */
+    getInstance: () => VList<T> | null;
+}
+/**
+ * React hook for vlist integration.
+ *
+ * Creates a virtual list instance bound to a container ref.
+ * The instance is created on mount and destroyed on unmount.
+ * When `config.items` changes (by reference), items are synced automatically.
+ *
+ * **Usage:**
+ * ```tsx
+ * import { useVList } from 'vlist/react';
+ *
+ * function UserList({ users }) {
+ *   const { containerRef, instanceRef } = useVList({
+ *     item: {
+ *       height: 48,
+ *       template: (user) => `<div class="user">${user.name}</div>`,
+ *     },
+ *     items: users,
+ *     selection: { mode: 'single' },
+ *   });
+ *
+ *   return (
+ *     <div
+ *       ref={containerRef}
+ *       style={{ height: 400 }}
+ *       onClick={() => {
+ *         const selected = instanceRef.current?.getSelected();
+ *         console.log('Selected:', selected);
+ *       }}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * **With adapter (async/infinite scroll):**
+ * ```tsx
+ * const { containerRef } = useVList({
+ *   item: {
+ *     height: 64,
+ *     template: (item) => `<div>${item.title}</div>`,
+ *   },
+ *   adapter: {
+ *     read: async ({ offset, limit }) => {
+ *       const res = await fetch(`/api/items?offset=${offset}&limit=${limit}`);
+ *       const data = await res.json();
+ *       return { items: data.items, total: data.total };
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @param config - VList configuration (without `container`)
+ * @returns containerRef, instanceRef, and getInstance helper
+ */
+export declare function useVList<T extends VListItem = VListItem>(config: UseVListConfig<T>): UseVListReturn<T>;
+/**
+ * Subscribe to a vlist event within React's lifecycle.
+ * Automatically unsubscribes on unmount or when the handler changes.
+ *
+ * ```tsx
+ * const { instanceRef } = useVList(config);
+ *
+ * useVListEvent(instanceRef, 'selection:change', ({ selected }) => {
+ *   console.log('Selected items:', selected);
+ * });
+ *
+ * useVListEvent(instanceRef, 'scroll', ({ scrollTop, direction }) => {
+ *   console.log(`Scrolling ${direction} at ${scrollTop}px`);
+ * });
+ * ```
+ *
+ * @param instanceRef - Ref to the vlist instance (from useVList)
+ * @param event - Event name
+ * @param handler - Event handler
+ */
+export declare function useVListEvent<T extends VListItem, K extends keyof VListEvents<T>>(instanceRef: React.RefObject<VList<T> | null>, event: K, handler: EventHandler<VListEvents<T>[K]>): void;
+//# sourceMappingURL=react.d.ts.map

package/dist/adapters/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/adapters/react.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,KAAK,EACL,WAAW,EACX,YAAY,EAEb,MAAM,OAAO,CAAC;AAMf,iEAAiE;AACjE,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,IAAI,CAChE,WAAW,CAAC,CAAC,CAAC,EACd,WAAW,CACZ,CAAC;AAEF,0CAA0C;AAC1C,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC7D;;;;;;;OAOG;IACH,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAErD;;;;;;;;OAQG;IACH,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAE9C;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CACpC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACtD,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,GACxB,cAAc,CAAC,CAAC,CAAC,CAqDnB;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,MAAM,WAAW,CAAC,CAAC,CAAC,EAE9B,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAC7C,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACvC,IAAI,CAmBN"}

package/dist/adapters/svelte.d.ts

@@ -0,0 +1,198 @@
+/**
+ * vlist/svelte — Thin Svelte wrapper for vlist
+ *
+ * Provides a `vlist` action that manages the vlist lifecycle
+ * within Svelte's component model. The action creates a vlist instance
+ * when the element mounts, syncs items on update, and destroys on unmount.
+ *
+ * Works with both Svelte 4 and Svelte 5 (actions are framework-stable).
+ * No Svelte imports needed — actions are plain functions.
+ *
+ * @packageDocumentation
+ */
+import type { VListConfig, VListItem, VList, VListEvents, EventHandler, Unsubscribe } from "vlist";
+/** Configuration for the vlist action (VListConfig without container) */
+export type VListActionConfig<T extends VListItem = VListItem> = Omit<VListConfig<T>, "container">;
+/**
+ * Callback invoked once the vlist instance is ready.
+ * Use this to subscribe to events, call methods, or store a reference.
+ */
+export type OnInstanceCallback<T extends VListItem = VListItem> = (instance: VList<T>) => void;
+/** Full options passed to the vlist action */
+export interface VListActionOptions<T extends VListItem = VListItem> {
+    /** VList configuration (without container) */
+    config: VListActionConfig<T>;
+    /**
+     * Called once the instance is created (on mount).
+     * Use this to get a reference to the vlist instance for calling methods.
+     *
+     * ```svelte
+     * <script>
+     *   let vlistInstance;
+     *   const options = {
+     *     config: { ... },
+     *     onInstance: (inst) => { vlistInstance = inst; },
+     *   };
+     * </script>
+     * <div use:vlist={options} />
+     * <button on:click={() => vlistInstance?.scrollToIndex(0)}>Top</button>
+     * ```
+     */
+    onInstance?: OnInstanceCallback<T>;
+}
+/** Svelte action return type */
+export interface VListActionReturn<T extends VListItem = VListItem> {
+    /** Called by Svelte when the action parameter changes */
+    update?: (newOptions: VListActionOptions<T>) => void;
+    /** Called by Svelte when the element is removed from the DOM */
+    destroy?: () => void;
+}
+/**
+ * Svelte action for vlist integration.
+ *
+ * Attaches a virtual list to the target element. The list is created
+ * when the element mounts and destroyed when it unmounts. Passing
+ * new options via Svelte's reactivity triggers an update.
+ *
+ * **Basic usage:**
+ * ```svelte
+ * <script>
+ *   import { vlist } from 'vlist/svelte';
+ *
+ *   const users = [
+ *     { id: 1, name: 'Alice' },
+ *     { id: 2, name: 'Bob' },
+ *   ];
+ *
+ *   const options = {
+ *     config: {
+ *       item: {
+ *         height: 48,
+ *         template: (user) => `<div class="user">${user.name}</div>`,
+ *       },
+ *       items: users,
+ *     },
+ *   };
+ * </script>
+ *
+ * <div use:vlist={options} style="height: 400px" />
+ * ```
+ *
+ * **With instance access (for methods):**
+ * ```svelte
+ * <script>
+ *   import { vlist } from 'vlist/svelte';
+ *
+ *   let instance;
+ *
+ *   const options = {
+ *     config: {
+ *       item: {
+ *         height: 48,
+ *         template: (item) => `<div>${item.name}</div>`,
+ *       },
+ *       items: users,
+ *       selection: { mode: 'single' },
+ *     },
+ *     onInstance: (inst) => { instance = inst; },
+ *   };
+ *
+ *   function jumpToTop() {
+ *     instance?.scrollToIndex(0);
+ *   }
+ * </script>
+ *
+ * <div use:vlist={options} style="height: 400px" />
+ * <button on:click={jumpToTop}>Jump to top</button>
+ * ```
+ *
+ * **Reactive items (Svelte 4):**
+ * ```svelte
+ * <script>
+ *   import { vlist } from 'vlist/svelte';
+ *
+ *   let users = [...];
+ *
+ *   // Svelte re-runs the action's update when this object changes
+ *   $: options = {
+ *     config: {
+ *       item: { height: 48, template: (u) => `<div>${u.name}</div>` },
+ *       items: users,
+ *     },
+ *   };
+ * </script>
+ *
+ * <div use:vlist={options} style="height: 400px" />
+ * ```
+ *
+ * **With adapter (async/infinite scroll):**
+ * ```svelte
+ * <script>
+ *   import { vlist } from 'vlist/svelte';
+ *
+ *   const options = {
+ *     config: {
+ *       item: {
+ *         height: 64,
+ *         template: (item) => `<div>${item.title}</div>`,
+ *       },
+ *       adapter: {
+ *         read: async ({ offset, limit }) => {
+ *           const res = await fetch(`/api/items?offset=${offset}&limit=${limit}`);
+ *           const data = await res.json();
+ *           return { items: data.items, total: data.total };
+ *         },
+ *       },
+ *     },
+ *   };
+ * </script>
+ *
+ * <div use:vlist={options} style="height: 400px" />
+ * ```
+ *
+ * @param node - The DOM element Svelte binds the action to
+ * @param options - Configuration and callbacks
+ * @returns Action lifecycle object (update + destroy)
+ */
+export declare function vlist<T extends VListItem = VListItem>(node: HTMLElement, options: VListActionOptions<T>): VListActionReturn<T>;
+/**
+ * Helper to subscribe to vlist events with automatic cleanup.
+ * Returns an unsubscribe function.
+ *
+ * ```svelte
+ * <script>
+ *   import { vlist, onVListEvent } from 'vlist/svelte';
+ *   import { onDestroy } from 'svelte';
+ *
+ *   let instance;
+ *   let unsubs = [];
+ *
+ *   function handleInstance(inst) {
+ *     instance = inst;
+ *
+ *     unsubs.push(
+ *       onVListEvent(inst, 'selection:change', ({ selected }) => {
+ *         console.log('Selected:', selected);
+ *       })
+ *     );
+ *
+ *     unsubs.push(
+ *       onVListEvent(inst, 'scroll', ({ scrollTop, direction }) => {
+ *         console.log(`Scrolling ${direction} at ${scrollTop}px`);
+ *       })
+ *     );
+ *   }
+ *
+ *   onDestroy(() => unsubs.forEach(fn => fn()));
+ * </script>
+ *
+ * <div use:vlist={{ config, onInstance: handleInstance }} />
+ * ```
+ *
+ * @param instance - The vlist instance
+ * @param event - Event name
+ * @param handler - Event handler
+ * @returns Unsubscribe function
+ */
+export declare function onVListEvent<T extends VListItem, K extends keyof VListEvents<T>>(instance: VList<T>, event: K, handler: EventHandler<VListEvents<T>[K]>): Unsubscribe;
+//# sourceMappingURL=svelte.d.ts.map

package/dist/adapters/svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte.d.ts","sourceRoot":"","sources":["../../src/adapters/svelte.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,KAAK,EACL,WAAW,EACX,YAAY,EACZ,WAAW,EACZ,MAAM,OAAO,CAAC;AAMf,yEAAyE;AACzE,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,IAAI,CACnE,WAAW,CAAC,CAAC,CAAC,EACd,WAAW,CACZ,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,CAChE,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,KACf,IAAI,CAAC;AAEV,8CAA8C;AAC9C,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACjE,8CAA8C;IAC9C,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAE7B;;;;;;;;;;;;;;;OAeG;IACH,UAAU,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;CACpC;AAED,gCAAgC;AAChC,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAChE,yDAAyD;IACzD,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAErD,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACnD,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC7B,iBAAiB,CAAC,CAAC,CAAC,CA4BtB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,YAAY,CAC1B,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,MAAM,WAAW,CAAC,CAAC,CAAC,EAE9B,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,EAClB,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACvC,WAAW,CAEb"}

package/dist/adapters/vue.d.ts

@@ -0,0 +1,151 @@
+/**
+ * vlist/vue — Thin Vue 3 wrapper for vlist
+ *
+ * Provides a `useVList` composable that manages the vlist lifecycle
+ * within Vue's composition API. The composable creates a vlist instance
+ * on mount, syncs items reactively, and destroys on unmount.
+ *
+ * @packageDocumentation
+ */
+import { type Ref, type ShallowRef } from "vue";
+import type { VListConfig, VListItem, VList, VListEvents, EventHandler } from "vlist";
+/** Configuration for useVList (VListConfig without container) */
+export type UseVListConfig<T extends VListItem = VListItem> = Omit<VListConfig<T>, "container">;
+/** Accepted config input — plain object or reactive ref */
+export type UseVListConfigInput<T extends VListItem = VListItem> = UseVListConfig<T> | Ref<UseVListConfig<T>>;
+/** Return value from the useVList composable */
+export interface UseVListReturn<T extends VListItem = VListItem> {
+    /**
+     * Template ref to bind to your container element.
+     *
+     * ```vue
+     * <template>
+     *   <div ref="containerRef" style="height: 400px" />
+     * </template>
+     *
+     * <script setup>
+     * const { containerRef } = useVList(config);
+     * </script>
+     * ```
+     */
+    containerRef: Ref<HTMLElement | null>;
+    /**
+     * Shallow ref holding the underlying vlist instance.
+     * Populated after mount, `null` before.
+     *
+     * ```vue
+     * <script setup>
+     * const { instance } = useVList(config);
+     *
+     * function jumpToTop() {
+     *   instance.value?.scrollToIndex(0);
+     * }
+     * </script>
+     * ```
+     */
+    instance: ShallowRef<VList<T> | null>;
+}
+/**
+ * Vue 3 composable for vlist integration.
+ *
+ * Creates a virtual list instance bound to a template ref.
+ * The instance is created on mount and destroyed on unmount.
+ * When items change (detected via `watch`), they are synced automatically.
+ *
+ * **Basic usage:**
+ * ```vue
+ * <template>
+ *   <div ref="containerRef" style="height: 400px" />
+ * </template>
+ *
+ * <script setup lang="ts">
+ * import { useVList } from 'vlist/vue';
+ * import { ref } from 'vue';
+ *
+ * const users = ref([
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ * ]);
+ *
+ * const { containerRef, instance } = useVList({
+ *   item: {
+ *     height: 48,
+ *     template: (user) => `<div class="user">${user.name}</div>`,
+ *   },
+ *   items: users.value,
+ * });
+ * </script>
+ * ```
+ *
+ * **With reactive config (auto-syncs items):**
+ * ```vue
+ * <script setup lang="ts">
+ * import { useVList } from 'vlist/vue';
+ * import { computed, ref } from 'vue';
+ *
+ * const filter = ref('');
+ * const allUsers = ref([...]);
+ *
+ * const config = computed(() => ({
+ *   item: {
+ *     height: 48,
+ *     template: (user) => `<div>${user.name}</div>`,
+ *   },
+ *   items: allUsers.value.filter(u =>
+ *     u.name.includes(filter.value)
+ *   ),
+ * }));
+ *
+ * const { containerRef, instance } = useVList(config);
+ * </script>
+ * ```
+ *
+ * **With adapter (async/infinite scroll):**
+ * ```vue
+ * <script setup lang="ts">
+ * const { containerRef } = useVList({
+ *   item: {
+ *     height: 64,
+ *     template: (item) => `<div>${item.title}</div>`,
+ *   },
+ *   adapter: {
+ *     read: async ({ offset, limit }) => {
+ *       const res = await fetch(`/api/items?offset=${offset}&limit=${limit}`);
+ *       const data = await res.json();
+ *       return { items: data.items, total: data.total };
+ *     },
+ *   },
+ * });
+ * </script>
+ * ```
+ *
+ * @param configInput - VList configuration (without `container`), plain or reactive
+ * @returns containerRef and reactive instance ref
+ */
+export declare function useVList<T extends VListItem = VListItem>(configInput: UseVListConfigInput<T>): UseVListReturn<T>;
+/**
+ * Subscribe to a vlist event within Vue's lifecycle.
+ * Automatically unsubscribes on unmount.
+ *
+ * ```vue
+ * <script setup lang="ts">
+ * import { useVList, useVListEvent } from 'vlist/vue';
+ *
+ * const { containerRef, instance } = useVList(config);
+ *
+ * useVListEvent(instance, 'selection:change', ({ selected }) => {
+ *   console.log('Selected items:', selected);
+ * });
+ *
+ * useVListEvent(instance, 'scroll', ({ scrollTop, direction }) => {
+ *   console.log(`Scrolling ${direction} at ${scrollTop}px`);
+ * });
+ * </script>
+ * ```
+ *
+ * @param instance - Shallow ref to the vlist instance (from useVList)
+ * @param event - Event name
+ * @param handler - Event handler
+ */
+export declare function useVListEvent<T extends VListItem, K extends keyof VListEvents<T>>(instance: ShallowRef<VList<T> | null>, event: K, handler: EventHandler<VListEvents<T>[K]>): void;
+//# sourceMappingURL=vue.d.ts.map

package/dist/adapters/vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vue.d.ts","sourceRoot":"","sources":["../../src/adapters/vue.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAEH,OAAO,EAQL,KAAK,GAAG,EACR,KAAK,UAAU,EAChB,MAAM,KAAK,CAAC;AAEb,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACT,KAAK,EACL,WAAW,EACX,YAAY,EAEb,MAAM,OAAO,CAAC;AAMf,iEAAiE;AACjE,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,IAAI,CAChE,WAAW,CAAC,CAAC,CAAC,EACd,WAAW,CACZ,CAAC;AAEF,2DAA2D;AAC3D,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAC3D,cAAc,CAAC,CAAC,CAAC,GACjB,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3B,gDAAgD;AAChD,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC7D;;;;;;;;;;;;OAYG;IACH,YAAY,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;;OAaG;IACH,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;CACvC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACtD,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAClC,cAAc,CAAC,CAAC,CAAC,CAwCnB;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CAC3B,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,MAAM,WAAW,CAAC,CAAC,CAAC,EAE9B,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EACrC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GACvC,IAAI,CA4BN"}

package/dist/builder/context.d.ts

@@ -0,0 +1,36 @@
+/**
+ * vlist/builder - BuilderContext Factory
+ * Central state container that plugins receive during setup.
+ *
+ * The BuilderContext provides access to all core components plus
+ * registration points for handlers, methods, and cleanup callbacks.
+ */
+import type { VListItem, VListEvents } from "../types";
+import type { HeightCache } from "../render/heights";
+import type { Renderer, DOMStructure } from "../render/renderer";
+import type { SimpleDataManager } from "./data";
+import type { ScrollController } from "../scroll/controller";
+import type { Emitter } from "../events/emitter";
+import type { BuilderConfig, BuilderContext, BuilderState, ResolvedBuilderConfig } from "./types";
+/** Options for creating a BuilderContext */
+export interface CreateBuilderContextOptions<T extends VListItem = VListItem> {
+    rawConfig: BuilderConfig<T>;
+    resolvedConfig: ResolvedBuilderConfig;
+    dom: DOMStructure;
+    heightCache: HeightCache;
+    dataManager: SimpleDataManager<T>;
+    scrollController: ScrollController;
+    renderer: Renderer<T>;
+    emitter: Emitter<VListEvents<T>>;
+    initialState: BuilderState;
+    initialHeightConfig: number | ((index: number) => number);
+}
+/**
+ * Create a BuilderContext from individual components.
+ *
+ * The context acts as the central hub that plugins wire into.
+ * Unlike VListContext (used by the monolithic factory), BuilderContext
+ * exposes registration arrays and replacement methods for plugins.
+ */
+export declare const createBuilderContext: <T extends VListItem = VListItem>(options: CreateBuilderContextOptions<T>) => BuilderContext<T>;
+//# sourceMappingURL=context.d.ts.map

package/dist/builder/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/builder/context.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAuB,MAAM,UAAU,CAAC;AAG5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EACV,QAAQ,EACR,YAAY,EAEb,MAAM,oBAAoB,CAAC;AAU5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,YAAY,EACZ,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAMjB,4CAA4C;AAC5C,MAAM,WAAW,2BAA2B,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC1E,SAAS,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IAC5B,cAAc,EAAE,qBAAqB,CAAC;IACtC,GAAG,EAAE,YAAY,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAClC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,YAAY,EAAE,YAAY,CAAC;IAC3B,mBAAmB,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;CAC3D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,SAAS,GAAG,SAAS,EAClE,SAAS,2BAA2B,CAAC,CAAC,CAAC,KACtC,cAAc,CAAC,CAAC,CA+SlB,CAAC"}

package/dist/builder/core.d.ts

@@ -0,0 +1,16 @@
+/**
+ * vlist/builder — Self-contained composable virtual list builder
+ *
+ * Everything inlined — height cache, emitter, DOM, element pool, renderer,
+ * range calculations, scroll handling. Zero module imports means the builder
+ * core is ~12 KB minified instead of ~25 KB.
+ *
+ * Plugins compose features *around* the hot path via extension points:
+ * afterScroll, clickHandlers, keydownHandlers, resizeHandlers, destroyHandlers,
+ * and the methods Map for public API extension.
+ */
+import type { VListItem } from "../types";
+import type { BuilderConfig, VListBuilder } from "./types";
+export type { CompressionState } from "../render/virtual";
+export declare const vlist: <T extends VListItem = VListItem>(config: BuilderConfig<T>) => VListBuilder<T>;
+//# sourceMappingURL=core.d.ts.map

package/dist/builder/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../src/builder/core.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,SAAS,EAOV,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EACV,aAAa,EAKb,YAAY,EAGb,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAqb1D,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,SAAS,GAAG,SAAS,EACnD,QAAQ,aAAa,CAAC,CAAC,CAAC,KACvB,YAAY,CAAC,CAAC,CAoEhB,CAAC"}

package/dist/builder/data.d.ts

@@ -0,0 +1,71 @@
+/**
+ * vlist/builder - Lightweight In-Memory Data Manager
+ *
+ * A minimal data manager that stores items in a plain array.
+ * No sparse storage, no placeholders, no async adapter support.
+ *
+ * This keeps the builder core small (~12 KB). When the user installs
+ * withData(), that plugin replaces this manager with the full
+ * adapter-backed data manager from src/data/manager.ts.
+ */
+import type { VListItem, Range } from "../types";
+/** Minimal data state */
+export interface SimpleDataState<_T extends VListItem = VListItem> {
+    total: number;
+    cached: number;
+    isLoading: boolean;
+    pendingRanges: Range[];
+    error: Error | undefined;
+    hasMore: boolean;
+    cursor: string | undefined;
+}
+/**
+ * SimpleDataManager — the same interface as the full DataManager,
+ * but backed by a plain array instead of sparse storage + placeholders.
+ *
+ * Only the methods used by the builder core and plugins are implemented.
+ * Adapter-related methods (loadRange, ensureRange, loadInitial, loadMore,
+ * reload, evictDistant) are no-ops or stubs.
+ */
+export interface SimpleDataManager<T extends VListItem = VListItem> {
+    getState: () => SimpleDataState<T>;
+    getTotal: () => number;
+    getCached: () => number;
+    getIsLoading: () => boolean;
+    getHasMore: () => boolean;
+    getStorage: () => unknown;
+    getPlaceholders: () => unknown;
+    getItem: (index: number) => T | undefined;
+    getItemById: (id: string | number) => T | undefined;
+    getIndexById: (id: string | number) => number;
+    isItemLoaded: (index: number) => boolean;
+    getItemsInRange: (start: number, end: number) => T[];
+    setTotal: (total: number) => void;
+    setItems: (items: T[], offset?: number, total?: number) => void;
+    updateItem: (id: string | number, updates: Partial<T>) => boolean;
+    removeItem: (id: string | number) => boolean;
+    loadRange: (start: number, end: number) => Promise<void>;
+    ensureRange: (start: number, end: number) => Promise<void>;
+    loadInitial: () => Promise<void>;
+    loadMore: () => Promise<boolean>;
+    reload: () => Promise<void>;
+    evictDistant: (visibleStart: number, visibleEnd: number) => void;
+    clear: () => void;
+    reset: () => void;
+}
+export interface SimpleDataManagerConfig<T extends VListItem = VListItem> {
+    initialItems?: T[];
+    initialTotal?: number;
+    onStateChange?: (state: SimpleDataState<T>) => void;
+    onItemsLoaded?: (items: T[], offset: number, total: number) => void;
+}
+/**
+ * Create a lightweight in-memory data manager.
+ *
+ * Items are stored in a plain array. ID lookups use a Map.
+ * No sparse storage, no placeholders, no chunking, no eviction.
+ *
+ * ~1 KB minified vs ~8 KB for the full data manager.
+ */
+export declare const createSimpleDataManager: <T extends VListItem = VListItem>(config?: SimpleDataManagerConfig<T>) => SimpleDataManager<T>;
+//# sourceMappingURL=data.d.ts.map

package/dist/builder/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../src/builder/data.ts"],"names":[],"mappings":"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"}

package/dist/builder/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * vlist/builder - Composable Virtual List Builder
+ * Pick only the features you need, pay only for what you ship.
+ *
+ * @example
+ * ```ts
+ * import { vlist } from 'vlist/builder'
+ * import { withSelection } from 'vlist/selection'
+ * import { withScrollbar } from 'vlist/scroll'
+ *
+ * const list = vlist({
+ *   container: '#app',
+ *   item: { height: 48, template: renderItem },
+ *   items: data,
+ * })
+ * .use(withSelection({ mode: 'multiple' }))
+ * .use(withScrollbar())
+ * .build()
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { vlist } from "./core";
+export type { VListBuilder, BuiltVList, BuilderConfig, VListPlugin, BuilderContext, ResolvedBuilderConfig, BuilderState, CachedCompression, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/builder/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/builder/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAGH,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAG/B,YAAY,EAEV,YAAY,EACZ,UAAU,EACV,aAAa,EAGb,WAAW,EACX,cAAc,EAGd,qBAAqB,EACrB,YAAY,EACZ,iBAAiB,GAClB,MAAM,SAAS,CAAC"}