@tanstack/marko-virtual 3.14.2 → 3.15.0

package/dist/esm/tags/window-virtualizer/options.d.ts

@@ -1,13 +1,44 @@
-import { VirtualizerOptions } from '@tanstack/virtual-core';
+import { Virtualizer, Range, VirtualItem, VirtualizerOptions } from '@tanstack/virtual-core';
 export interface WindowVirtualizerInput {
     count: number;
     estimateSize?: (index: number) => number;
     overscan?: number;
+    horizontal?: boolean;
     paddingStart?: number;
     paddingEnd?: number;
     scrollPaddingStart?: number;
     scrollPaddingEnd?: number;
     gap?: number;
     lanes?: number;
+    initialOffset?: number | (() => number);
+    initialRect?: {
+        width: number;
+        height: number;
+    };
+    getItemKey?: (index: number) => number | string | bigint;
+    rangeExtractor?: (range: Range) => Array<number>;
+    indexAttribute?: string;
+    initialMeasurementsCache?: Array<VirtualItem>;
+    anchorTo?: 'start' | 'end';
+    followOnAppend?: boolean | ScrollBehavior;
+    scrollEndThreshold?: number;
+    scrollMargin?: number;
+    enabled?: boolean;
+    isRtl?: boolean;
+    isScrollingResetDelay?: number;
+    useScrollendEvent?: boolean;
+    useAnimationFrameWithResizeObserver?: boolean;
+    laneAssignmentMode?: 'estimate' | 'measured';
+    useCachedMeasurements?: boolean;
+    debug?: boolean;
+    measureElement?: (element: Element, entry: ResizeObserverEntry | undefined, instance: Virtualizer<Window, Element>) => number;
 }
 export declare function buildOptions(input: WindowVirtualizerInput, notify: () => void): VirtualizerOptions<Window, Element>;
