@difizen/libro-virtualized 0.1.2

package/es/grid/index.d.ts

@@ -0,0 +1,6 @@
+export { default as accessibilityOverscanIndicesGetter } from './accessibility-overscanIndices-getter.js';
+export { default as defaultCellRangeRenderer } from './default-cell-range-renderer.js';
+export { default as defaultOverscanIndicesGetter } from './default-overscanIndices-getter.js';
+export { default, default as Grid } from './grid.js';
+export type { Alignment, CellPosition, CellRendererParams, CellSize, NoContentRenderer, OverscanIndicesGetter, RenderedSection, Scroll, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/es/grid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/grid/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,kCAAkC,EAAE,MAAM,2CAA2C,CAAC;AAC1G,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AAC9F,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAC;AACrD,YAAY,EACV,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,QAAQ,EACR,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,MAAM,GACP,MAAM,YAAY,CAAC"}

package/es/grid/index.js

@@ -0,0 +1,4 @@
+export { default as accessibilityOverscanIndicesGetter } from "./accessibility-overscanIndices-getter.js";
+export { default as defaultCellRangeRenderer } from "./default-cell-range-renderer.js";
+export { default as defaultOverscanIndicesGetter } from "./default-overscanIndices-getter.js";
+export { default, default as Grid } from "./grid.js";

package/es/grid/types.d.ts

@@ -0,0 +1,87 @@
+import type * as React from 'react';
+import type ScalingCellSizeAndPositionManager from './utils/scaling-cell-size-and-position-manager.js';
+export type CellPosition = {
+    columnIndex: number;
+    rowIndex: number;
+};
+export type CellRendererParams = {
+    columnIndex: number;
+    isScrolling: boolean;
+    isVisible: boolean;
+    key: string;
+    parent: object;
+    rowIndex: number;
+    style: object;
+};
+export type CellRenderer = (props: CellRendererParams) => React.ReactNode;
+export type CellCache = Record<string, React.ReactNode>;
+export type StyleCache = Record<string, object>;
+export type CellRangeRendererParams = {
+    cellCache: CellCache;
+    cellRenderer: CellRenderer;
+    columnSizeAndPositionManager: ScalingCellSizeAndPositionManager;
+    columnStartIndex: number;
+    columnStopIndex: number;
+    deferredMeasurementCache?: object;
+    horizontalOffsetAdjustment: number;
+    isScrolling: boolean;
+    isScrollingOptOut: boolean;
+    parent: object;
+    rowSizeAndPositionManager: ScalingCellSizeAndPositionManager;
+    rowStartIndex: number;
+    rowStopIndex: number;
+    scrollLeft: number;
+    scrollTop: number;
+    styleCache: StyleCache;
+    verticalOffsetAdjustment: number;
+    visibleColumnIndices: Record<any, any>;
+    visibleRowIndices: Record<any, any>;
+};
+export type CellRangeRenderer = (params: CellRangeRendererParams) => React.ReactNode[];
+export type CellSizeGetter = (params: {
+    index: number;
+}) => number;
+export type CellSize = CellSizeGetter | number;
+export type NoContentRenderer = () => React.ReactNode | null;
+export type Scroll = {
+    clientHeight: number;
+    clientWidth: number;
+    scrollHeight: number;
+    scrollLeft: number;
+    scrollTop: number;
+    scrollWidth: number;
+};
+export type ScrollbarPresenceChange = {
+    horizontal: boolean;
+    vertical: boolean;
+    size: number;
+};
+export type RenderedSection = {
+    columnOverscanStartIndex: number;
+    columnOverscanStopIndex: number;
+    columnStartIndex: number;
+    columnStopIndex: number;
+    rowOverscanStartIndex: number;
+    rowOverscanStopIndex: number;
+    rowStartIndex: number;
+    rowStopIndex: number;
+};
+export type OverscanIndicesGetterParams = {
+    direction: 'horizontal' | 'vertical';
+    scrollDirection: -1 | 1;
+    cellCount: number;
+    overscanCellsCount: number;
+    startIndex: number;
+    stopIndex: number;
+};
+export type OverscanIndices = {
+    overscanStartIndex: number;
+    overscanStopIndex: number;
+};
+export type OverscanIndicesGetter = (params: OverscanIndicesGetterParams) => OverscanIndices;
+export type Alignment = 'auto' | 'end' | 'start' | 'center';
+export type VisibleCellRange = {
+    start?: number;
+    stop?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/es/grid/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/grid/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAEpC,OAAO,KAAK,iCAAiC,MAAM,mDAAmD,CAAC;AAEvG,MAAM,MAAM,YAAY,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,KAAK,CAAC,SAAS,CAAC;AAE1E,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;AACxD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEhD,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,4BAA4B,EAAE,iCAAiC,CAAC;IAChE,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,0BAA0B,EAAE,MAAM,CAAC;IACnC,WAAW,EAAE,OAAO,CAAC;IACrB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,yBAAyB,EAAE,iCAAiC,CAAC;IAC7D,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,wBAAwB,EAAE,MAAM,CAAC;IACjC,oBAAoB,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACvC,iBAAiB,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,MAAM,EAAE,uBAAuB,KAAK,KAAK,CAAC,SAAS,EAAE,CAAC;AAEvF,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,KAAK,MAAM,CAAC;AAEnE,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,MAAM,CAAC;AAE/C,MAAM,MAAM,iBAAiB,GAAG,MAAM,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC;AAE7D,MAAM,MAAM,MAAM,GAAG;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,wBAAwB,EAAE,MAAM,CAAC;IACjC,uBAAuB,EAAE,MAAM,CAAC;IAChC,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IAExC,SAAS,EAAE,YAAY,GAAG,UAAU,CAAC;IAGrC,eAAe,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;IAGxB,SAAS,EAAE,MAAM,CAAC;IAGlB,kBAAkB,EAAE,MAAM,CAAC;IAG3B,UAAU,EAAE,MAAM,CAAC;IAGnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAClC,MAAM,EAAE,2BAA2B,KAChC,eAAe,CAAC;AAErB,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC"}

package/es/grid/types.js

@@ -0,0 +1 @@
+export {};

package/es/grid/utils/calculate-size-and-position-data-and-update-scroll-offset.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Helper method that determines when to recalculate row or column metadata.
+ */
+type Params<T> = {
+    cellCount: number;
+    cellSize?: number | null;
+    computeMetadataCallback: (props: T) => void;
+    computeMetadataCallbackProps: T;
+    nextCellsCount: number;
+    nextCellSize?: number | null;
+    nextScrollToIndex: number;
+    scrollToIndex: number;
+    updateScrollOffsetForScrollToIndex: () => void;
+};
+export default function calculateSizeAndPositionDataAndUpdateScrollOffset({ cellCount, cellSize, computeMetadataCallback, computeMetadataCallbackProps, nextCellsCount, nextCellSize, nextScrollToIndex, scrollToIndex, updateScrollOffsetForScrollToIndex, }: Params<any>): void;
+export {};
+//# sourceMappingURL=calculate-size-and-position-data-and-update-scroll-offset.d.ts.map

package/es/grid/utils/calculate-size-and-position-data-and-update-scroll-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-size-and-position-data-and-update-scroll-offset.d.ts","sourceRoot":"","sources":["../../../src/grid/utils/calculate-size-and-position-data-and-update-scroll-offset.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH,KAAK,MAAM,CAAC,CAAC,IAAI;IAEf,SAAS,EAAE,MAAM,CAAC;IAGlB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAGzB,uBAAuB,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAG5C,4BAA4B,EAAE,CAAC,CAAC;IAGhC,cAAc,EAAE,MAAM,CAAC;IAGvB,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAG7B,iBAAiB,EAAE,MAAM,CAAC;IAG1B,aAAa,EAAE,MAAM,CAAC;IAGtB,kCAAkC,EAAE,MAAM,IAAI,CAAC;CAChD,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,iDAAiD,CAAC,EACxE,SAAS,EACT,QAAQ,EACR,uBAAuB,EACvB,4BAA4B,EAC5B,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,kCAAkC,GACnC,EAAE,MAAM,CAAC,GAAG,CAAC,QAgBb"}

package/es/grid/utils/calculate-size-and-position-data-and-update-scroll-offset.js

@@ -0,0 +1,25 @@
+/**
+ * Helper method that determines when to recalculate row or column metadata.
+ */
+export default function calculateSizeAndPositionDataAndUpdateScrollOffset(_ref) {
+  var cellCount = _ref.cellCount,
+    cellSize = _ref.cellSize,
+    computeMetadataCallback = _ref.computeMetadataCallback,
+    computeMetadataCallbackProps = _ref.computeMetadataCallbackProps,
+    nextCellsCount = _ref.nextCellsCount,
+    nextCellSize = _ref.nextCellSize,
+    nextScrollToIndex = _ref.nextScrollToIndex,
+    scrollToIndex = _ref.scrollToIndex,
+    updateScrollOffsetForScrollToIndex = _ref.updateScrollOffsetForScrollToIndex;
+  // Don't compare cell sizes if they are functions because inline functions would cause infinite loops.
+  // In that event users should use the manual recompute methods to inform of changes.
+  if (cellCount !== nextCellsCount || (typeof cellSize === 'number' || typeof nextCellSize === 'number') && cellSize !== nextCellSize) {
+    computeMetadataCallback(computeMetadataCallbackProps);
+
+    // Updated cell metadata may have hidden the previous scrolled-to item.
+    // In this case we should also update the scrollTop to ensure it stays visible.
+    if (scrollToIndex >= 0 && scrollToIndex === nextScrollToIndex) {
+      updateScrollOffsetForScrollToIndex();
+    }
+  }
+}

package/es/grid/utils/cell-size-and-position-manager-row.d.ts

@@ -0,0 +1,97 @@
+import type { Alignment, CellSizeGetter, VisibleCellRange } from '../types.js';
+type CellSizeAndPositionManagerParams = {
+    cellCount: number;
+    cellSizeGetter: CellSizeGetter;
+    estimatedCellSize: number;
+    cellsHeight: number[];
+    editorAreaHeight: number[];
+    totalSize: number;
+    editorsOffset: number[];
+};
+type ConfigureParams = {
+    cellCount: number;
+    estimatedCellSize: number;
+    cellSizeGetter: CellSizeGetter;
+    cellsHeight: number[];
+    editorAreaHeight: number[];
+    totalSize: number;
+    editorsOffset: number[];
+};
+type GetUpdatedOffsetForIndex = {
+    align: Alignment;
+    containerSize: number;
+    currentOffset: number;
+    targetIndex: number;
+};
+type GetVisibleCellRangeParams = {
+    containerSize: number;
+    offset: number;
+};
+type SizeAndPositionData = {
+    offset: number;
+    size: number;
+};
+/**
+ * Just-in-time calculates and caches size and position information for a collection of cells.
+ */
+export default class RowCellSizeAndPositionManager {
+    _cellSizeAndPositionData: any;
+    _lastMeasuredIndex: number;
+    _lastBatchedIndex: number;
+    _cellCount: number;
+    _cellSizeGetter: CellSizeGetter;
+    _estimatedCellSize: number;
+    _cellsHeight: number[];
+    _editorAreaHeight: number[];
+    _totalSize: number;
+    _editorsOffset: number[];
+    constructor({ cellCount, cellSizeGetter, estimatedCellSize, cellsHeight, editorAreaHeight, totalSize, editorsOffset, }: CellSizeAndPositionManagerParams);
+    areOffsetsAdjusted(): boolean;
+    configure({ cellCount, estimatedCellSize, cellSizeGetter, cellsHeight, editorAreaHeight, totalSize, editorsOffset, }: ConfigureParams): void;
+    getCellCount(): number;
+    getEstimatedCellSize(): number;
+    getLastMeasuredIndex(): number;
+    getOffsetAdjustment(): number;
+    /**
+     * This method returns the size and position for the cell at the specified index.
+     * It just-in-time calculates (or used cached values) for cells leading up to the index.
+     */
+    getSizeAndPositionOfCell(index: number): SizeAndPositionData;
+    getSizeAndPositionOfLastMeasuredCell(): SizeAndPositionData;
+    /**
+     * Total size of all cells being measured.
+     * This value will be completely estimated initially.
+     * As cells are measured, the estimate will be updated.
+     */
+    getTotalSize(): number;
+    /**
+     * Determines a new offset that ensures a certain cell is visible, given the current offset.
+     * If the cell is already visible then the current offset will be returned.
+     * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.
+     *
+     * @param align Desired alignment within container; one of "auto" (default), "start", or "end"
+     * @param containerSize Size (width or height) of the container viewport
+     * @param currentOffset Container's current (x or y) offset
+     * @param totalSize Total size (width or height) of all cells
+     * @return Offset to use to ensure the specified cell is visible
+     */
+    getUpdatedOffsetForIndex({ align, containerSize, currentOffset, targetIndex, }: GetUpdatedOffsetForIndex): number;
+    getVisibleCellRange(params: GetVisibleCellRangeParams): VisibleCellRange;
+    /**
+     * Clear all cached values for cells after the specified index.
+     * This method should be called for any cell that has changed its size.
+     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called.
+     */
+    resetCell(index: number): void;
+    _binarySearch(high: number, low: number, offset: number): number;
+    _exponentialSearch(index: number, offset: number): number;
+    /**
+     * Searches for the cell (index) nearest the specified offset.
+     *
+     * If no exact match is found the next lowest cell index will be returned.
+     * This allows partially visible cells (with offsets just before/above the fold) to be visible.
+     */
+    _findNearestCell(offset: number): number;
+}
+export {};
+//# sourceMappingURL=cell-size-and-position-manager-row.d.ts.map

package/es/grid/utils/cell-size-and-position-manager-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-size-and-position-manager-row.d.ts","sourceRoot":"","sources":["../../../src/grid/utils/cell-size-and-position-manager-row.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/E,KAAK,gCAAgC,GAAG;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AAEH,MAAM,CAAC,OAAO,OAAO,6BAA6B;IAGhD,wBAAwB,EAAE,GAAG,CAAM;IAGnC,kBAAkB,SAAM;IAGxB,iBAAiB,SAAM;IAEvB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,cAAc,CAAC;IAChC,kBAAkB,EAAE,MAAM,CAAC;IAE3B,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAE5B,UAAU,EAAE,MAAM,CAAC;IAEnB,cAAc,EAAE,MAAM,EAAE,CAAC;gBAEb,EACV,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,aAAa,GACd,EAAE,gCAAgC;IAmBnC,kBAAkB;IAIlB,SAAS,CAAC,EACR,SAAS,EACT,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,aAAa,GACd,EAAE,eAAe;IAelB,YAAY,IAAI,MAAM;IAItB,oBAAoB,IAAI,MAAM;IAI9B,oBAAoB,IAAI,MAAM;IAI9B,mBAAmB;IAInB;;;OAGG;IACH,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB;IAwC5D,oCAAoC,IAAI,mBAAmB;IAS3D;;;;OAIG;IACH,YAAY,IAAI,MAAM;IAWtB;;;;;;;;;;OAUG;IACH,wBAAwB,CAAC,EACvB,KAAc,EACd,aAAa,EACb,aAAa,EACb,WAAW,GACZ,EAAE,wBAAwB,GAAG,MAAM;IAgCpC,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,gBAAgB;IA6BxE;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI9B,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAuBhE,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAkBzD;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAsBzC"}

package/es/grid/utils/cell-size-and-position-manager-row.js

@@ -0,0 +1,297 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint-disable prefer-const */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-param-reassign */
+/**
+ * Just-in-time calculates and caches size and position information for a collection of cells.
+ */
+var RowCellSizeAndPositionManager = /*#__PURE__*/function () {
+  function RowCellSizeAndPositionManager(_ref) {
+    var cellCount = _ref.cellCount,
+      cellSizeGetter = _ref.cellSizeGetter,
+      estimatedCellSize = _ref.estimatedCellSize,
+      cellsHeight = _ref.cellsHeight,
+      editorAreaHeight = _ref.editorAreaHeight,
+      totalSize = _ref.totalSize,
+      editorsOffset = _ref.editorsOffset;
+    _classCallCheck(this, RowCellSizeAndPositionManager);
+    // Cache of size and position data for cells, mapped by cell index.
+    // Note that invalid values may exist in this map so only rely on cells up to this._lastMeasuredIndex
+    this._cellSizeAndPositionData = {};
+    // Measurements for cells up to this index can be trusted; cells afterward should be estimated.
+    this._lastMeasuredIndex = -1;
+    // Used in deferred mode to track which cells have been queued for measurement.
+    this._lastBatchedIndex = -1;
+    // this._cellSizeGetter = cellSizeGetter;
+    this._cellCount = cellCount;
+    this._estimatedCellSize = estimatedCellSize;
+    this._cellsHeight = cellsHeight;
+    this._editorAreaHeight = editorAreaHeight;
+    this._editorsOffset = editorsOffset;
+    this._totalSize = totalSize;
+    this._lastMeasuredIndex = -1;
+    this._cellSizeAndPositionData = {};
+
+    // this._cellSizeGetter = (params: { index: number }) => {
+    //   // return this._cellsHeight[params.index];
+    //   return this._editorAreaHeight[params.index];
+    // };
+  }
+  _createClass(RowCellSizeAndPositionManager, [{
+    key: "areOffsetsAdjusted",
+    value: function areOffsetsAdjusted() {
+      return false;
+    }
+  }, {
+    key: "configure",
+    value: function configure(_ref2) {
+      var cellCount = _ref2.cellCount,
+        estimatedCellSize = _ref2.estimatedCellSize,
+        cellSizeGetter = _ref2.cellSizeGetter,
+        cellsHeight = _ref2.cellsHeight,
+        editorAreaHeight = _ref2.editorAreaHeight,
+        totalSize = _ref2.totalSize,
+        editorsOffset = _ref2.editorsOffset;
+      this._cellCount = cellCount;
+      this._estimatedCellSize = estimatedCellSize;
+      // this._cellSizeGetter = cellSizeGetter;
+      this._cellsHeight = cellsHeight;
+      this._editorAreaHeight = editorAreaHeight;
+      this._editorsOffset = editorsOffset;
+      this._totalSize = totalSize;
+      this._lastMeasuredIndex = -1;
+      this._cellSizeAndPositionData = {};
+    }
+  }, {
+    key: "getCellCount",
+    value: function getCellCount() {
+      return this._cellCount;
+    }
+  }, {
+    key: "getEstimatedCellSize",
+    value: function getEstimatedCellSize() {
+      return this._estimatedCellSize;
+    }
+  }, {
+    key: "getLastMeasuredIndex",
+    value: function getLastMeasuredIndex() {
+      return this._lastMeasuredIndex;
+    }
+  }, {
+    key: "getOffsetAdjustment",
+    value: function getOffsetAdjustment() {
+      return 0;
+    }
+
+    /**
+     * This method returns the size and position for the cell at the specified index.
+     * It just-in-time calculates (or used cached values) for cells leading up to the index.
+     */
+  }, {
+    key: "getSizeAndPositionOfCell",
+    value: function getSizeAndPositionOfCell(index) {
+      if (index < 0 || index >= this._cellCount) {
+        throw Error("Requested index ".concat(index, " is outside of range 0..").concat(this._cellCount));
+      }
+      if (index > this._lastMeasuredIndex) {
+        var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+        var offset = lastMeasuredCellSizeAndPosition.offset; // + lastMeasuredCellSizeAndPosition.size;
+
+        for (var i = this._lastMeasuredIndex + 1; i <= index; i++) {
+          // const size = this._cellSizeGetter({ index: i });
+          var size = this._editorAreaHeight[i];
+          offset = this._editorsOffset[i]; // 上border高度
+
+          // undefined or NaN probably means a logic error in the size getter.
+          // null means we're using CellMeasurer and haven't yet measured a given index.
+          if (size === undefined || isNaN(size)) {
+            throw Error("Invalid size returned for cell ".concat(i, " of value ").concat(size));
+          } else if (size === null) {
+            this._cellSizeAndPositionData[i] = {
+              offset: offset,
+              size: 0
+            };
+            this._lastBatchedIndex = index;
+          } else {
+            this._cellSizeAndPositionData[i] = {
+              offset: offset,
+              size: size
+            };
+            this._lastMeasuredIndex = index;
+          }
+        }
+      }
+      return this._cellSizeAndPositionData[index];
+    }
+  }, {
+    key: "getSizeAndPositionOfLastMeasuredCell",
+    value: function getSizeAndPositionOfLastMeasuredCell() {
+      return this._lastMeasuredIndex >= 0 ? this._cellSizeAndPositionData[this._lastMeasuredIndex] : {
+        offset: 0,
+        size: 0
+      };
+    }
+
+    /**
+     * Total size of all cells being measured.
+     * This value will be completely estimated initially.
+     * As cells are measured, the estimate will be updated.
+     */
+  }, {
+    key: "getTotalSize",
+    value: function getTotalSize() {
+      return this._totalSize;
+
+      // const lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+      // const totalSizeOfMeasuredCells =
+      //   lastMeasuredCellSizeAndPosition.offset + lastMeasuredCellSizeAndPosition.size;
+      // const numUnmeasuredCells = this._cellCount - this._lastMeasuredIndex - 1;
+      // const totalSizeOfUnmeasuredCells = numUnmeasuredCells * this._estimatedCellSize;
+      // return totalSizeOfMeasuredCells + totalSizeOfUnmeasuredCells;
+    }
+
+    /**
+     * Determines a new offset that ensures a certain cell is visible, given the current offset.
+     * If the cell is already visible then the current offset will be returned.
+     * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.
+     *
+     * @param align Desired alignment within container; one of "auto" (default), "start", or "end"
+     * @param containerSize Size (width or height) of the container viewport
+     * @param currentOffset Container's current (x or y) offset
+     * @param totalSize Total size (width or height) of all cells
+     * @return Offset to use to ensure the specified cell is visible
+     */
+  }, {
+    key: "getUpdatedOffsetForIndex",
+    value: function getUpdatedOffsetForIndex(_ref3) {
+      var _ref3$align = _ref3.align,
+        align = _ref3$align === void 0 ? 'auto' : _ref3$align,
+        containerSize = _ref3.containerSize,
+        currentOffset = _ref3.currentOffset,
+        targetIndex = _ref3.targetIndex;
+      if (containerSize <= 0) {
+        return 0;
+      }
+      var datum = this.getSizeAndPositionOfCell(targetIndex);
+      var minOffset = datum.offset;
+      var maxOffset = datum.offset + datum.size - containerSize;
+      var idealOffset;
+      switch (align) {
+        case 'start':
+          idealOffset = minOffset;
+          break;
+        case 'end':
+          idealOffset = maxOffset;
+          break;
+        case 'center':
+          idealOffset = minOffset + datum.size / 2;
+          break;
+        default:
+          idealOffset = minOffset;
+          break;
+      }
+      var totalSize = this.getTotalSize();
+      return Math.max(0, Math.min(totalSize - containerSize, idealOffset));
+    }
+  }, {
+    key: "getVisibleCellRange",
+    value: function getVisibleCellRange(params) {
+      var containerSize = params.containerSize,
+        offset = params.offset;
+      var totalSize = this.getTotalSize();
+      if (totalSize === 0) {
+        return {};
+      }
+      var maxOffset = offset + containerSize;
+      var start = this._findNearestCell(offset);
+      var datum = this.getSizeAndPositionOfCell(start);
+      offset = datum.offset;
+      var stop = start;
+      while (offset < maxOffset && stop < this._cellCount - 1) {
+        stop++;
+        offset = this.getSizeAndPositionOfCell(stop).offset;
+      }
+      return {
+        start: start,
+        stop: stop
+      };
+    }
+
+    /**
+     * Clear all cached values for cells after the specified index.
+     * This method should be called for any cell that has changed its size.
+     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called.
+     */
+  }, {
+    key: "resetCell",
+    value: function resetCell(index) {
+      this._lastMeasuredIndex = Math.min(this._lastMeasuredIndex, index - 1);
+    }
+  }, {
+    key: "_binarySearch",
+    value: function _binarySearch(high, low, offset) {
+      while (low <= high) {
+        var middle = low + Math.floor((high - low) / 2);
+        var currentOffset = this.getSizeAndPositionOfCell(middle).offset || (middle > 0 ? this.getSizeAndPositionOfCell(middle - 1).offset || 0 : 0);
+        if (currentOffset === offset) {
+          return middle;
+        } else if (currentOffset < offset) {
+          low = middle + 1;
+        } else if (currentOffset > offset) {
+          high = middle - 1;
+        }
+      }
+      if (low > 0) {
+        return low - 1;
+      } else {
+        return 0;
+      }
+    }
+  }, {
+    key: "_exponentialSearch",
+    value: function _exponentialSearch(index, offset) {
+      var interval = 1;
+      while (index < this._cellCount && this.getSizeAndPositionOfCell(index).offset < offset) {
+        index += interval;
+        interval *= 2;
+      }
+      return this._binarySearch(Math.min(index, this._cellCount - 1), Math.floor(index / 2), offset);
+    }
+
+    /**
+     * Searches for the cell (index) nearest the specified offset.
+     *
+     * If no exact match is found the next lowest cell index will be returned.
+     * This allows partially visible cells (with offsets just before/above the fold) to be visible.
+     */
+  }, {
+    key: "_findNearestCell",
+    value: function _findNearestCell(offset) {
+      if (isNaN(offset)) {
+        throw Error("Invalid offset ".concat(offset, " specified"));
+      }
+
+      // Our search algorithms find the nearest match at or below the specified offset.
+      // So make sure the offset is at least 0 or no match will be found.
+      offset = Math.max(0, offset);
+      var lastMeasuredCellSizeAndPosition = this.getSizeAndPositionOfLastMeasuredCell();
+      var lastMeasuredIndex = Math.max(0, this._lastMeasuredIndex);
+      if (lastMeasuredCellSizeAndPosition.offset >= offset) {
+        // If we've already measured cells within this range just use a binary search as it's faster.
+        return this._binarySearch(lastMeasuredIndex, 0, offset);
+      } else {
+        // If we haven't yet measured this high, fallback to an exponential search with an inner binary search.
+        // The exponential search avoids pre-computing sizes for the full set of cells as a binary search would.
+        // The overall complexity for this approach is O(log n).
+        return this._exponentialSearch(lastMeasuredIndex, offset);
+      }
+    }
+  }]);
+  return RowCellSizeAndPositionManager;
+}();
+export { RowCellSizeAndPositionManager as default };

package/es/grid/utils/cell-size-and-position-manager.d.ts

@@ -0,0 +1,85 @@
+import type { Alignment, CellSizeGetter, VisibleCellRange } from '../types.js';
+type CellSizeAndPositionManagerParams = {
+    cellCount: number;
+    cellSizeGetter: CellSizeGetter;
+    estimatedCellSize: number;
+};
+type ConfigureParams = {
+    cellCount: number;
+    estimatedCellSize: number;
+    cellSizeGetter: CellSizeGetter;
+};
+type GetUpdatedOffsetForIndex = {
+    align: Alignment;
+    containerSize: number;
+    currentOffset: number;
+    targetIndex: number;
+};
+type GetVisibleCellRangeParams = {
+    containerSize: number;
+    offset: number;
+};
+type SizeAndPositionData = {
+    offset: number;
+    size: number;
+};
+/**
+ * Just-in-time calculates and caches size and position information for a collection of cells.
+ */
+export default class CellSizeAndPositionManager {
+    _cellSizeAndPositionData: any;
+    _lastMeasuredIndex: number;
+    _lastBatchedIndex: number;
+    _cellCount: number;
+    _cellSizeGetter: CellSizeGetter;
+    _estimatedCellSize: number;
+    constructor({ cellCount, cellSizeGetter, estimatedCellSize, }: CellSizeAndPositionManagerParams);
+    areOffsetsAdjusted(): boolean;
+    configure({ cellCount, estimatedCellSize, cellSizeGetter }: ConfigureParams): void;
+    getCellCount(): number;
+    getEstimatedCellSize(): number;
+    getLastMeasuredIndex(): number;
+    getOffsetAdjustment(): number;
+    /**
+     * This method returns the size and position for the cell at the specified index.
+     * It just-in-time calculates (or used cached values) for cells leading up to the index.
+     */
+    getSizeAndPositionOfCell(index: number): SizeAndPositionData;
+    getSizeAndPositionOfLastMeasuredCell(): SizeAndPositionData;
+    /**
+     * Total size of all cells being measured.
+     * This value will be completely estimated initially.
+     * As cells are measured, the estimate will be updated.
+     */
+    getTotalSize(): number;
+    /**
+     * Determines a new offset that ensures a certain cell is visible, given the current offset.
+     * If the cell is already visible then the current offset will be returned.
+     * If the current offset is too great or small, it will be adjusted just enough to ensure the specified index is visible.
+     *
+     * @param align Desired alignment within container; one of "auto" (default), "start", or "end"
+     * @param containerSize Size (width or height) of the container viewport
+     * @param currentOffset Container's current (x or y) offset
+     * @param totalSize Total size (width or height) of all cells
+     * @return Offset to use to ensure the specified cell is visible
+     */
+    getUpdatedOffsetForIndex({ align, containerSize, currentOffset, targetIndex, }: GetUpdatedOffsetForIndex): number;
+    getVisibleCellRange(params: GetVisibleCellRangeParams): VisibleCellRange;
+    /**
+     * Clear all cached values for cells after the specified index.
+     * This method should be called for any cell that has changed its size.
+     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionOfCell() is called.
+     */
+    resetCell(index: number): void;
+    _binarySearch(high: number, low: number, offset: number): number;
+    _exponentialSearch(index: number, offset: number): number;
+    /**
+     * Searches for the cell (index) nearest the specified offset.
+     *
+     * If no exact match is found the next lowest cell index will be returned.
+     * This allows partially visible cells (with offsets just before/above the fold) to be visible.
+     */
+    _findNearestCell(offset: number): number;
+}
+export {};
+//# sourceMappingURL=cell-size-and-position-manager.d.ts.map

package/es/grid/utils/cell-size-and-position-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-size-and-position-manager.d.ts","sourceRoot":"","sources":["../../../src/grid/utils/cell-size-and-position-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/E,KAAK,gCAAgC,GAAG;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,cAAc,CAAC;CAChC,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AAEH,MAAM,CAAC,OAAO,OAAO,0BAA0B;IAG7C,wBAAwB,EAAE,GAAG,CAAM;IAGnC,kBAAkB,SAAM;IAGxB,iBAAiB,SAAM;IAEvB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,cAAc,CAAC;IAChC,kBAAkB,EAAE,MAAM,CAAC;gBAEf,EACV,SAAS,EACT,cAAc,EACd,iBAAiB,GAClB,EAAE,gCAAgC;IAMnC,kBAAkB;IAIlB,SAAS,CAAC,EAAE,SAAS,EAAE,iBAAiB,EAAE,cAAc,EAAE,EAAE,eAAe;IAM3E,YAAY,IAAI,MAAM;IAItB,oBAAoB,IAAI,MAAM;IAI9B,oBAAoB,IAAI,MAAM;IAI9B,mBAAmB;IAInB;;;OAGG;IACH,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,mBAAmB;IAyC5D,oCAAoC,IAAI,mBAAmB;IAS3D;;;;OAIG;IACH,YAAY,IAAI,MAAM;IAStB;;;;;;;;;;OAUG;IACH,wBAAwB,CAAC,EACvB,KAAc,EACd,aAAa,EACb,aAAa,EACb,WAAW,GACZ,EAAE,wBAAwB,GAAG,MAAM;IA+BpC,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,gBAAgB;IA6BxE;;;;OAIG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI9B,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAqBhE,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IAkBzD;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAsBzC"}