amis-rev-ui 6.13.0

package/esm/components/table/util.d.ts

@@ -0,0 +1,25 @@
+import { ColumnProps, SummaryProps, ThProps, TdProps, SortProps } from './index';
+export declare function checkChildrenRow(data: any, childrenColumnName: string): any;
+export declare function getDataChildrenKeys(data: any, childrenColumnName: string, rowSelectionKeyField: string): string[];
+export declare function getAllSelectableRows(dataSource: Array<any>, rowSelectionKeyField: string, childrenColumnName: string, expandable: boolean, selectedRowKeys: Array<string | number>, maxSelectedLength: number | undefined): {
+    rows: any[];
+    rowKeys: (string | number)[];
+    restSelectedKeys: (string | number)[];
+};
+export declare function getRowsByKeys(dataSource: Array<any>, keys: Array<string | number>, keyField: string, childrenColumnName: string): {
+    selectedRows: any[];
+    unSelectedRows: any[];
+};
+export declare function getMaxLevelThRowSpan(columns: Array<ColumnProps>): number;
+export declare function getThRowSpan(column: ColumnProps): number;
+export declare function getThColSpan(column: ColumnProps): number;
+export declare function buildColumns(columns: Array<ColumnProps> | undefined, thColumns: Array<Array<any>>, tdColumns: Array<ColumnProps> | undefined, maxLevel: number, depth?: number, fixed?: boolean | string): void;
+export declare function getBuildColumns(columns: Array<any>): {
+    thColumns: ThProps[][];
+    tdColumns: TdProps[];
+};
+export declare function updateFixedRow(row: HTMLTableRowElement, columns: Array<ColumnProps | SummaryProps>, cx: Function): void;
+export declare function updateStickyRow(thead: HTMLCollection, rowIndex: number): void;
+export declare function hasFixedColumn(columns: Array<ColumnProps | SummaryProps>): any;
+export declare function levelsSplit(level: string): number[];
+export declare function getSortData(data: Array<any>, columns: Array<ColumnProps>, childrenColumnName: string, sort?: SortProps): Array<any>;

package/esm/components/table/util.js

