vlist 1.9.1 → 2.0.0

package/dist/features/sortable/feature.d.ts

@@ -1,101 +0,0 @@
-/**
- * vlist/sortable - Builder Feature
- * Drag-and-drop reordering for virtual lists.
- *
- * Priority: 55 (runs after selection at 50, before scrollbar at 60)
- *
- * What it wires:
- * - Pointer event handlers on the items container for drag initiation
- * - Creates a drag ghost element that follows the pointer
- * - Items shift via CSS transforms to make room (like iOS list reordering)
- * - Auto-scrolls when dragging near viewport edges
- * - Keyboard reordering: Space to grab, arrows to move, Space to drop, Escape to cancel
- * - ARIA attributes (aria-roledescription, aria-describedby) and live region announcements
- * - Emits sort:start, sort:end, and sort:cancel events
- *
- * The feature is purely visual during drag — it does NOT reorder data.
- * On drop, it emits a `sort:end` event with `{ fromIndex, toIndex }`.
- * The consumer is responsible for reordering their data array and
- * calling `setItems()` with the new order.
- *
- * Keyboard reordering emits `sort:end` per arrow key press (incremental moves).
- * On Escape, it emits `sort:cancel` with `{ originalItems }` so the consumer
- * can restore the original order via `setItems(originalItems)`.
- *
- * When composed with withSelection, Space is intercepted for grab/drop.
- * Use Enter to toggle selection on focused items.
- *
- * IMPORTANT: vlist positions items via `style.transform: translateY(offset)`.
- * The shift must ADD to that existing offset, not replace it.
- *
- * Added methods: isSorting
- * Added events: sort:start, sort:end, sort:cancel
- */
-import type { VListItem } from "../../types";
-import type { VListFeature } from "../../builder/types";
-/** Sortable feature configuration */
-export interface SortableConfig {
-    /**
-     * CSS selector for the drag handle within each item.
-     * When set, only elements matching this selector initiate a drag.
-     * When omitted, the entire item is draggable.
-     *
-     * ```ts
-     * withSortable({ handle: '.drag-handle' })
-     * ```
-     */
-    handle?: string;
-    /**
-     * CSS class added to the drag ghost element (default: 'vlist-sort-ghost').
-     * The ghost is a clone of the dragged item that follows the pointer.
-     */
-    ghostClass?: string;
-    /**
-     * Transition duration for item shift animations in milliseconds (default: 150).
-     * Set to 0 for instant shifts.
-     */
-    shiftDuration?: number;
-    /**
-     * Size of the auto-scroll zone at viewport edges in pixels (default: 40).
-     * When the pointer enters this zone during drag, the list auto-scrolls.
-     */
-    edgeScrollZone?: number;
-    /**
-     * Auto-scroll speed in pixels per frame (default: 8).
-     */
-    edgeScrollSpeed?: number;
-    /**
-     * Minimum distance in pixels the pointer must move before drag starts (default: 5).
-     * Prevents accidental drags on click.
-     */
-    dragThreshold?: number;
-    /**
-     * Container element for the drag ghost (default: document.body).
-     * Set this to keep the ghost inside a specific ancestor so it inherits
-     * scoped CSS (e.g. theme variables, list-specific item styles).
-     */
-    ghostContainer?: HTMLElement;
-}
-/**
- * Create a sortable feature for the builder.
- *
- * Enables drag-and-drop reordering of items in the virtual list.
- *
- * ```ts
- * import { vlist } from 'vlist'
- * import { withSortable } from 'vlist/sortable'
- *
- * const list = vlist({ ... })
- *   .use(withSortable({ handle: '.drag-handle' }))
- *   .build()
- *
- * list.on('sort:end', ({ fromIndex, toIndex }) => {
- *   const reordered = [...items]
- *   const [moved] = reordered.splice(fromIndex, 1)
- *   reordered.splice(toIndex, 0, moved)
- *   list.setItems(reordered)
- * })
- * ```
- */
-export declare const withSortable: <T extends VListItem = VListItem>(config?: SortableConfig) => VListFeature<T>;
-//# sourceMappingURL=feature.d.ts.map

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

@@ -1,6 +0,0 @@
-/**
- * vlist - Sortable Domain
- * Drag-and-drop reordering for virtual lists
- */
-export { withSortable, type SortableConfig } from "./feature";
-//# sourceMappingURL=index.d.ts.map

package/dist/features/table/feature.d.ts

