@open-grid/virtual 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Open Grid contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,29 @@
+# @open-grid/virtual
+
+Framework-agnostic virtualization primitives for Open Grid.
+
+Use this package for row and column virtualization calculations shared by React, Vue, Svelte, and custom renderers.
+
+## Install
+
+```bash
+npm install @open-grid/virtual
+```
+
+## Usage
+
+```ts
+import { getVirtualRange } from "@open-grid/virtual";
+
+const range = getVirtualRange({
+  count: 10_000,
+  viewportSize: 480,
+  scrollOffset: 2_400,
+  estimateSize: 40,
+  overscan: 4,
+});
+```
+
+It also includes shared initial scroll frames, row virtual range helpers, sized column layout helpers, measured column layout cache helpers, measured layout signature/cache sync helpers, render item helpers, render item key helpers, focused-cell render-window checks, and spacer item type guards for virtualized rows, center-column windows, spacers, and grouped header clipping so framework renderers can keep header/body alignment consistent.
+
+Most applications should use virtualization through a framework UI package. Use this package directly when building a custom renderer.

package/dist/index.d.ts

@@ -0,0 +1,155 @@
+interface VirtualItem {
+    index: number;
+    start: number;
+    size: number;
+    end: number;
+}
+interface VirtualRangeOptions {
+    count: number;
+    viewportSize: number;
+    scrollOffset: number;
+    estimateSize: number | ((index: number) => number);
+    overscan?: number;
+}
+interface VirtualRowRangeOptions {
+    count: number;
+    scrollFrame: ScrollFrame;
+    enabled: boolean;
+    estimateSize: number | ((index: number) => number);
+    overscan?: number;
+}
+interface VirtualRange {
+    totalSize: number;
+    startIndex: number;
+    endIndex: number;
+    items: VirtualItem[];
+}
+interface VirtualRowItem<TRow> {
+    row: TRow;
+    rowIndex: number;
+    virtualItem: VirtualItem | null;
+}
+interface ScrollFrameOptions {
+    scrollTop: number;
+    scrollLeft: number;
+    viewportHeight: number;
+    viewportWidth: number;
+    stickyTopOffset?: number;
+}
+interface ScrollFrame {
+    scrollTop: number;
+    scrollLeft: number;
+    viewportHeight: number;
+    viewportWidth: number;
+}
+interface ColumnVirtualLayoutItem {
+    id: string;
+    start: number;
+    end: number;
+    size: number;
+    pinned: false | "left" | "right";
+    pinnedStart?: number;
+    pinnedEdge?: "left" | "right";
+}
+type ColumnRenderItem<TLayout extends ColumnVirtualLayoutItem = ColumnVirtualLayoutItem> = {
+    type: "column";
+    layout: TLayout;
+} | {
+    type: "spacer";
+    id: string;
+    size: number;
+};
+interface ColumnCellRenderItem<TLayout extends ColumnVirtualLayoutItem = ColumnVirtualLayoutItem> {
+    layout: TLayout;
+    beforeSpacerSize: number;
+    afterSpacerSize: number;
+}
+interface HeaderRenderHeaderLike {
+    id: string;
+    leafColumnIds: readonly string[];
+}
+interface HeaderRenderGroupLike<THeader extends HeaderRenderHeaderLike> {
+    headers: readonly THeader[];
+}
+interface FocusedCellRenderWindowLike {
+    rowId: string;
+    columnId: string;
+}
+type HeaderRenderItem<THeader extends HeaderRenderHeaderLike = HeaderRenderHeaderLike> = {
+    type: "header";
+    header: THeader;
+    size: number;
+    leafColumnIds: string[];
+} | {
+    type: "spacer";
+    id: string;
+    size: number;
+};
+declare function isColumnRenderSpacerItem<TItem extends ColumnRenderItem>(item: TItem): item is Extract<TItem, {
+    type: "spacer";
+}>;
+declare function isHeaderRenderSpacerItem<TItem extends HeaderRenderItem>(item: TItem): item is Extract<TItem, {
+    type: "spacer";
+}>;
+declare function getColumnRenderItemKey<TLayout extends ColumnVirtualLayoutItem>(item: ColumnRenderItem<TLayout>): string;
+declare function getColumnCellRenderItems<TLayout extends ColumnVirtualLayoutItem>(items: readonly ColumnRenderItem<TLayout>[]): ColumnCellRenderItem<TLayout>[];
+declare function getHeaderRenderItemKey<THeader extends HeaderRenderHeaderLike>(headerGroupId: string, item: HeaderRenderItem<THeader>): string;
+interface ColumnRenderItemsOptions {
+    enabled: boolean;
+    overscan: number;
+}
+interface ColumnRenderItemsScrollFrame {
+    scrollLeft: number;
+    viewportWidth: number;
+}
+type MeasuredSizeKey = string | number;
+interface MeasuredSizeCache {
+    readonly version: number;
+    readonly size: number;
+    get: (key: MeasuredSizeKey) => number | undefined;
+    set: (key: MeasuredSizeKey, size: number) => boolean;
+    delete: (key: MeasuredSizeKey) => boolean;
+    clear: () => boolean;
+    prune: (keys: Iterable<MeasuredSizeKey>) => boolean;
+    resolve: (key: MeasuredSizeKey, estimateSize: number | (() => number)) => number;
+}
+interface MeasuredColumnLayoutCacheOptions {
+    enabled: boolean;
+    cache: Pick<MeasuredSizeCache, "get">;
+    tolerance?: number;
+}
+interface MeasuredColumnLayoutCacheSyncOptions {
+    enabled: boolean;
+    cache: Pick<MeasuredSizeCache, "clear">;
+    currentSignature: string;
+    nextSignature: string;
+}
+interface MeasuredColumnLayoutCacheSyncResult {
+    signature: string;
+    changed: boolean;
+}
+interface SizedColumnLayoutOptions {
+    getColumnSize: (columnId: string) => number | undefined;
+    getFallbackSize?: (columnId: string, fallbackSize: number) => number | undefined;
+}
+declare function getVirtualRange(options: VirtualRangeOptions): VirtualRange;
+declare function getScrollFrame(options: ScrollFrameOptions): ScrollFrame;
+declare function getInitialScrollFrame(): ScrollFrame;
+declare function getVirtualRowRange(options: VirtualRowRangeOptions): VirtualRange | null;
+declare function getVirtualRowItems<TRow>(rows: readonly TRow[], virtualRange: VirtualRange | null | undefined): VirtualRowItem<TRow>[];
+declare function getIsFocusedCellInRenderWindow<TRow extends {
+    id: string;
+}, TLayout extends ColumnVirtualLayoutItem>(focusedCell: FocusedCellRenderWindowLike | null | undefined, visibleRowItems: readonly VirtualRowItem<TRow>[], columnRenderItems: readonly ColumnRenderItem<TLayout>[]): boolean;
+declare function getColumnRenderItems<TLayout extends ColumnVirtualLayoutItem>(layout: readonly TLayout[], scrollFrame: ColumnRenderItemsScrollFrame, options: ColumnRenderItemsOptions): ColumnRenderItem<TLayout>[];
+declare function getHeaderRenderItems<THeader extends HeaderRenderHeaderLike, TLayout extends ColumnVirtualLayoutItem>(headerGroup: HeaderRenderGroupLike<THeader>, columnRenderItems: readonly ColumnRenderItem<TLayout>[], layoutById: ReadonlyMap<string, {
+    size: number;
+}>): HeaderRenderItem<THeader>[];
+declare function getMeasuredColumnLayout<TLayout extends ColumnVirtualLayoutItem>(layout: readonly TLayout[], resolveSize: (columnId: string, fallbackSize: number) => number): TLayout[];
+declare function getSizedColumnLayout<TLayout extends ColumnVirtualLayoutItem>(layout: readonly TLayout[], options: SizedColumnLayoutOptions): TLayout[];
+declare function getMeasuredColumnLayoutFromCache<TLayout extends ColumnVirtualLayoutItem>(layout: readonly TLayout[], options: MeasuredColumnLayoutCacheOptions): TLayout[];
+declare function getColumnLayoutMeasurementSignature(layout: readonly ColumnVirtualLayoutItem[]): string;
+declare function syncMeasuredColumnLayoutCache(options: MeasuredColumnLayoutCacheSyncOptions): MeasuredColumnLayoutCacheSyncResult;
+declare function createMeasuredSizeCache(): MeasuredSizeCache;
+declare function createMeasuredSizeResolver(cache: MeasuredSizeCache, getKey: (index: number) => MeasuredSizeKey, estimateSize: number | ((index: number) => number)): (index: number) => number;
+
+export { type ColumnCellRenderItem, type ColumnRenderItem, type ColumnRenderItemsOptions, type ColumnRenderItemsScrollFrame, type ColumnVirtualLayoutItem, type FocusedCellRenderWindowLike, type HeaderRenderGroupLike, type HeaderRenderHeaderLike, type HeaderRenderItem, type MeasuredColumnLayoutCacheOptions, type MeasuredColumnLayoutCacheSyncOptions, type MeasuredColumnLayoutCacheSyncResult, type MeasuredSizeCache, type MeasuredSizeKey, type ScrollFrame, type ScrollFrameOptions, type SizedColumnLayoutOptions, type VirtualItem, type VirtualRange, type VirtualRangeOptions, type VirtualRowItem, type VirtualRowRangeOptions, createMeasuredSizeCache, createMeasuredSizeResolver, getColumnCellRenderItems, getColumnLayoutMeasurementSignature, getColumnRenderItemKey, getColumnRenderItems, getHeaderRenderItemKey, getHeaderRenderItems, getInitialScrollFrame, getIsFocusedCellInRenderWindow, getMeasuredColumnLayout, getMeasuredColumnLayoutFromCache, getScrollFrame, getSizedColumnLayout, getVirtualRange, getVirtualRowItems, getVirtualRowRange, isColumnRenderSpacerItem, isHeaderRenderSpacerItem, syncMeasuredColumnLayoutCache };

