@tanstack/virtual-core 3.0.0-beta.22 → 3.0.0-beta.26

package/build/stats.json

@@ -1,76 +0,0 @@
-{
-  "version": 2,
-  "tree": {
-    "name": "root",
-    "children": [
-      {
-        "name": "index.production.js",
-        "children": [
-          {
-            "name": "packages/virtual-core/src",
-            "children": [
-              {
-                "uid": "07ec-5",
-                "name": "utils.ts"
-              },
-              {
-                "uid": "07ec-7",
-                "name": "index.ts"
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "isRoot": true
-  },
-  "nodeParts": {
-    "07ec-5": {
-      "renderedLength": 1432,
-      "gzipLength": 544,
-      "brotliLength": 0,
-      "mainUid": "07ec-4"
-    },
-    "07ec-7": {
-      "renderedLength": 17482,
-      "gzipLength": 3850,
-      "brotliLength": 0,
-      "mainUid": "07ec-6"
-    }
-  },
-  "nodeMetas": {
-    "07ec-4": {
-      "id": "/packages/virtual-core/src/utils.ts",
-      "moduleParts": {
-        "index.production.js": "07ec-5"
-      },
-      "imported": [],
-      "importedBy": [
-        {
-          "uid": "07ec-6"
-        }
-      ]
-    },
-    "07ec-6": {
-      "id": "/packages/virtual-core/src/index.ts",
-      "moduleParts": {
-        "index.production.js": "07ec-7"
-      },
-      "imported": [
-        {
-          "uid": "07ec-4"
-        }
-      ],
-      "importedBy": [],
-      "isEntry": true
-    }
-  },
-  "env": {
-    "rollup": "2.75.4"
-  },
-  "options": {
-    "gzip": true,
-    "brotli": false,
-    "sourcemap": false
-  }
-}

package/build/types/index.d.ts

@@ -1,131 +0,0 @@
-/**
- * virtual-core
- *
- * Copyright (c) TanStack
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-declare type NoInfer<A extends any> = [A][A extends any ? 0 : never];
-declare type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-declare function memo<TDeps extends readonly any[], TResult>(getDeps: () => [...TDeps], fn: (...args: NoInfer<[...TDeps]>) => TResult, opts: {
-    key: any;
-    debug?: () => any;
-    onChange?: (result: TResult) => void;
-}): () => TResult;
-
-declare type ScrollAlignment = 'start' | 'center' | 'end' | 'auto';
-interface ScrollToOptions {
-    align?: ScrollAlignment;
-    smoothScroll?: boolean;
-}
-declare type ScrollToOffsetOptions = ScrollToOptions;
-declare type ScrollToIndexOptions = ScrollToOptions;
-interface Range {
-    startIndex: number;
-    endIndex: number;
-    overscan: number;
-    count: number;
-}
-declare type Key = number | string;
-interface VirtualItem {
-    key: Key;
-    index: number;
-    start: number;
-    end: number;
-    size: number;
-}
-interface Rect {
-    width: number;
-    height: number;
-}
-declare const defaultKeyExtractor: (index: number) => number;
-declare const defaultRangeExtractor: (range: Range) => number[];
-declare const observeElementRect: (instance: Virtualizer<any, any>, cb: (rect: Rect) => void) => (() => void) | undefined;
-declare const observeWindowRect: (instance: Virtualizer<any, any>, cb: (rect: Rect) => void) => (() => void) | undefined;
-declare const observeElementOffset: (instance: Virtualizer<any, any>, cb: (offset: number) => void) => (() => void) | undefined;
-declare const observeWindowOffset: (instance: Virtualizer<any, any>, cb: (offset: number) => void) => (() => void) | undefined;
-declare const measureElement: <TItemElement extends Element>(element: TItemElement, instance: Virtualizer<any, TItemElement>) => number;
-declare const windowScroll: (offset: number, { canSmooth, sync }: {
-    canSmooth: boolean;
-    sync: boolean;
-}, instance: Virtualizer<any, any>) => void;
-declare const elementScroll: (offset: number, { canSmooth, sync }: {
-    canSmooth: boolean;
-    sync: boolean;
-}, instance: Virtualizer<any, any>) => void;
-interface VirtualizerOptions<TScrollElement extends unknown, TItemElement extends Element> {
-    count: number;
-    getScrollElement: () => TScrollElement | null;
-    estimateSize: (index: number) => number;
-    scrollToFn: (offset: number, options: {
-        canSmooth: boolean;
-        sync: boolean;
-    }, instance: Virtualizer<TScrollElement, TItemElement>) => void;
-    observeElementRect: (instance: Virtualizer<TScrollElement, TItemElement>, cb: (rect: Rect) => void) => void | (() => void);
-    observeElementOffset: (instance: Virtualizer<TScrollElement, TItemElement>, cb: (offset: number) => void) => void | (() => void);
-    debug?: any;
-    initialRect?: Rect;
-    onChange?: (instance: Virtualizer<TScrollElement, TItemElement>) => void;
-    measureElement?: (el: TItemElement, instance: Virtualizer<TScrollElement, TItemElement>) => number;
-    overscan?: number;
-    horizontal?: boolean;
-    paddingStart?: number;
-    paddingEnd?: number;
-    scrollPaddingStart?: number;
-    scrollPaddingEnd?: number;
-    initialOffset?: number;
-    getItemKey?: (index: number) => Key;
-    rangeExtractor?: (range: Range) => number[];
-    enableSmoothScroll?: boolean;
-    scrollMargin?: number;
-    scrollingDelay?: number;
-    indexAttribute?: string;
-}
-declare class Virtualizer<TScrollElement extends unknown, TItemElement extends Element> {
-    private unsubs;
-    options: Required<VirtualizerOptions<TScrollElement, TItemElement>>;
-    scrollElement: TScrollElement | null;
-    isScrolling: boolean;
-    private isScrollingTimeoutId;
-    measurementsCache: VirtualItem[];
-    private itemMeasurementsCache;
-    private pendingMeasuredCacheIndexes;
-    private scrollRect;
-    private scrollOffset;
-    private scrollDelta;
-    private destinationOffset;
-    private scrollCheckFrame;
-    private measureElementCache;
-    private getResizeObserver;
-    range: {
-        startIndex: number;
-        endIndex: number;
-    };
-    constructor(opts: VirtualizerOptions<TScrollElement, TItemElement>);
-    setOptions: (opts: VirtualizerOptions<TScrollElement, TItemElement>) => void;
-    private notify;
-    private cleanup;
-    _didMount: () => () => void;
-    _willUpdate: () => void;
-    private getSize;
-    private getMeasurements;
-    calculateRange: () => {
-        startIndex: number;
-        endIndex: number;
-    };
-    private getIndexes;
-    indexFromElement: (node: TItemElement) => number;
-    private _measureElement;
-    measureElement: (node: TItemElement | null) => void;
-    getVirtualItems: () => VirtualItem[];
-    scrollToOffset: (toOffset: number, { align, smoothScroll, }?: ScrollToOffsetOptions) => void;
-    scrollToIndex: (index: number, { align, smoothScroll, ...rest }?: ScrollToIndexOptions) => void;
-    getTotalSize: () => number;
-    private _scrollToOffset;
-    measure: () => void;
-}
-
-export { NoInfer, PartialKeys, Range, ScrollToOptions, VirtualItem, Virtualizer, VirtualizerOptions, defaultKeyExtractor, defaultRangeExtractor, elementScroll, measureElement, memo, observeElementOffset, observeElementRect, observeWindowOffset, observeWindowRect, windowScroll };