@@ -1,67 +0,0 @@
-/**
- * vlist/table - Builder Feature
- * Switches from list layout to a data table with columns, resizable headers,
- * sticky header row, and cell-based rendering.
- *
- * Priority: 10 (runs first — replaces the renderer before anything else renders)
- *
- * What it wires:
- * - Replaces render functions — swaps the core render loop with table-aware rendering
- * - Sticky header — creates a fixed header row above the viewport
- * - Column layout — manages column widths, offsets, and resize logic
- * - Resize interaction — drag handles on header column borders
- * - Sort events — click on sortable header emits column:sort
- * - Horizontal scroll sync — header scrolls in sync with the viewport
- * - CSS class — adds .vlist--table to the root element
- * - Variable row heights — supports fixed and function-based heights
- *
- * Critical design: This feature uses ctx.setRenderFns() to completely replace
- * the core's render loop, NOT ctx.replaceRenderer() which is a no-op in the
- * materialize context. This follows the same pattern as withGrid.
- *
- * Restrictions:
- * - Cannot be combined with withGrid or withMasonry (conflicting layout modes)
- * - Cannot be combined with orientation: 'horizontal' (tables are always vertical)
- *
- * Can be combined with:
- * - withSelection (row selection works as-is)
- * - withScrollbar (custom scrollbar)
- * - withAsync (async data loading)
- * - withSnapshots (scroll position save/restore)
- * - withScale (large dataset compression)
- */
-import type { VListItem } from "../../types";
-import type { VListFeature } from "../../builder/types";
-import type { TableConfig } from "./types";
-/** Table feature configuration — re-exported as TableFeatureConfig */
-export type TableFeatureConfig<T extends VListItem = VListItem> = TableConfig<T>;
-/**
- * Create a table feature for the builder.
- *
- * Switches from list layout to a data table with column headers, resizable
- * columns, and cell-based row rendering.
- *
- * ```ts
- * import { vlist } from 'vlist/builder'
- * import { withTable } from 'vlist/table'
- *
- * const table = vlist({
- *   container: '#my-table',
- *   item: { height: 40, template: () => '' },
- *   items: users,
- * })
- * .use(withTable({
- *   columns: [
- *     { key: 'name',   label: 'Name',   width: 200 },
- *     { key: 'email',  label: 'Email',  width: 300 },
- *     { key: 'role',   label: 'Role',   width: 120 },
- *   ],
- *   rowHeight: 40,
- *   headerHeight: 44,
- *   resizable: true,
- * }))
- * .build()
- * ```
- */
-export declare const withTable: <T extends VListItem = VListItem>(config: TableFeatureConfig<T>) => VListFeature<T>;
-//# sourceMappingURL=feature.d.ts.map

package/dist/features/transition/feature.d.ts

@@ -1,30 +0,0 @@
-/**
- * withTransition — FLIP-based enter/exit animations for insertItem and removeItem.
- *
- * Opt-in feature that replaces the immediate insert/remove with animated versions:
- * - removeItem: clone collapses via scaleY(0), siblings slide up
- * - insertItem: new element expands in, siblings slide down
- *
- * Without this feature, insert/remove are instantaneous.
- */
-import type { VListItem } from "../../types";
-import type { VListFeature } from "../../builder/types";
-/** Per-animation timing overrides. */
-export interface TransitionTiming {
-    /** Duration in ms */
-    duration?: number;
-    /** CSS easing function */
-    easing?: string;
-}
-export interface TransitionConfig {
-    /** Shared duration in ms (default: 200). Overridden by add/remove sub-configs. */
-    duration?: number;
-    /** Shared CSS easing (default: MD3 emphasized). Overridden by add/remove sub-configs. */
-    easing?: string;
-    /** Insert animation config, or `false` to disable. */
-    insert?: TransitionTiming | false;
-    /** Remove animation config, or `false` to disable. */
-    remove?: TransitionTiming | false;
-}
-export declare function withTransition<T extends VListItem = VListItem>(config?: TransitionConfig): VListFeature<T>;
-//# sourceMappingURL=feature.d.ts.map

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

@@ -1,9 +0,0 @@
-/**
- * vlist/transition — FLIP-based enter/exit animations
- * Opt-in animated add/remove for smooth list transitions
- *
- * Usage: import { withTransition } from 'vlist'
- */
-export { withTransition } from "./feature";
-export type { TransitionConfig, TransitionTiming } from "./feature";
-//# sourceMappingURL=index.d.ts.map