package/dist/index.js

@@ -0,0 +1,420 @@
+// src/index.ts
+function isColumnRenderSpacerItem(item) {
+  return item.type === "spacer";
+}
+function isHeaderRenderSpacerItem(item) {
+  return item.type === "spacer";
+}
+function getColumnRenderItemKey(item) {
+  return isColumnRenderSpacerItem(item) ? item.id : item.layout.id;
+}
+function getColumnCellRenderItems(items) {
+  const columns = [];
+  let beforeSpacerSize = 0;
+  let afterSpacerSize = 0;
+  for (const item of items) {
+    if (!isColumnRenderSpacerItem(item)) {
+      columns.push(item.layout);
+    } else if (item.id === "center-before") {
+      beforeSpacerSize = item.size;
+    } else if (item.id === "center-after") {
+      afterSpacerSize = item.size;
+    }
+  }
+  const firstCenterIndex = columns.findIndex((layout) => layout.pinned === false);
+  let lastCenterIndex = -1;
+  for (let index = columns.length - 1; index >= 0; index -= 1) {
+    if (columns[index]?.pinned === false) {
+      lastCenterIndex = index;
+      break;
+    }
+  }
+  return columns.map((layout, index) => ({
+    layout,
+    beforeSpacerSize: index === firstCenterIndex ? beforeSpacerSize : 0,
+    afterSpacerSize: index === lastCenterIndex ? afterSpacerSize : 0
+  }));
+}
+function getHeaderRenderItemKey(headerGroupId, item) {
+  return isHeaderRenderSpacerItem(item) ? item.id : `${headerGroupId}:${item.header.id}:${item.leafColumnIds.join(",")}`;
+}
+function getVirtualRange(options) {
+  const { count, viewportSize, scrollOffset, overscan = 2 } = options;
+  if (count <= 0) {
+    return {
+      totalSize: 0,
+      startIndex: 0,
+      endIndex: -1,
+      items: []
+    };
+  }
+  if (typeof options.estimateSize === "number" && Number.isFinite(options.estimateSize) && options.estimateSize > 0) {
+    return getFixedVirtualRange(count, viewportSize, scrollOffset, options.estimateSize, overscan);
+  }
+  const sizes = Array.from({ length: count }, (_, index) => resolveSize(options.estimateSize, index));
+  const offsets = createOffsets(sizes);
+  const totalSize = offsets[count] ?? 0;
+  const visibleStart = Math.max(0, findNearestIndex(offsets, scrollOffset) - overscan);
+  const viewportEnd = scrollOffset + viewportSize;
+  const lastVisibleIndex = viewportSize > 0 ? findLastIndexStartingBefore(offsets, viewportEnd) : findNearestIndex(offsets, scrollOffset);
+  const visibleEnd = Math.min(count - 1, Math.max(visibleStart, lastVisibleIndex) + overscan);
+  const items = [];
+  for (let index = visibleStart; index <= visibleEnd; index += 1) {
+    const start = offsets[index] ?? 0;
+    const size = sizes[index] ?? 0;
+    items.push({
+      index,
+      start,
+      size,
+      end: start + size
+    });
+  }
+  return {
+    totalSize,
+    startIndex: visibleStart,
+    endIndex: visibleEnd,
+    items
+  };
+}
+function getFixedVirtualRange(count, viewportSize, scrollOffset, size, overscan) {
+  const totalSize = count * size;
+  const resolvedScrollOffset = Math.max(0, scrollOffset);
+  const resolvedViewportEnd = Math.max(0, resolvedScrollOffset + viewportSize);
+  const visibleStart = Math.max(0, Math.min(count - 1, Math.floor(resolvedScrollOffset / size)) - overscan);
+  const lastVisibleIndex = viewportSize > 0 ? Math.max(0, Math.ceil(resolvedViewportEnd / size) - 1) : Math.floor(resolvedScrollOffset / size);
+  const visibleEnd = Math.min(count - 1, Math.max(visibleStart, lastVisibleIndex) + overscan);
+  const items = [];
+  for (let index = visibleStart; index <= visibleEnd; index += 1) {
+    const start = index * size;
+    items.push({ index, start, size, end: start + size });
+  }
+  return { totalSize, startIndex: visibleStart, endIndex: visibleEnd, items };
+}
+function getScrollFrame(options) {
+  const stickyTopOffset = options.stickyTopOffset ?? 0;
+  return {
+    scrollTop: Math.max(0, options.scrollTop - stickyTopOffset),
+    scrollLeft: Math.max(0, options.scrollLeft),
+    viewportHeight: Math.max(0, options.viewportHeight - stickyTopOffset),
+    viewportWidth: Math.max(0, options.viewportWidth)
+  };
+}
+function getInitialScrollFrame() {
+  return {
+    scrollTop: 0,
+    scrollLeft: 0,
+    viewportHeight: 0,
+    viewportWidth: 0
+  };
+}
+function getVirtualRowRange(options) {
+  if (!options.enabled) {
+    return null;
+  }
+  const rangeOptions = {
+    count: options.count,
+    viewportSize: options.scrollFrame.viewportHeight,
+    scrollOffset: options.scrollFrame.scrollTop,
+    estimateSize: options.estimateSize
+  };
+  if (options.overscan !== void 0) {
+    rangeOptions.overscan = options.overscan;
+  }
+  return getVirtualRange(rangeOptions);
+}
+function getVirtualRowItems(rows, virtualRange) {
+  if (!virtualRange) {
+    return rows.map((row, rowIndex) => ({ row, rowIndex, virtualItem: null }));
+  }
+  return virtualRange.items.flatMap((item) => {
+    const row = rows[item.index];
+    return row ? [{ row, rowIndex: item.index, virtualItem: item }] : [];
+  });
+}
+function getIsFocusedCellInRenderWindow(focusedCell, visibleRowItems, columnRenderItems) {
+  if (!focusedCell) {
+    return false;
+  }
+  return visibleRowItems.some((item) => item.row.id === focusedCell.rowId) && columnRenderItems.some((item) => !isColumnRenderSpacerItem(item) && item.layout.id === focusedCell.columnId);
+}
+function getColumnRenderItems(layout, scrollFrame, options) {
+  if (!options.enabled) {
+    return layout.map((item) => ({ type: "column", layout: item }));
+  }
+  const leftPinned = layout.filter((item) => item.pinned === "left");
+  const rightPinned = layout.filter((item) => item.pinned === "right");
+  const center = layout.filter((item) => item.pinned === false);
+  const leftPinnedSize = leftPinned.reduce((total, item) => total + item.size, 0);
+  const rightPinnedSize = rightPinned.reduce((total, item) => total + item.size, 0);
+  const centerStart = center[0]?.start ?? leftPinnedSize;
+  const centerRange = getVirtualRange({
+    count: center.length,
+    viewportSize: Math.max(0, scrollFrame.viewportWidth - leftPinnedSize - rightPinnedSize),
+    scrollOffset: Math.max(0, scrollFrame.scrollLeft - centerStart),
+    estimateSize: (index) => center[index]?.size ?? 0,
+    overscan: options.overscan
+  });
+  const virtualCenter = centerRange.items.flatMap((item) => {
+    const column = center[item.index];
+    return column ? [column] : [];
+  });
+  const centerEnd = center.at(-1)?.end ?? centerStart;
+  const firstVirtualCenter = virtualCenter[0];
+  const lastVirtualCenter = virtualCenter.at(-1);
+  const beforeCenterSize = Math.max(0, (firstVirtualCenter?.start ?? centerEnd) - centerStart);
+  const afterCenterSize = Math.max(0, centerEnd - (lastVirtualCenter?.end ?? centerStart));
+  const items = [...leftPinned.map((item) => ({ type: "column", layout: item }))];
+  if (beforeCenterSize > 0) {
+    items.push({ type: "spacer", id: "center-before", size: beforeCenterSize });
+  }
+  items.push(...virtualCenter.map((item) => ({ type: "column", layout: item })));
+  if (afterCenterSize > 0) {
+    items.push({ type: "spacer", id: "center-after", size: afterCenterSize });
+  }
+  items.push(...rightPinned.map((item) => ({ type: "column", layout: item })));
+  return items;
+}
+function getHeaderRenderItems(headerGroup, columnRenderItems, layoutById) {
+  const headersByLeafId = /* @__PURE__ */ new Map();
+  for (const header of headerGroup.headers) {
+    for (const leafColumnId of header.leafColumnIds) {
+      headersByLeafId.set(leafColumnId, header);
+    }
+  }
+  const items = [];
+  let activeHeader = null;
+  let activeSize = 0;
+  let activeLeafColumnIds = [];
+  const flushActiveHeader = () => {
+    if (!activeHeader) {
+      return;
+    }
+    items.push({
+      type: "header",
+      header: activeHeader,
+      size: activeSize,
+      leafColumnIds: activeLeafColumnIds
+    });
+    activeHeader = null;
+    activeSize = 0;
+    activeLeafColumnIds = [];
+  };
+  for (const item of columnRenderItems) {
+    if (isColumnRenderSpacerItem(item)) {
+      flushActiveHeader();
+      items.push(item);
+      continue;
+    }
+    const header = headersByLeafId.get(item.layout.id);
+    if (!header) {
+      continue;
+    }
+    const size = layoutById.get(item.layout.id)?.size ?? item.layout.size;
+    if (activeHeader?.id !== header.id) {
+      flushActiveHeader();
+      activeHeader = header;
+    }
+    activeSize += size;
+    activeLeafColumnIds.push(item.layout.id);
+  }
+  flushActiveHeader();
+  return items;
+}
+function getMeasuredColumnLayout(layout, resolveSize2) {
+  const leftPinned = layout.filter((item) => item.pinned === "left");
+  const rightPinned = layout.filter((item) => item.pinned === "right");
+  const lastLeftPinnedId = leftPinned.at(-1)?.id;
+  const firstRightPinnedId = rightPinned[0]?.id;
+  const measuredSizes = new Map(layout.map((item) => [item.id, resolveSize2(item.id, item.size)]));
+  const rightOffsets = /* @__PURE__ */ new Map();
+  let rightOffset = 0;
+  for (const item of [...rightPinned].reverse()) {
+    rightOffsets.set(item.id, rightOffset);
+    rightOffset += measuredSizes.get(item.id) ?? item.size;
+  }
+  let start = 0;
+  let leftOffset = 0;
+  return layout.map((item) => {
+    const size = measuredSizes.get(item.id) ?? item.size;
+    const measured = {
+      id: item.id,
+      size,
+      start,
+      end: start + size,
+      pinned: item.pinned
+    };
+    if (item.pinned === "left") {
+      measured.pinnedStart = leftOffset;
+      leftOffset += size;
+      if (item.id === lastLeftPinnedId) {
+        measured.pinnedEdge = "left";
+      }
+    } else if (item.pinned === "right") {
+      measured.pinnedStart = rightOffsets.get(item.id) ?? 0;
+      if (item.id === firstRightPinnedId) {
+        measured.pinnedEdge = "right";
+      }
+    }
+    start += size;
+    return measured;
+  });
+}
+function getSizedColumnLayout(layout, options) {
+  return getMeasuredColumnLayout(
+    layout,
+    (columnId, fallbackSize) => options.getColumnSize(columnId) ?? options.getFallbackSize?.(columnId, fallbackSize) ?? fallbackSize
+  );
+}
+function getMeasuredColumnLayoutFromCache(layout, options) {
+  const tolerance = options.tolerance ?? 1;
+  return getMeasuredColumnLayout(layout, (columnId, fallbackSize) => {
+    const measuredSize = options.enabled ? options.cache.get(columnId) : void 0;
+    return measuredSize !== void 0 && Math.abs(measuredSize - fallbackSize) <= tolerance ? measuredSize : fallbackSize;
+  });
+}
+function getColumnLayoutMeasurementSignature(layout) {
+  return layout.map((item) => `${item.id}:${item.size}:${item.pinned}:${item.pinnedStart ?? ""}:${item.pinnedEdge ?? ""}`).join("|");
+}
+function syncMeasuredColumnLayoutCache(options) {
+  if (!options.enabled) {
+    return {
+      signature: options.nextSignature,
+      changed: false
+    };
+  }
+  if (options.currentSignature === options.nextSignature) {
+    return {
+      signature: options.currentSignature,
+      changed: false
+    };
+  }
+  return {
+    signature: options.nextSignature,
+    changed: options.cache.clear()
+  };
+}
+function createMeasuredSizeCache() {
+  const sizes = /* @__PURE__ */ new Map();
+  let version = 0;
+  const bump = () => {
+    version += 1;
+  };
+  return {
+    get version() {
+      return version;
+    },
+    get size() {
+      return sizes.size;
+    },
+    get: (key) => sizes.get(key),
+    set: (key, size) => {
+      if (!Number.isFinite(size) || size <= 0) {
+        return false;
+      }
+      if (sizes.get(key) === size) {
+        return false;
+      }
+      sizes.set(key, size);
+      bump();
+      return true;
+    },
+    delete: (key) => {
+      const deleted = sizes.delete(key);
+      if (deleted) {
+        bump();
+      }
+      return deleted;
+    },
+    clear: () => {
+      if (sizes.size === 0) {
+        return false;
+      }
+      sizes.clear();
+      bump();
+      return true;
+    },
+    prune: (keys) => {
+      const available = new Set(keys);
+      let changed = false;
+      for (const key of sizes.keys()) {
+        if (!available.has(key)) {
+          sizes.delete(key);
+          changed = true;
+        }
+      }
+      if (changed) {
+        bump();
+      }
+      return changed;
+    },
+    resolve: (key, estimateSize) => sizes.get(key) ?? (typeof estimateSize === "function" ? estimateSize() : estimateSize)
+  };
+}
+function createMeasuredSizeResolver(cache, getKey, estimateSize) {
+  return (index) => cache.resolve(getKey(index), typeof estimateSize === "function" ? () => estimateSize(index) : estimateSize);
+}
+function resolveSize(estimateSize, index) {
+  return typeof estimateSize === "function" ? estimateSize(index) : estimateSize;
+}
+function createOffsets(sizes) {
+  const offsets = [0];
+  for (const size of sizes) {
+    offsets.push((offsets[offsets.length - 1] ?? 0) + size);
+  }
+  return offsets;
+}
+function findNearestIndex(offsets, value) {
+  let low = 0;
+  let high = Math.max(0, offsets.length - 2);
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const start = offsets[mid] ?? 0;
+    const end = offsets[mid + 1] ?? start;
+    if (value >= start && value < end) {
+      return mid;
+    }
+    if (value < start) {
+      high = mid - 1;
+    } else {
+      low = mid + 1;
+    }
+  }
+  return Math.max(0, Math.min(offsets.length - 2, low));
+}
+function findLastIndexStartingBefore(offsets, value) {
+  let low = 0;
+  let high = Math.max(0, offsets.length - 2);
+  let result = 0;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if ((offsets[mid] ?? 0) < value) {
+      result = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return result;
+}
+export {
+  createMeasuredSizeCache,
+  createMeasuredSizeResolver,
+  getColumnCellRenderItems,
+  getColumnLayoutMeasurementSignature,
+  getColumnRenderItemKey,
+  getColumnRenderItems,
+  getHeaderRenderItemKey,
+  getHeaderRenderItems,
+  getInitialScrollFrame,
+  getIsFocusedCellInRenderWindow,
+  getMeasuredColumnLayout,
+  getMeasuredColumnLayoutFromCache,
+  getScrollFrame,
+  getSizedColumnLayout,
+  getVirtualRange,
+  getVirtualRowItems,
+  getVirtualRowRange,
+  isColumnRenderSpacerItem,
+  isHeaderRenderSpacerItem,
+  syncMeasuredColumnLayoutCache
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@open-grid/virtual",
+  "version": "0.1.0",
+  "description": "Framework-agnostic virtualization primitives for Open Grid.",
+  "keywords": [
+    "data-grid",
+    "grid",
+    "table",
+    "virtualization",
+    "typescript"
+  ],
+  "homepage": "https://goatshave.github.io/open-grid/packages#virtual",
+  "bugs": {
+    "url": "https://github.com/Goatshave/open-grid/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "check": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "lint": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Goatshave/open-grid.git",
+    "directory": "packages/virtual"
+  }
+}