@@ -0,0 +1,279 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __spreadArray, __read, __assign, __rest } from 'tslib';
+import findLastIndex from 'lodash/findLastIndex';
+import find from 'lodash/find';
+import { isBreakpoint } from 'amis-rev-core';
+
+// 当前行包含子数据
+function checkChildrenRow(data, childrenColumnName) {
+    return (data[childrenColumnName] &&
+        Array.isArray(data[childrenColumnName]) &&
+        data[childrenColumnName].length > 0);
+}
+// 获取当前行数据所有子行的key值
+function getDataChildrenKeys(data, childrenColumnName, rowSelectionKeyField) {
+    var keys = [];
+    if (checkChildrenRow(data, childrenColumnName)) {
+        data[childrenColumnName].forEach(function (item) {
+            return (keys = __spreadArray(__spreadArray(__spreadArray([], __read(keys), false), __read(getDataChildrenKeys(item, childrenColumnName, rowSelectionKeyField)), false), [
+                item[rowSelectionKeyField]
+            ], false));
+        });
+    }
+    return keys;
+}
+// 获取当前表格所有可以选中的行
+function getAllSelectableRows(dataSource, rowSelectionKeyField, childrenColumnName, expandable, selectedRowKeys, maxSelectedLength) {
+    var allRowKeys = [];
+    var allRows = [];
+    dataSource.forEach(function (data) {
+        allRowKeys.push(data[rowSelectionKeyField]);
+        allRows.push(data);
+        if (!expandable && checkChildrenRow(data, childrenColumnName)) {
+            allRowKeys = __spreadArray(__spreadArray([], __read(allRowKeys), false), __read(getDataChildrenKeys(data, childrenColumnName, rowSelectionKeyField)), false);
+            data[childrenColumnName].forEach(function (item) { return allRows.push(item); });
+        }
+    });
+    var restSelectedKeys = selectedRowKeys === null || selectedRowKeys === void 0 ? void 0 : selectedRowKeys.filter(function (key) { return !allRowKeys.includes(key); });
+    if (maxSelectedLength && Number.isInteger(maxSelectedLength)) {
+        if (restSelectedKeys.length + allRowKeys.length > maxSelectedLength) {
+            var count = maxSelectedLength - restSelectedKeys.length;
+            allRowKeys = allRowKeys.slice(0, count);
+            allRows = allRows.slice(0, count);
+        }
+    }
+    return { rows: allRows, rowKeys: allRowKeys, restSelectedKeys: restSelectedKeys };
+}
+function getRowsByKeys(dataSource, keys, keyField, childrenColumnName) {
+    var selectedRows = [];
+    var unSelectedRows = [];
+    dataSource.forEach(function (data) {
+        if (keys.find(function (key) { return key === data[keyField]; })) {
+            selectedRows.push(data);
+        }
+        else {
+            unSelectedRows.push(data);
+        }
+        if (checkChildrenRow(data, childrenColumnName)) {
+            var childrenResult = getRowsByKeys(data[childrenColumnName], keys, keyField, childrenColumnName);
+            selectedRows = __spreadArray(__spreadArray([], __read(selectedRows), false), __read(childrenResult.selectedRows), false);
+            unSelectedRows = __spreadArray(__spreadArray([], __read(unSelectedRows), false), __read(childrenResult.unSelectedRows), false);
+        }
+    });
+    return { selectedRows: selectedRows, unSelectedRows: unSelectedRows };
+}
+function getMaxLevelThRowSpan(columns) {
+    var maxLevel = 0;
+    Array.isArray(columns) &&
+        columns.forEach(function (c) {
+            var level = getThRowSpan(c);
+            if (maxLevel < level) {
+                maxLevel = level;
+            }
+        });
+    return maxLevel;
+}
+function getThRowSpan(column) {
+    if (!column.children || (column.children && !column.children.length)) {
+        return 1;
+    }
+    return 1 + getMaxLevelThRowSpan(column.children);
+}
+function getThColSpan(column) {
+    if (!column.children || (column.children && !column.children.length)) {
+        return 1;
+    }
+    var childrenLength = 0;
+    column.children.forEach(function (item) { return (childrenLength += getThColSpan(item)); });
+    return childrenLength;
+}
+function buildColumns(columns, thColumns, tdColumns, maxLevel, depth, fixed) {
+    if (columns === void 0) { columns = []; }
+    if (tdColumns === void 0) { tdColumns = []; }
+    if (depth === void 0) { depth = 0; }
+    // 在处理表头时，如果父级column设置了fixed属性，那么所有children保持一致
+    Array.isArray(columns) &&
+        columns.forEach(function (column) {
+            var childMaxLevel = 0;
+            if (column.children) {
+                childMaxLevel = getMaxLevelThRowSpan(column.children);
+            }
+            var newColumn = __assign(__assign({}, column), { rowSpan: childMaxLevel ? 1 : maxLevel - depth, colSpan: getThColSpan(column), depth: depth });
+            var tdColumn = __assign({}, column);
+            if (fixed) {
+                newColumn.fixed = fixed;
+                tdColumn.fixed = fixed;
+            }
+            if (!thColumns[depth]) {
+                thColumns[depth] = [];
+            }
+            thColumns[depth].push(newColumn);
+            if (column.children && column.children.length > 0) {
+                buildColumns(column.children, thColumns, tdColumns, maxLevel, depth + 1, column.fixed);
+            }
+            else {
+                tdColumn.children; var rest = __rest(tdColumn, ["children"]);
+                tdColumns.push(rest);
+            }
+        });
+}
+function getBuildColumns(columns) {
+    var filterColumns = columns.filter(function (item) { return !item.breakpoint || !isBreakpoint(item.breakpoint); });
+    var thColumns = [];
+    var tdColumns = [];
+    buildColumns(filterColumns, thColumns, tdColumns, getMaxLevelThRowSpan(filterColumns));
+    return { thColumns: thColumns, tdColumns: tdColumns };
+}
+function isFixedLeftColumn(fixed) {
+    return fixed === true || fixed === 'left';
+}
+function isFixedRightColumn(fixed) {
+    return fixed === 'right';
+}
+function getPreviousLeftWidth(index, columns) {
+    var widths = [];
+    for (var i = 0; i < index; i++) {
+        if (columns && columns[i] && isFixedLeftColumn(columns[i].fixed)) {
+            widths.push("var(--Table-column-".concat(i, "-width)"));
+        }
+    }
+    return widths.length
+        ? widths.length > 1
+            ? "calc(".concat(widths.join(' + '), ")")
+            : widths[0]
+        : '0';
+}
+function getPreviousTopHeight(thead, rowIndex) {
+    var height = 0;
+    for (var i = 0; i < rowIndex; i++) {
+        if (thead && thead[i]) {
+            var dom = thead[i];
+            height += dom.offsetHeight;
+        }
+    }
+    return height;
+}
+function getAfterRightWidth(index, columns) {
+    var widths = [];
+    for (var i = columns.length - 1; i > index; i--) {
+        if (columns && columns[i] && isFixedRightColumn(columns[i].fixed)) {
+            widths.push("var(--Table-column-".concat(i, "-width)"));
+        }
+    }
+    return widths.length
+        ? widths.length > 1
+            ? "calc(".concat(widths.join(' + '), ")")
+            : widths[0]
+        : '0';
+}
+// 更新一个tr下的td的left和class
+function updateFixedRow(row, columns, cx) {
+    var _a, _b, _c;
+    var children = (row === null || row === void 0 ? void 0 : row.children) || [];
+    var length = children.length;
+    var CLASS_FIX_LEFT_LAST = cx('Table-cell-fix-left-last');
+    var CLASS_FIX_RIGHT_FIRST = cx('Table-cell-fix-right-first');
+    var CLASS_FIX_RIGHT_FIRST_PREV = cx('Table-cell-fix-right-first-prev');
+    var styleUpdates = [];
+    var classRemovals = [];
+    for (var i = 0; i < length; i++) {
+        var dom = children[i];
+        classRemovals.push(dom);
+        var fixed = columns[i] ? columns[i].fixed || '' : '';
+        var left = '', right = '';
+        if (isFixedLeftColumn(fixed)) {
+            left = i > 0 ? getPreviousLeftWidth(i, columns) : '0';
+        }
+        else if (isFixedRightColumn(fixed)) {
+            right = i < length - 1 ? getAfterRightWidth(i, columns) : '0';
+        }
+        styleUpdates.push({ dom: dom, left: left, right: right });
+    }
+    // 批量修改样式
+    styleUpdates.forEach(function (_a) {
+        var dom = _a.dom, left = _a.left, right = _a.right;
+        dom.style.removeProperty('left');
+        dom.style.removeProperty('right');
+        left && (dom.style.left = left);
+        right && (dom.style.right = right);
+    });
+    // 批量移除类名
+    classRemovals.forEach(function (dom) {
+        dom.classList.remove(CLASS_FIX_LEFT_LAST, CLASS_FIX_RIGHT_FIRST, CLASS_FIX_RIGHT_FIRST_PREV);
+    });
+    // 最后一个左fixed的添加样式
+    var leftIndex = findLastIndex(columns, function (column) {
+        return isFixedLeftColumn(column.fixed);
+    });
+    if (leftIndex > -1) {
+        (_a = children[leftIndex]) === null || _a === void 0 ? void 0 : _a.classList.add(CLASS_FIX_LEFT_LAST);
+    }
+    // 第一个右fixed的添加样式
+    var rightIndex = columns.findIndex(function (column) {
+        return isFixedRightColumn(column.fixed);
+    });
+    if (rightIndex > -1) {
+        (_b = children[rightIndex]) === null || _b === void 0 ? void 0 : _b.classList.add(CLASS_FIX_RIGHT_FIRST);
+        if (rightIndex > 0) {
+            (_c = children[rightIndex - 1]) === null || _c === void 0 ? void 0 : _c.classList.add(CLASS_FIX_RIGHT_FIRST_PREV);
+        }
+    }
+}
+// 更新一个tr下的th的top
+function updateStickyRow(thead, rowIndex) {
+    var _a;
+    var children = ((_a = thead[rowIndex]) === null || _a === void 0 ? void 0 : _a.children) || [];
+    for (var i = 0; i < children.length; i++) {
+        var dom = children[i];
+        dom.style.removeProperty('top');
+        dom.style.top =
+            rowIndex > 0 ? getPreviousTopHeight(thead, rowIndex) + 'px' : '0';
+    }
+}
+function hasFixedColumn(columns) {
+    return find(columns, function (column) { return column.fixed; });
+}
+function levelsSplit(level) {
+    if (!level) {
+        return [];
+    }
+    return level.split(',').map(function (l) { return +l; });
+}
+function getSortData(data, columns, childrenColumnName, sort) {
+    var cloneData = data.slice();
+    if (!(sort === null || sort === void 0 ? void 0 : sort.orderBy)) {
+        return cloneData;
+    }
+    var column = columns.find(function (column) { return column.name === sort.orderBy; });
+    if (!column) {
+        return cloneData;
+    }
+    if (typeof column.sorter !== 'function') {
+        return cloneData;
+    }
+    var sortOrder = sort.orderDir;
+    return cloneData
+        .sort(function (record1, record2) {
+        var compareResult = typeof column.sorter === 'function'
+            ? column.sorter(record1, record2, sortOrder)
+            : 0;
+        if (compareResult !== 0) {
+            return sortOrder === 'asc' ? compareResult : -compareResult;
+        }
+        return 0;
+    })
+        .map(function (record) {
+        var _a;
+        var subRecords = record[childrenColumnName];
+        if (subRecords) {
+            return __assign(__assign({}, record), (_a = {}, _a[childrenColumnName] = getSortData(data, columns, childrenColumnName, sort), _a));
+        }
+        return record;
+    });
+}
+
+export { buildColumns, checkChildrenRow, getAllSelectableRows, getBuildColumns, getDataChildrenKeys, getMaxLevelThRowSpan, getRowsByKeys, getSortData, getThColSpan, getThRowSpan, hasFixedColumn, levelsSplit, updateFixedRow, updateStickyRow };