+export declare function renderSlice(input: WindowVirtualizerInput): {
+    items: Array<VirtualItem>;
+    size: number;
+    range: {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+};

package/dist/tags/virtualizer/index.d.marko

@@ -0,0 +1,56 @@
+import { Virtualizer } from "@tanstack/virtual-core";
+import type { Range, VirtualItem, ScrollToOptions } from "@tanstack/virtual-core";
+export interface VirtualizerHandle {
+    virtualItems: VirtualItem[];
+    totalSize: number;
+    range: {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+    measureElement: ((el: Element | null) => void) | undefined;
+    scrollToIndex: (index: number, options?: ScrollToOptions) => void;
+    scrollToOffset: (offset: number, options?: ScrollToOptions) => void;
+    measure: () => void;
+    resizeItem: (index: number, size: number) => void;
+    scrollToEnd: (options?: {
+        behavior?: ScrollToOptions['behavior'];
+    }) => void;
+    isAtEnd: (threshold?: number) => boolean;
+    getDistanceFromEnd: () => number;
+}
+export interface Input {
+    count: number;
+    estimateSize?: (index: number) => number;
+    getScrollElement: () => Element | null;
+    overscan?: number;
+    horizontal?: boolean;
+    paddingStart?: number;
+    paddingEnd?: number;
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
+    gap?: number;
+    lanes?: number;
+    initialOffset?: number | (() => number);
+    initialRect?: {
+        width: number;
+        height: number;
+    };
+    getItemKey?: (index: number) => number | string | bigint;
+    rangeExtractor?: (range: Range) => number[];
+    indexAttribute?: string;
+    initialMeasurementsCache?: VirtualItem[];
+    anchorTo?: 'start' | 'end';
+    followOnAppend?: boolean | ScrollBehavior;
+    scrollEndThreshold?: number;
+    scrollMargin?: number;
+    enabled?: boolean;
+    isRtl?: boolean;
+    isScrollingResetDelay?: number;
+    useScrollendEvent?: boolean;
+    useAnimationFrameWithResizeObserver?: boolean;
+    laneAssignmentMode?: 'estimate' | 'measured';
+    useCachedMeasurements?: boolean;
+    debug?: boolean;
+    measureElement?: (element: Element, entry: ResizeObserverEntry | undefined, instance: Virtualizer<Element, Element>) => number;
+}
+<return = (1 as any as VirtualizerHandle)/>

package/dist/tags/virtualizer/index.marko

@@ -0,0 +1,59 @@
+import { Virtualizer } from "@tanstack/virtual-core";
+import { buildOptions, renderSlice } from "./options.js";
+<!-- Render-time seed: derive the initial window as plain data via a transient virtual-core-->
+<!-- instance (see renderSlice in ./options). On the server this paints the initial slice into-->
+<!-- the HTML (when `initialRect` is given) or an empty container with the correct total height-->
+<!-- (when it is not) — no <if=mounted> guard. The values serialize and recompute identically on-->
+<!-- resume. The live, observing instance is then built client-only in onMount and takes over.-->
+<const/seed=renderSlice(input)/>
+<let/items=seed.items/>
+<let/size=seed.size/>
+<let/range=seed.range/>
+<let/v=null/>
+<let/cleanup=null/>
+<lifecycle<{}> onMount() {
+  const notify = () => {
+    const inst = v;
+    if (!inst) return;
+    items = inst.getVirtualItems();
+    size = inst.getTotalSize();
+    range = inst.range;
+  };
+  v = new Virtualizer(buildOptions(input, notify));
+  cleanup = v._didMount();
+  v._willUpdate();
+  notify();
+} onUpdate() {
+  const current = v;
+  if (!current) return;
+  const notify = () => {
+    const inst = v;
+    if (!inst) return;
+    items = inst.getVirtualItems();
+    size = inst.getTotalSize();
+    range = inst.range;
+  };
+  current.setOptions({
+    ...current.options,
+    ...buildOptions(input, notify)
+  });
+  current._willUpdate();
+  notify();
+} onDestroy() {
+  cleanup?.();
+  v = null;
+  cleanup = null;
+}/>
+<return={
+  virtualItems: items,
+  totalSize: size,
+  range: range,
+  measureElement: v?.measureElement,
+  scrollToIndex: (index, options) => v?.scrollToIndex(index, options),
+  scrollToOffset: (offset, options) => v?.scrollToOffset(offset, options),
+  measure: () => v?.measure(),
+  resizeItem: (index, itemSize) => v?.resizeItem(index, itemSize),
+  scrollToEnd: options => v?.scrollToEnd(options),
+  isAtEnd: threshold => v?.isAtEnd(threshold) ?? false,
+  getDistanceFromEnd: () => v?.getDistanceFromEnd() ?? Infinity
+}/>

package/dist/tags/virtualizer/options.d.ts

@@ -0,0 +1,46 @@
+import { Virtualizer } from '@tanstack/virtual-core';
+import type { Range, VirtualItem, VirtualizerOptions } from '@tanstack/virtual-core';
+export interface VirtualizerInput {
+    count: number;
+    estimateSize?: (index: number) => number;
+    getScrollElement: () => Element | null;
+    overscan?: number;
+    horizontal?: boolean;
+    paddingStart?: number;
+    paddingEnd?: number;
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
+    gap?: number;
+    lanes?: number;
+    initialOffset?: number | (() => number);
+    initialRect?: {
+        width: number;
+        height: number;
+    };
+    getItemKey?: (index: number) => number | string | bigint;
+    rangeExtractor?: (range: Range) => Array<number>;
+    indexAttribute?: string;
+    initialMeasurementsCache?: Array<VirtualItem>;
+    anchorTo?: 'start' | 'end';
+    followOnAppend?: boolean | ScrollBehavior;
+    scrollEndThreshold?: number;
+    scrollMargin?: number;
+    enabled?: boolean;
+    isRtl?: boolean;
+    isScrollingResetDelay?: number;
+    useScrollendEvent?: boolean;
+    useAnimationFrameWithResizeObserver?: boolean;
+    laneAssignmentMode?: 'estimate' | 'measured';
+    useCachedMeasurements?: boolean;
+    debug?: boolean;
+    measureElement?: (element: Element, entry: ResizeObserverEntry | undefined, instance: Virtualizer<Element, Element>) => number;
+}
+export declare function buildOptions(input: VirtualizerInput, notify: () => void): VirtualizerOptions<Element, Element>;
+export declare function renderSlice(input: VirtualizerInput): {
+    items: Array<VirtualItem>;
+    size: number;
+    range: {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+};

package/dist/tags/virtualizer/options.js

@@ -0,0 +1,63 @@
+import { Virtualizer, elementScroll, observeElementOffset, observeElementRect, } from '@tanstack/virtual-core';
+// Single source of truth for the input -> virtual-core option mapping,
+// shared by the render-time seed, onMount (construction) and onUpdate (setOptions).
+// Optional inputs are forwarded possibly-undefined on purpose: virtual-core's
+// setOptions() skips undefined keys, so its own defaults apply.
+export function buildOptions(input, notify) {
+    return {
+        count: input.count,
+        estimateSize: input.estimateSize ?? (() => 50),
+        getScrollElement: input.getScrollElement,
+        overscan: input.overscan ?? 5,
+        horizontal: input.horizontal ?? false,
+        paddingStart: input.paddingStart,
+        paddingEnd: input.paddingEnd,
+        scrollPaddingStart: input.scrollPaddingStart,
+        scrollPaddingEnd: input.scrollPaddingEnd,
+        gap: input.gap,
+        lanes: input.lanes,
+        initialOffset: input.initialOffset,
+        initialRect: input.initialRect,
+        getItemKey: input.getItemKey,
+        rangeExtractor: input.rangeExtractor,
+        indexAttribute: input.indexAttribute,
+        initialMeasurementsCache: input.initialMeasurementsCache,
+        anchorTo: input.anchorTo,
+        followOnAppend: input.followOnAppend,
+        scrollEndThreshold: input.scrollEndThreshold,
+        scrollMargin: input.scrollMargin,
+        enabled: input.enabled,
+        isRtl: input.isRtl,
+        isScrollingResetDelay: input.isScrollingResetDelay,
+        useScrollendEvent: input.useScrollendEvent,
+        useAnimationFrameWithResizeObserver: input.useAnimationFrameWithResizeObserver,
+        laneAssignmentMode: input.laneAssignmentMode,
+        useCachedMeasurements: input.useCachedMeasurements,
+        debug: input.debug,
+        measureElement: input.measureElement,
+        observeElementRect,
+        observeElementOffset,
+        scrollToFn: elementScroll,
+        onChange: notify,
+    };
+}
+// Render-time (server / pre-mount) slice. Constructs a transient virtual-core instance,
+// reads the initial window as PLAIN DATA, and discards it — nothing live is retained, so
+// nothing live is serialized, and the values recompute identically on resume. With
+// `initialRect` this is a real slice of rows; without it renderSlice returns the trivial
+// window (no items, size 0). The constructor and getVirtualItems()/getTotalSize() are
+// SSR-safe (no DOM access); getScrollElement is forced to null so the probe never touches
+// the scroll element, which does not exist on the server.
+// `range` is the visible window ({ startIndex, endIndex }) the probe computed — plain data,
+// null when there is no slice.
+export function renderSlice(input) {
+    // Opt-in: without an explicit viewport hint there is no server slice. Returning the
+    // trivial window keeps every example that does not pass `initialRect` byte-for-byte
+    // identical to a client-only build (empty container, filled on mount).
+    if (!input.initialRect) {
+        return { items: [], size: 0, range: null };
+    }
+    const probe = new Virtualizer(buildOptions({ ...input, getScrollElement: () => null }, () => { }));
+    const items = probe.getVirtualItems();
+    return { items, size: probe.getTotalSize(), range: probe.range };
+}

package/dist/tags/window-virtualizer/index.d.marko

@@ -0,0 +1,55 @@
+import { Virtualizer } from "@tanstack/virtual-core";
+import type { Range, VirtualItem, ScrollToOptions } from "@tanstack/virtual-core";
+export interface WindowVirtualizerHandle {
+    virtualItems: VirtualItem[];
+    totalSize: number;
+    range: {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+    measureElement: ((el: Element | null) => void) | undefined;
+    scrollToIndex: (index: number, options?: ScrollToOptions) => void;
+    scrollToOffset: (offset: number, options?: ScrollToOptions) => void;
+    measure: () => void;
+    resizeItem: (index: number, size: number) => void;
+    scrollToEnd: (options?: {
+        behavior?: ScrollToOptions['behavior'];
+    }) => void;
+    isAtEnd: (threshold?: number) => boolean;
+    getDistanceFromEnd: () => number;
+}
+export interface Input {
+    count: number;
+    estimateSize?: (index: number) => number;
+    overscan?: number;
+    horizontal?: boolean;
+    paddingStart?: number;
+    paddingEnd?: number;
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
+    gap?: number;
+    lanes?: number;
+    initialOffset?: number | (() => number);
+    initialRect?: {
+        width: number;
+        height: number;
+    };
+    getItemKey?: (index: number) => number | string | bigint;
+    rangeExtractor?: (range: Range) => number[];
+    indexAttribute?: string;
+    initialMeasurementsCache?: VirtualItem[];
+    anchorTo?: 'start' | 'end';
+    followOnAppend?: boolean | ScrollBehavior;
+    scrollEndThreshold?: number;
+    scrollMargin?: number;
+    enabled?: boolean;
+    isRtl?: boolean;
+    isScrollingResetDelay?: number;
+    useScrollendEvent?: boolean;
+    useAnimationFrameWithResizeObserver?: boolean;
+    laneAssignmentMode?: 'estimate' | 'measured';
+    useCachedMeasurements?: boolean;
+    debug?: boolean;
+    measureElement?: (element: Element, entry: ResizeObserverEntry | undefined, instance: Virtualizer<Window, Element>) => number;
+}
+<return = (1 as any as WindowVirtualizerHandle)/>

package/dist/tags/window-virtualizer/index.marko

@@ -0,0 +1,57 @@
+import { Virtualizer } from "@tanstack/virtual-core";
+import { buildOptions, renderSlice } from "./options.js";
+<!-- Render-time seed (window counterpart): paints the initial slice into the server HTML when-->
+<!-- `initialRect` is given (empty container with correct total height otherwise), no <if=mounted>-->
+<!-- guard. The live, observing instance is built client-only in onMount and takes over.-->
+<const/seed=renderSlice(input)/>
+<let/items=seed.items/>
+<let/size=seed.size/>
+<let/range=seed.range/>
+<let/v=null/>
+<let/cleanup=null/>
+<lifecycle<{}> onMount() {
+  const notify = () => {
+    const inst = v;
+    if (!inst) return;
+    items = inst.getVirtualItems();
+    size = inst.getTotalSize();
+    range = inst.range;
+  };
+  v = new Virtualizer(buildOptions(input, notify));
+  cleanup = v._didMount();
+  v._willUpdate();
+  notify();
+} onUpdate() {
+  const current = v;
+  if (!current) return;
+  const notify = () => {
+    const inst = v;
+    if (!inst) return;
+    items = inst.getVirtualItems();
+    size = inst.getTotalSize();
+    range = inst.range;
+  };
+  current.setOptions({
+    ...current.options,
+    ...buildOptions(input, notify)
+  });
+  current._willUpdate();
+  notify();
+} onDestroy() {
+  cleanup?.();
+  v = null;
+  cleanup = null;
+}/>
+<return={
+  virtualItems: items,
+  totalSize: size,
+  range: range,
+  measureElement: v?.measureElement,
+  scrollToIndex: (index, options) => v?.scrollToIndex(index, options),
+  scrollToOffset: (offset, options) => v?.scrollToOffset(offset, options),
+  measure: () => v?.measure(),
+  resizeItem: (index, itemSize) => v?.resizeItem(index, itemSize),
+  scrollToEnd: options => v?.scrollToEnd(options),
+  isAtEnd: threshold => v?.isAtEnd(threshold) ?? false,
+  getDistanceFromEnd: () => v?.getDistanceFromEnd() ?? Infinity
+}/>

package/dist/tags/window-virtualizer/options.d.ts

@@ -0,0 +1,45 @@
+import { Virtualizer } from '@tanstack/virtual-core';
+import type { Range, VirtualItem, VirtualizerOptions } from '@tanstack/virtual-core';
+export interface WindowVirtualizerInput {
+    count: number;
+    estimateSize?: (index: number) => number;
+    overscan?: number;
+    horizontal?: boolean;
+    paddingStart?: number;
+    paddingEnd?: number;
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
+    gap?: number;
+    lanes?: number;
+    initialOffset?: number | (() => number);
+    initialRect?: {
+        width: number;
+        height: number;
+    };
+    getItemKey?: (index: number) => number | string | bigint;
+    rangeExtractor?: (range: Range) => Array<number>;
+    indexAttribute?: string;
+    initialMeasurementsCache?: Array<VirtualItem>;
+    anchorTo?: 'start' | 'end';
+    followOnAppend?: boolean | ScrollBehavior;
+    scrollEndThreshold?: number;
+    scrollMargin?: number;
+    enabled?: boolean;
+    isRtl?: boolean;
+    isScrollingResetDelay?: number;
+    useScrollendEvent?: boolean;
+    useAnimationFrameWithResizeObserver?: boolean;
+    laneAssignmentMode?: 'estimate' | 'measured';
+    useCachedMeasurements?: boolean;
+    debug?: boolean;
+    measureElement?: (element: Element, entry: ResizeObserverEntry | undefined, instance: Virtualizer<Window, Element>) => number;
+}
+export declare function buildOptions(input: WindowVirtualizerInput, notify: () => void): VirtualizerOptions<Window, Element>;
+export declare function renderSlice(input: WindowVirtualizerInput): {
+    items: Array<VirtualItem>;
+    size: number;
+    range: {
+        startIndex: number;
+        endIndex: number;
+    } | null;
+};

package/dist/tags/window-virtualizer/options.js

@@ -0,0 +1,67 @@
+import { Virtualizer, observeWindowOffset, observeWindowRect, windowScroll, } from '@tanstack/virtual-core';
+// Single source of truth for the input -> virtual-core option mapping,
+// shared by the render-time seed, onMount (construction) and onUpdate (setOptions).
+// Optional inputs are forwarded possibly-undefined on purpose: virtual-core's
+// setOptions() skips undefined keys, so its own defaults apply.
+export function buildOptions(input, notify) {
+    return {
+        count: input.count,
+        estimateSize: input.estimateSize ?? (() => 50),
+        getScrollElement: () => (typeof document !== 'undefined' ? window : null),
+        overscan: input.overscan ?? 5,
+        horizontal: input.horizontal,
+        paddingStart: input.paddingStart,
+        paddingEnd: input.paddingEnd,
+        scrollPaddingStart: input.scrollPaddingStart,
+        scrollPaddingEnd: input.scrollPaddingEnd,
+        gap: input.gap,
+        lanes: input.lanes,
+        // Consumer override first (mirrors react-virtual's spread-over-defaults), then the
+        // live window position on the client / 0 (top) on the server.
+        initialOffset: input.initialOffset ??
+            (() => typeof document !== 'undefined'
+                ? input.horizontal
+                    ? window.scrollX
+                    : window.scrollY
+                : 0),
+        initialRect: input.initialRect,
+        getItemKey: input.getItemKey,
+        rangeExtractor: input.rangeExtractor,
+        indexAttribute: input.indexAttribute,
+        initialMeasurementsCache: input.initialMeasurementsCache,
+        anchorTo: input.anchorTo,
+        followOnAppend: input.followOnAppend,
+        scrollEndThreshold: input.scrollEndThreshold,
+        scrollMargin: input.scrollMargin,
+        enabled: input.enabled,
+        isRtl: input.isRtl,
+        isScrollingResetDelay: input.isScrollingResetDelay,
+        useScrollendEvent: input.useScrollendEvent,
+        useAnimationFrameWithResizeObserver: input.useAnimationFrameWithResizeObserver,
+        laneAssignmentMode: input.laneAssignmentMode,
+        useCachedMeasurements: input.useCachedMeasurements,
+        debug: input.debug,
+        measureElement: input.measureElement,
+        observeElementRect: observeWindowRect,
+        observeElementOffset: observeWindowOffset,
+        scrollToFn: windowScroll,
+        onChange: notify,
+    };
+}
+// Render-time (server / pre-mount) slice — the window counterpart of the element helper.
+// Opt-in: without `initialRect` there is no server slice (trivial window), which keeps every
+// example that does not pass it byte-for-byte identical to a client-only build. With
+// `initialRect` a transient instance derives the initial window as plain data and is discarded;
+// nothing live is retained or serialized, and the values recompute identically on resume.
+// The probe never observes, so it reads `initialRect` directly (getScrollElement returns null on
+// the server and window on the client, but neither is measured before getVirtualItems()).
+// `range` is the visible window ({ startIndex, endIndex }) the probe computed — plain data,
+// null when there is no slice.
+export function renderSlice(input) {
+    if (!input.initialRect) {
+        return { items: [], size: 0, range: null };
+    }
+    const probe = new Virtualizer(buildOptions(input, () => { }));
+    const items = probe.getVirtualItems();
+    return { items, size: probe.getTotalSize(), range: probe.range };
+}

package/marko.json

@@ -1 +1 @@
-{ "tags-dir": "./src/tags", "script-lang": "ts" }
+{ "exports": "./dist/tags" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/marko-virtual",
-  "version": "3.14.2",
+  "version": "3.15.0",
   "description": "Headless UI for virtualizing scrollable elements in Marko 6",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -38,22 +38,25 @@
     },
     "./package.json": "./package.json",
     "./marko.json": "./marko.json",
-    "./src/tags/*": "./src/tags/*"
+    "./dist/tags/*": "./dist/tags/*"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "**/*.marko"
+  ],
   "files": [
     "dist",
-    "src/tags",
     "marko.json",
     "README.md"
   ],
   "dependencies": {
-    "@tanstack/virtual-core": "3.17.5"
+    "@tanstack/virtual-core": "3.17.7"
   },
   "devDependencies": {
-    "@marko/vite": "^3.0.0",
+    "@marko/language-tools": "^2.6.2",
+    "@marko/type-check": "3.1.1",
+    "@marko/vite": "^6.1.0",
     "@testing-library/dom": "^10.0.0",
-    "marko": "^6.0.0"
+    "marko": "^6.2.2"
   },
   "peerDependencies": {
     "marko": "^6.0.0"
@@ -61,10 +64,10 @@
   "scripts": {
     "clean": "premove ./dist ./coverage",
     "test:eslint": "eslint ./src",
-    "test:types": "tsc",
+    "test:types": "mtc -p tsconfig.typecheck.json",
     "test:lib": "vitest",
     "test:lib:dev": "pnpm run test:lib --watch",
     "test:build": "publint --strict",
-    "build": "vite build"
+    "build": "vite build && marko-type-check -p tsconfig.tags.json && premove ./dist/tsconfig.tags.tsbuildinfo"
   }
 }

package/src/tags/virtualizer/index.marko

@@ -1,78 +0,0 @@
-import { Virtualizer } from "@tanstack/virtual-core"
-import type { VirtualItem, ScrollToOptions } from "@tanstack/virtual-core"
-import { buildOptions } from "./options"
-
-export interface Input {
-  count: number
-  estimateSize?: (index: number) => number
-  getScrollElement: () => Element | null
-  overscan?: number
-  horizontal?: boolean
-  paddingStart?: number
-  paddingEnd?: number
-  scrollPaddingStart?: number
-  scrollPaddingEnd?: number
-  gap?: number
-  lanes?: number
-  initialOffset?: number | (() => number)
-  content: Marko.Body<[{
-    virtualItems: VirtualItem[]
-    totalSize: number
-    measureElement: ((el: Element | null) => void) | undefined
-    scrollToIndex: (index: number, options?: ScrollToOptions) => void
-    scrollToOffset: (offset: number, options?: ScrollToOptions) => void
-  }]>
-}
-
-<let/v       = (null as Virtualizer<Element, Element> | null)/>
-<let/cleanup = (null as (() => void) | null)/>
-<let/items   = ([] as VirtualItem[])/>
-<let/size    = 0/>
-
-<lifecycle<{}>
-  onMount() {
-    const notify = () => {
-      const inst = v
-      if (!inst) return
-      items = inst.getVirtualItems()
-      size  = inst.getTotalSize()
-    }
-
-    v = new Virtualizer<Element, Element>(buildOptions(input, notify))
-    cleanup = v!._didMount()
-    v!._willUpdate()
-  }
-
-  onUpdate() {
-    const current = v
-    if (!current) return
-
-    const notify = () => {
-      const inst = v
-      if (!inst) return
-      items = inst.getVirtualItems()
-      size  = inst.getTotalSize()
-    }
-
-    current.setOptions({ ...current.options, ...buildOptions(input, notify) })
-
-    // _willUpdate() is a no-op when the scroll element is unchanged, so
-    // notify() explicitly afterwards to recompute on count/option changes.
-    current._willUpdate()
-    notify()
-  }
-
-  onDestroy() {
-    cleanup?.()
-    v = null
-    cleanup = null
-  }
-/>
-
-<${input.content}
-  virtualItems=items
-  totalSize=size
-  measureElement=v?.measureElement
-  scrollToIndex=(index: number, options?: ScrollToOptions) => v?.scrollToIndex(index, options)
-  scrollToOffset=(offset: number, options?: ScrollToOptions) => v?.scrollToOffset(offset, options)
-/>