package/esm/components/virtual-list/AutoSizer.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+export type Size = {
+    height: number;
+    width: number;
+};
+export type AutoSizerProps = {
+    WrapperComponent?: React.ElementType;
+    minHeight?: number;
+    children: (props: Size) => React.ReactNode;
+    onResize?: (props: Size) => void;
+};
+export default class AutoSizer extends React.PureComponent<AutoSizerProps, Size> {
+    unSensor: Function;
+    constructor(props: AutoSizerProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    sizer(dom: HTMLElement): void;
+    render(): React.JSX.Element;
+}

package/esm/components/virtual-list/AutoSizer.js

@@ -0,0 +1,48 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { __extends, __assign } from 'tslib';
+import * as React from 'react';
+import { findDomCompat, resizeSensor } from 'amis-rev-core';
+
+var AutoSizer = /** @class */ (function (_super) {
+    __extends(AutoSizer, _super);
+    function AutoSizer(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = { width: 0, height: 0 };
+        return _this;
+    }
+    AutoSizer.prototype.componentDidMount = function () {
+        var _this = this;
+        var dom = findDomCompat(this);
+        this.unSensor = resizeSensor(dom, function () { return _this.sizer(dom); });
+        this.sizer(dom);
+    };
+    AutoSizer.prototype.componentWillUnmount = function () {
+        this.unSensor && this.unSensor();
+    };
+    AutoSizer.prototype.sizer = function (dom) {
+        var _a, _b;
+        var width = dom.offsetWidth;
+        var height = dom.offsetHeight;
+        (_b = (_a = this.props) === null || _a === void 0 ? void 0 : _a.onResize) === null || _b === void 0 ? void 0 : _b.call(_a, { width: width, height: height });
+        this.setState({
+            width: width,
+            height: height
+        });
+    };
+    AutoSizer.prototype.render = function () {
+        var _a = this.props, children = _a.children, WrapperComponent = _a.WrapperComponent, minHeight = _a.minHeight;
+        var _b = this.state, width = _b.width, height = _b.height;
+        var WrapperCmpt = WrapperComponent !== null && WrapperComponent !== void 0 ? WrapperComponent : 'div';
+        return (React.createElement(WrapperCmpt, { style: __assign({ display: 'block', position: 'relative', width: '100%', height: '100%' }, (minHeight ? { minHeight: minHeight } : {})) }, children({
+            width: width,
+            height: height
+        })));
+    };
+    return AutoSizer;
+}(React.PureComponent));
+
+export { AutoSizer as default };

package/esm/components/virtual-list/SizeAndPositionManager.d.ts

@@ -0,0 +1,70 @@
+import { ALIGNMENT } from './constants';
+export type ItemSizeGetter = (index: number) => number;
+export type ItemSize = number | number[] | ItemSizeGetter;
+export interface SizeAndPosition {
+    size: number;
+    offset: number;
+}
+export interface Options {
+    itemCount: number;
+    itemSizeGetter: ItemSizeGetter;
+    estimatedItemSize: number;
+}
+export default class SizeAndPositionManager {
+    private itemSizeGetter;
+    private itemCount;
+    private estimatedItemSize;
+    private lastMeasuredIndex;
+    private itemSizeAndPositionData;
+    constructor({ itemCount, itemSizeGetter, estimatedItemSize }: Options);
+    updateConfig({ itemCount, itemSizeGetter, estimatedItemSize }: Partial<Options>): void;
+    getLastMeasuredIndex(): number;
+    /**
+     * This method returns the size and position for the item at the specified index.
+     * It just-in-time calculates (or used cached values) for items leading up to the index.
+     */
+    getSizeAndPositionForIndex(index: number): SizeAndPosition;
+    getSizeAndPositionOfLastMeasuredItem(): SizeAndPosition;
+    /**
+     * Total size of all items being measured.
+     * This value will be completedly estimated initially.
+     * As items as measured the estimate will be updated.
+     */
+    getTotalSize(): number;
+    /**
+     * Determines a new offset that ensures a certain item is visible, given the alignment.
+     *
+     * @param align Desired alignment within container; one of "start" (default), "center", or "end"
+     * @param containerSize Size (width or height) of the container viewport
+     * @return Offset to use to ensure the specified item is visible
+     */
+    getUpdatedOffsetForIndex({ align, containerSize, currentOffset, targetIndex }: {
+        align: ALIGNMENT | undefined;
+        containerSize: number;
+        currentOffset: number;
+        targetIndex: number;
+    }): number;
+    getVisibleRange({ containerSize, offset, overscanCount }: {
+        containerSize: number;
+        offset: number;
+        overscanCount: number;
+    }): {
+        start?: number;
+        stop?: number;
+    };
+    /**
+     * Clear all cached values for items after the specified index.
+     * This method should be called for any item that has changed its size.
+     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionForIndex() is called.
+     */
+    resetItem(index: number): void;
+    /**
+     * Searches for the item (index) nearest the specified offset.
+     *
+     * If no exact match is found the next lowest item index will be returned.
+     * This allows partially visible items (with offsets just before/above the fold) to be visible.
+     */
+    findNearestItem(offset: number): number;
+    private binarySearch;
+    private exponentialSearch;
+}

package/esm/components/virtual-list/SizeAndPositionManager.js

@@ -0,0 +1,216 @@
+/**
+ * amis-rev-ui v6.13.0
+ * Copyright 2018-2026 fex
+ */
+
+import { ALIGNMENT } from './constants.js';
+
+/* Forked from react-virtualized 💖 */
+var SizeAndPositionManager = /** @class */ (function () {
+    function SizeAndPositionManager(_a) {
+        var itemCount = _a.itemCount, itemSizeGetter = _a.itemSizeGetter, estimatedItemSize = _a.estimatedItemSize;
+        this.itemSizeGetter = itemSizeGetter;
+        this.itemCount = itemCount;
+        this.estimatedItemSize = estimatedItemSize;
+        // Cache of size and position data for items, mapped by item index.
+        this.itemSizeAndPositionData = {};
+        // Measurements for items up to this index can be trusted; items afterward should be estimated.
+        this.lastMeasuredIndex = -1;
+    }
+    SizeAndPositionManager.prototype.updateConfig = function (_a) {
+        var itemCount = _a.itemCount, itemSizeGetter = _a.itemSizeGetter, estimatedItemSize = _a.estimatedItemSize;
+        if (itemCount != null) {
+            this.itemCount = itemCount;
+        }
+        if (estimatedItemSize != null) {
+            this.estimatedItemSize = estimatedItemSize;
+        }
+        if (itemSizeGetter != null) {
+            this.itemSizeGetter = itemSizeGetter;
+        }
+    };
+    SizeAndPositionManager.prototype.getLastMeasuredIndex = function () {
+        return this.lastMeasuredIndex;
+    };
+    /**
+     * This method returns the size and position for the item at the specified index.
+     * It just-in-time calculates (or used cached values) for items leading up to the index.
+     */
+    SizeAndPositionManager.prototype.getSizeAndPositionForIndex = function (index) {
+        if (index < 0 || index >= this.itemCount) {
+            throw Error("Requested index ".concat(index, " is outside of range 0..").concat(this.itemCount));
+        }
+        if (index > this.lastMeasuredIndex) {
+            var lastMeasuredSizeAndPosition = this.getSizeAndPositionOfLastMeasuredItem();
+            var offset = lastMeasuredSizeAndPosition.offset + lastMeasuredSizeAndPosition.size;
+            for (var i = this.lastMeasuredIndex + 1; i <= index; i++) {
+                var size = this.itemSizeGetter(i);
+                if (size == null || isNaN(size)) {
+                    throw Error("Invalid size returned for index ".concat(i, " of value ").concat(size));
+                }
+                this.itemSizeAndPositionData[i] = {
+                    offset: offset,
+                    size: size
+                };
+                offset += size;
+            }
+            this.lastMeasuredIndex = index;
+        }
+        return this.itemSizeAndPositionData[index];
+    };
+    SizeAndPositionManager.prototype.getSizeAndPositionOfLastMeasuredItem = function () {
+        return this.lastMeasuredIndex >= 0
+            ? this.itemSizeAndPositionData[this.lastMeasuredIndex]
+            : { offset: 0, size: 0 };
+    };
+    /**
+     * Total size of all items being measured.
+     * This value will be completedly estimated initially.
+     * As items as measured the estimate will be updated.
+     */
+    SizeAndPositionManager.prototype.getTotalSize = function () {
+        var lastMeasuredSizeAndPosition = this.getSizeAndPositionOfLastMeasuredItem();
+        return (lastMeasuredSizeAndPosition.offset +
+            lastMeasuredSizeAndPosition.size +
+            (this.itemCount - this.lastMeasuredIndex - 1) * this.estimatedItemSize);
+    };
+    /**
+     * Determines a new offset that ensures a certain item is visible, given the alignment.
+     *
+     * @param align Desired alignment within container; one of "start" (default), "center", or "end"
+     * @param containerSize Size (width or height) of the container viewport
+     * @return Offset to use to ensure the specified item is visible
+     */
+    SizeAndPositionManager.prototype.getUpdatedOffsetForIndex = function (_a) {
+        var _b = _a.align, align = _b === void 0 ? ALIGNMENT.START : _b, containerSize = _a.containerSize, currentOffset = _a.currentOffset, targetIndex = _a.targetIndex;
+        if (containerSize <= 0) {
+            return 0;
+        }
+        var datum = this.getSizeAndPositionForIndex(targetIndex);
+        var maxOffset = datum.offset;
+        var minOffset = maxOffset - containerSize + datum.size;
+        var idealOffset;
+        switch (align) {
+            case ALIGNMENT.END:
+                idealOffset = minOffset;
+                break;
+            case ALIGNMENT.CENTER:
+                idealOffset = maxOffset - (containerSize - datum.size) / 2;
+                break;
+            case ALIGNMENT.START:
+                idealOffset = maxOffset;
+                break;
+            default:
+                idealOffset = Math.max(minOffset, Math.min(maxOffset, currentOffset));
+        }
+        var totalSize = this.getTotalSize();
+        return Math.max(0, Math.min(totalSize - containerSize, idealOffset));
+    };
+    SizeAndPositionManager.prototype.getVisibleRange = function (_a) {
+        var containerSize = _a.containerSize, offset = _a.offset, overscanCount = _a.overscanCount;
+        var totalSize = this.getTotalSize();
+        if (totalSize === 0) {
+            return {};
+        }
+        var maxOffset = offset + containerSize;
+        var start = this.findNearestItem(offset);
+        if (typeof start === 'undefined') {
+            throw Error("Invalid offset ".concat(offset, " specified"));
+        }
+        var datum = this.getSizeAndPositionForIndex(start);
+        offset = datum.offset + datum.size;
+        var stop = start;
+        while (offset < maxOffset && stop < this.itemCount - 1) {
+            stop++;
+            offset += this.getSizeAndPositionForIndex(stop).size;
+        }
+        if (overscanCount) {
+            start = Math.max(0, start - overscanCount);
+            stop = Math.min(stop + overscanCount, this.itemCount - 1);
+        }
+        return {
+            start: start,
+            stop: stop
+        };
+    };
+    /**
+     * Clear all cached values for items after the specified index.
+     * This method should be called for any item that has changed its size.
+     * It will not immediately perform any calculations; they'll be performed the next time getSizeAndPositionForIndex() is called.
+     */
+    SizeAndPositionManager.prototype.resetItem = function (index) {
+        this.lastMeasuredIndex = Math.min(this.lastMeasuredIndex, index - 1);
+    };
+    /**
+     * Searches for the item (index) nearest the specified offset.
+     *
+     * If no exact match is found the next lowest item index will be returned.
+     * This allows partially visible items (with offsets just before/above the fold) to be visible.
+     */
+    SizeAndPositionManager.prototype.findNearestItem = function (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 lastMeasuredSizeAndPosition = this.getSizeAndPositionOfLastMeasuredItem();
+        var lastMeasuredIndex = Math.max(0, this.lastMeasuredIndex);
+        if (lastMeasuredSizeAndPosition.offset >= offset) {
+            // If we've already measured items within this range just use a binary search as it's faster.
+            return this.binarySearch({
+                high: lastMeasuredIndex,
+                low: 0,
+                offset: 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 items as a binary search would.
+            // The overall complexity for this approach is O(log n).
+            return this.exponentialSearch({
+                index: lastMeasuredIndex,
+                offset: offset
+            });
+        }
+    };
+    SizeAndPositionManager.prototype.binarySearch = function (_a) {
+        var low = _a.low, high = _a.high, offset = _a.offset;
+        var middle = 0;
+        var currentOffset = 0;
+        while (low <= high) {
+            middle = low + Math.floor((high - low) / 2);
+            currentOffset = this.getSizeAndPositionForIndex(middle).offset;
+            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;
+        }
+        return 0;
+    };
+    SizeAndPositionManager.prototype.exponentialSearch = function (_a) {
+        var index = _a.index, offset = _a.offset;
+        var interval = 1;
+        while (index < this.itemCount &&
+            this.getSizeAndPositionForIndex(index).offset < offset) {
+            index += interval;
+            interval *= 2;
+        }
+        return this.binarySearch({
+            high: Math.min(index, this.itemCount - 1),
+            low: Math.floor(index / 2),
+            offset: offset
+        });
+    };
+    return SizeAndPositionManager;
+}());
+
+export { SizeAndPositionManager as default };