@progress/kendo-react-dateinputs 6.1.1-dev.202311151536 → 7.0.0-develop.1

package/dist/npm/virtualization/Virtualization.d.ts

@@ -1,116 +0,0 @@
-import * as React from 'react';
-import * as PropTypes from 'prop-types';
-import { ScrollAction, PageAction } from './services';
-/**
- * @hidden
- */
-export interface ScrollActionArguments {
-    index: number;
-    target: HTMLDivElement | null;
-    scrollAction?: ScrollAction;
-    pageAction?: PageAction;
-    animationInProgress: boolean;
-}
-/**
- * @hidden
- */
-export declare enum ScrollDirection {
-    Backward = 0,
-    Forward = 1
-}
-/**
- * @hidden
- */
-export declare type Direction = 'horizontal' | 'vertical';
-/**
- * @hidden
- */
-export interface VirtualizationProps {
-    bottomOffset: number;
-    className?: string;
-    direction?: Direction;
-    itemHeight?: number;
-    itemWidth?: number;
-    maxScrollDifference?: number;
-    onMount?: any;
-    onScroll?: (event: React.SyntheticEvent) => void;
-    onScrollAction?: (args: ScrollActionArguments) => void;
-    scrollOffsetSize?: number;
-    scrollDuration?: number;
-    skip: number;
-    tabIndex?: number;
-    take: number;
-    topOffset: number;
-    total: number;
-    role?: string;
-    children?: React.ReactNode;
-}
-/**
- * @hidden
- */
-export declare class Virtualization extends React.Component<VirtualizationProps, {}> {
-    static propTypes: {
-        bottomOffset: PropTypes.Validator<number>;
-        className: PropTypes.Requireable<string>;
-        direction: PropTypes.Requireable<string>;
-        forceScroll: PropTypes.Requireable<boolean>;
-        itemHeight: PropTypes.Requireable<number>;
-        itemWidth: PropTypes.Requireable<number>;
-        maxScrollDifference: PropTypes.Requireable<number>;
-        onScroll: PropTypes.Requireable<(...args: any[]) => any>;
-        onScrollAction: PropTypes.Requireable<(...args: any[]) => any>;
-        scrollDuration: PropTypes.Requireable<number>;
-        scrollOffsetSize: PropTypes.Requireable<number>;
-        skip: PropTypes.Validator<number>;
-        tabIndex: PropTypes.Requireable<number>;
-        take: PropTypes.Validator<number>;
-        topOffset: PropTypes.Validator<number>;
-        total: PropTypes.Validator<number>;
-        role: PropTypes.Requireable<string>;
-    };
-    static defaultProps: {
-        direction: Direction;
-        forceScroll: boolean;
-        scrollOffsetSize: number;
-        maxScrollDifference: number;
-        scrollDuration: number;
-    };
-    private cancelAnimation;
-    private rowHeightService;
-    private scrollerService;
-    private scrollContainer;
-    private scrollAction?;
-    private pageAction?;
-    private lastDirection;
-    private lastTotal;
-    private lastTake;
-    private animationInProgress;
-    private restrictScroll;
-    get element(): HTMLDivElement | null;
-    protected get containerOffsetSize(): number;
-    get containerScrollSize(): number;
-    get containerScrollPosition(): number;
-    protected get direction(): Direction;
-    protected get scrollOffsetSize(): number;
-    constructor(props: VirtualizationProps);
-    activeIndex(): number;
-    itemIndex(offset: number): number;
-    itemOffset(index: number): number;
-    isIndexVisible(index: number): boolean;
-    isListScrolled(index: number): boolean;
-    scrollTo: (value: number) => void;
-    scrollToIndex: (index: number) => void;
-    animateToIndex: (index: number) => void;
-    scrollToBottom: () => void;
-    componentDidMount(): void;
-    render(): JSX.Element;
-    protected scrollStep: (start: number, end: number) => number;
-    protected scrollRange: (indexOffset: number, direction: ScrollDirection) => any;
-    protected containerMaxScroll: () => number;
-    protected getContainerScrollDirection: (indexOffset: number) => ScrollDirection;
-    protected initServices: (props?: VirtualizationProps) => void;
-    protected getContainerProperty: (propertyName: 'offsetHeight' | 'offsetWidth' | 'scrollHeight' | 'scrollWidth' | 'scrollTop' | 'scrollLeft') => number;
-    private handleScroll;
-    private handleScrollAction;
-    private handlePageAction;
-}

package/dist/npm/virtualization/Virtualization.js

@@ -1,320 +0,0 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var _a, _b, _c;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Virtualization = exports.ScrollDirection = void 0;
-var React = require("react");
-var PropTypes = require("prop-types");
-var kendo_react_common_1 = require("@progress/kendo-react-common");
-var services_1 = require("./services");
-/**
- * @hidden
- */
-var ScrollDirection;
-(function (ScrollDirection) {
-    ScrollDirection[ScrollDirection["Backward"] = 0] = "Backward";
-    ScrollDirection[ScrollDirection["Forward"] = 1] = "Forward";
-})(ScrollDirection = exports.ScrollDirection || (exports.ScrollDirection = {}));
-var differenceToScroll = function (scrollTop, staticOffset, maxScrollDifference) {
-    return Math.min(Math.abs(staticOffset - scrollTop), maxScrollDifference);
-};
-var FRAME_DURATION = 17;
-var MIN_SCROLL_STEP = 10;
-var scrollModifiers = (_a = {},
-    _a[ScrollDirection.Forward] = function (step) { return function (value) { return value + step; }; },
-    _a[ScrollDirection.Backward] = function (step) { return function (value) { return value - step; }; },
-    _a);
-var scrollNormalizers = (_b = {},
-    _b[ScrollDirection.Forward] = function (end) { return function (value) { return Math.min(value, end); }; },
-    _b[ScrollDirection.Backward] = function (end) { return function (value) { return Math.max(value, end); }; },
-    _b);
-var scrollValidators = (_c = {},
-    _c[ScrollDirection.Forward] = function (end) { return function (start) { return start < end; }; },
-    _c[ScrollDirection.Backward] = function (end) { return function (start) { return start > end; }; },
-    _c);
-/**
- * @hidden
- */
-var Virtualization = /** @class */ (function (_super) {
-    __extends(Virtualization, _super);
-    function Virtualization(props) {
-        var _this = _super.call(this, props) || this;
-        _this.rowHeightService = null;
-        _this.scrollContainer = null;
-        _this.lastDirection = null;
-        _this.lastTotal = 0;
-        _this.lastTake = 0;
-        _this.animationInProgress = false;
-        _this.restrictScroll = false;
-        _this.scrollTo = function (value) {
-            var scrollProperty = _this.direction === 'vertical' ? 'scrollTop' : 'scrollLeft';
-            if (!_this.scrollContainer) {
-                return;
-            }
-            var current = _this.scrollContainer[scrollProperty];
-            if (_this.restrictScroll && scrollProperty === 'scrollTop' &&
-                (!Number.isInteger(current) || !Number.isInteger(value)) && Math.abs(current - value) < MIN_SCROLL_STEP) {
-                return;
-            }
-            _this.scrollContainer[scrollProperty] = value;
-        };
-        _this.scrollToIndex = function (index) {
-            _this.animationInProgress = false;
-            if (_this.rowHeightService) {
-                _this.scrollTo(_this.rowHeightService.offset(index));
-            }
-        };
-        _this.animateToIndex = function (index) {
-            if (!_this.rowHeightService || !window) {
-                return;
-            }
-            window.cancelAnimationFrame(_this.cancelAnimation);
-            var indexOffset = _this.rowHeightService.offset(index);
-            var direction = _this.getContainerScrollDirection(indexOffset);
-            var _a = _this.scrollRange(indexOffset, direction), start = _a.start, end = _a.end;
-            if (start === end) {
-                return;
-            }
-            var step = _this.scrollStep(start, end);
-            var modifyScroll = scrollModifiers[direction](step);
-            var normalizeScroll = scrollNormalizers[direction](end);
-            var isScrollValid = scrollValidators[direction](modifyScroll(end));
-            var animate = function (progress) {
-                _this.animationInProgress = true;
-                var next = modifyScroll(progress);
-                _this.scrollTo(normalizeScroll(next));
-                isScrollValid(next)
-                    ? _this.cancelAnimation = window.requestAnimationFrame(function () { animate(next); })
-                    : _this.animationInProgress = false;
-            };
-            _this.cancelAnimation = window.requestAnimationFrame(function () { animate(start); });
-        };
-        _this.scrollToBottom = function () {
-            if (!_this.rowHeightService) {
-                return;
-            }
-            _this.scrollTo(_this.rowHeightService.totalHeight() + _this.props.bottomOffset);
-        };
-        _this.scrollStep = function (start, end) {
-            var duration = _this.props.scrollDuration || Virtualization.defaultProps.scrollDuration;
-            return Math.abs(end - start) / (duration / FRAME_DURATION);
-        };
-        _this.scrollRange = function (indexOffset, direction) {
-            var containerScroll = _this.containerScrollPosition;
-            if (parseInt("".concat(indexOffset), 10) === parseInt("".concat(containerScroll), 10)) {
-                return { start: indexOffset, end: indexOffset };
-            }
-            var maxScroll = _this.containerMaxScroll();
-            var sign = direction === ScrollDirection.Backward ? 1 : -1;
-            var difference = differenceToScroll(containerScroll, indexOffset, _this.props.maxScrollDifference || 0);
-            var end = Math.min(indexOffset, maxScroll);
-            var start = Math.min(Math.max(end + (sign * difference), 0), maxScroll);
-            return { start: start, end: end };
-        };
-        _this.containerMaxScroll = function () {
-            return _this.containerScrollSize - _this.containerOffsetSize;
-        };
-        _this.getContainerScrollDirection = function (indexOffset) {
-            return indexOffset < _this.containerScrollPosition ? ScrollDirection.Backward : ScrollDirection.Forward;
-        };
-        _this.initServices = function (props) {
-            if (props === void 0) { props = _this.props; }
-            var dimension = _this.direction === 'vertical' ? props.itemHeight : props.itemWidth;
-            if (dimension === undefined) {
-                return;
-            }
-            _this.rowHeightService = new services_1.RowHeightService(props.total, dimension, 0);
-            _this.scrollerService.create(_this.rowHeightService, props.skip, props.take, props.total, props.topOffset, _this.scrollOffsetSize, _this.direction);
-        };
-        _this.getContainerProperty = function (propertyName) {
-            if (!_this.scrollContainer) {
-                return 0;
-            }
-            return _this.scrollContainer[propertyName];
-        };
-        _this.handleScroll = function (event) {
-            if (!_this.scrollContainer || !_this.rowHeightService) {
-                return;
-            }
-            var target = event.target;
-            _this.scrollerService.onScroll({
-                scrollLeft: target.scrollLeft,
-                scrollTop: target.scrollTop,
-                offsetHeight: target.offsetHeight,
-                offsetWidth: target.offsetWidth
-            });
-            var index = _this.rowHeightService.index(_this.containerScrollPosition - _this.props.topOffset);
-            var onScrollAction = _this.props.onScrollAction;
-            var args = {
-                index: index,
-                target: target,
-                scrollAction: _this.scrollAction,
-                pageAction: _this.pageAction,
-                animationInProgress: _this.animationInProgress
-            };
-            if (_this.props.onScroll) {
-                _this.props.onScroll.call(undefined, event);
-            }
-            if (onScrollAction) {
-                onScrollAction.call(undefined, args);
-            }
-            _this.scrollAction = undefined;
-            _this.pageAction = undefined;
-        };
-        _this.handleScrollAction = function (action) {
-            _this.scrollAction = action;
-        };
-        _this.handlePageAction = function (action) {
-            _this.pageAction = action;
-        };
-        _this.scrollerService = new services_1.ScrollerService(_this.handleScrollAction, _this.handlePageAction);
-        _this.restrictScroll = Number.parseFloat(React.version) > 17;
-        return _this;
-    }
-    Object.defineProperty(Virtualization.prototype, "element", {
-        get: function () {
-            return this.scrollContainer;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Virtualization.prototype, "containerOffsetSize", {
-        get: function () {
-            return this.getContainerProperty(this.direction === 'vertical' ? 'offsetHeight' : 'offsetWidth');
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Virtualization.prototype, "containerScrollSize", {
-        get: function () {
-            return this.getContainerProperty(this.direction === 'vertical' ? 'scrollHeight' : 'scrollWidth');
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Virtualization.prototype, "containerScrollPosition", {
-        get: function () {
-            return this.getContainerProperty(this.direction === 'vertical' ? 'scrollTop' : 'scrollLeft');
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Virtualization.prototype, "direction", {
-        get: function () {
-            return this.props.direction !== undefined ? this.props.direction : Virtualization.defaultProps.direction;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Virtualization.prototype, "scrollOffsetSize", {
-        get: function () {
-            return this.props.scrollOffsetSize !== undefined
-                ? this.props.scrollOffsetSize : Virtualization.defaultProps.scrollOffsetSize;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Virtualization.prototype.activeIndex = function () {
-        return this.itemIndex(Math.ceil(this.containerScrollPosition));
-    };
-    Virtualization.prototype.itemIndex = function (offset) {
-        if (!this.rowHeightService) {
-            return 0;
-        }
-        return this.rowHeightService.index(offset);
-    };
-    Virtualization.prototype.itemOffset = function (index) {
-        if (!this.rowHeightService) {
-            return 0;
-        }
-        return this.rowHeightService.offset(index);
-    };
-    Virtualization.prototype.isIndexVisible = function (index) {
-        if (!this.rowHeightService) {
-            return false;
-        }
-        var containerTop = this.containerScrollPosition;
-        var containerBottom = containerTop + this.containerOffsetSize;
-        var top = this.rowHeightService.offset(index);
-        var bottom = top + this.rowHeightService.height(index);
-        return top >= containerTop && bottom <= containerBottom;
-    };
-    Virtualization.prototype.isListScrolled = function (index) {
-        if (!this.rowHeightService) {
-            return false;
-        }
-        return this.containerScrollPosition !== this.rowHeightService.offset(index);
-    };
-    Virtualization.prototype.componentDidMount = function () {
-        var onMount = this.props.onMount;
-        if (onMount) {
-            onMount.call(undefined, this);
-        }
-    };
-    Virtualization.prototype.render = function () {
-        var _this = this;
-        if (this.lastTotal !== this.props.total
-            || this.lastDirection !== this.direction
-            || this.lastTake !== this.props.take) {
-            this.initServices();
-            this.lastTotal = this.props.total;
-            this.lastDirection = this.direction;
-            this.lastTake = this.props.take;
-        }
-        var vertexLength = "".concat((this.rowHeightService ? this.rowHeightService.totalHeight() : 0) + this.props.bottomOffset);
-        var placeholderStyle = this.direction === 'vertical'
-            ? { height: "".concat(vertexLength, "px") }
-            : { width: "".concat(vertexLength, "px") };
-        var rootClassNames = (0, kendo_react_common_1.classNames)('k-content k-scrollable', {
-            'k-scrollable-horizontal': this.direction === 'horizontal'
-        }, this.props.className);
-        var scrollableClassNames = (0, kendo_react_common_1.classNames)('k-scrollable-placeholder', {
-            'k-scrollable-horizontal-placeholder': this.direction === 'horizontal'
-        });
-        return (React.createElement("div", { ref: function (el) { _this.scrollContainer = el; }, onScroll: this.handleScroll, className: rootClassNames, tabIndex: this.props.tabIndex, role: this.props.role },
-            this.props.children,
-            React.createElement("div", { style: placeholderStyle, className: scrollableClassNames })));
-    };
-    Virtualization.propTypes = {
-        bottomOffset: PropTypes.number.isRequired,
-        className: PropTypes.string,
-        direction: PropTypes.oneOf(['horizontal', 'vertical']),
-        forceScroll: PropTypes.bool,
-        itemHeight: PropTypes.number,
-        itemWidth: PropTypes.number,
-        maxScrollDifference: PropTypes.number,
-        onScroll: PropTypes.func,
-        onScrollAction: PropTypes.func,
-        scrollDuration: PropTypes.number,
-        scrollOffsetSize: PropTypes.number,
-        skip: PropTypes.number.isRequired,
-        tabIndex: PropTypes.number,
-        take: PropTypes.number.isRequired,
-        topOffset: PropTypes.number.isRequired,
-        total: PropTypes.number.isRequired,
-        role: PropTypes.string
-    };
-    Virtualization.defaultProps = {
-        direction: 'vertical',
-        forceScroll: false,
-        scrollOffsetSize: 0,
-        maxScrollDifference: 100,
-        scrollDuration: 100
-    };
-    return Virtualization;
-}(React.Component));
-exports.Virtualization = Virtualization;

package/dist/npm/virtualization/services/RowHeightService.d.ts

@@ -1,18 +0,0 @@
-/**
- * @hidden
- */
-export declare class RowHeightService {
-    private total;
-    private rowHeight;
-    private detailRowHeight;
-    private offsets;
-    private heights;
-    constructor(total: number, rowHeight: number, detailRowHeight: number);
-    height(rowIndex: number): number;
-    expandDetail(rowIndex: number): void;
-    collapseDetail(rowIndex: number): void;
-    index(position: number): number;
-    offset(rowIndex: number): number;
-    totalHeight(): number;
-    private updateRowHeight;
-}

package/dist/npm/virtualization/services/RowHeightService.js

@@ -1,71 +0,0 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowHeightService = void 0;
-/**
- * @hidden
- */
-var update = function (arr, idx, value) { return (__spreadArray(__spreadArray([], arr.slice(0, idx + 1), true), (arr.slice(idx + 1).map(function (x) { return x + value; })), true)); };
-/**
- * @hidden
- */
-var RowHeightService = /** @class */ (function () {
-    function RowHeightService(total, rowHeight, detailRowHeight) {
-        if (total === void 0) { total = 0; }
-        this.total = total;
-        this.rowHeight = rowHeight;
-        this.detailRowHeight = detailRowHeight;
-        this.offsets = [];
-        this.heights = [];
-        var agg = 0;
-        for (var idx = 0; idx < total; idx++) {
-            this.offsets.push(agg);
-            agg += rowHeight;
-            this.heights.push(rowHeight);
-        }
-    }
-    RowHeightService.prototype.height = function (rowIndex) {
-        return this.heights[rowIndex];
-    };
-    RowHeightService.prototype.expandDetail = function (rowIndex) {
-        if (this.height(rowIndex) === this.rowHeight) {
-            this.updateRowHeight(rowIndex, this.detailRowHeight);
-        }
-    };
-    RowHeightService.prototype.collapseDetail = function (rowIndex) {
-        if (this.height(rowIndex) > this.rowHeight) {
-            this.updateRowHeight(rowIndex, this.detailRowHeight * -1);
-        }
-    };
-    RowHeightService.prototype.index = function (position) {
-        for (var i = 0; i < this.offsets.length; i++) {
-            if (position === this.offsets[i]) {
-                return i;
-            }
-            if (position < this.offsets[i]) {
-                return i - 1;
-            }
-        }
-        return this.total - 1;
-    };
-    RowHeightService.prototype.offset = function (rowIndex) {
-        return this.offsets[rowIndex];
-    };
-    RowHeightService.prototype.totalHeight = function () {
-        return this.heights.reduce(function (prev, curr) { return prev + curr; }, 0);
-    };
-    RowHeightService.prototype.updateRowHeight = function (rowIndex, value) {
-        this.heights[rowIndex] += value;
-        this.offsets = update(this.offsets, rowIndex, value);
-    };
-    return RowHeightService;
-}());
-exports.RowHeightService = RowHeightService;

package/dist/npm/virtualization/services/ScrollerService.d.ts

@@ -1,49 +0,0 @@
-import { RowHeightService } from './RowHeightService';
-/**
- * @hidden
- */
-export declare class ScrollAction {
-    offset: number;
-    constructor(offset: number);
-}
-/**
- * @hidden
- */
-export declare class PageAction {
-    skip: number;
-    constructor(skip: number);
-}
-/**
- * @hidden
- */
-export declare type ScrollElement = {
-    offsetHeight: number;
-    offsetWidth: number;
-    scrollLeft: number;
-    scrollTop: number;
-};
-/**
- * @hidden
- */
-export declare type Action = ScrollAction | PageAction;
-/**
- * @hidden
- */
-export declare class ScrollerService {
-    private onScrollAction;
-    private onPageAction;
-    private direction;
-    private firstLoaded;
-    private lastLoaded;
-    private lastScrollTop;
-    private take;
-    private total;
-    private rowHeightService;
-    private bottomOffset;
-    private topOffset;
-    constructor(onScrollAction: (action: ScrollAction) => void, onPageAction: (action: PageAction) => void);
-    create(rowHeightService: RowHeightService, skip: number, take: number, total: number, topOffset?: number, bottomOffset?: number, direction?: 'horizontal' | 'vertical'): void;
-    onScroll({ scrollLeft, scrollTop, offsetHeight, offsetWidth }: ScrollElement): void;
-    rowOffset(index: number): number;
-    private rowsForHeight;
-}

package/dist/npm/virtualization/services/ScrollerService.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScrollerService = exports.PageAction = exports.ScrollAction = void 0;
-var normalize = function (x) { return Math.max(x, 0); };
-/**
- * @hidden
- */
-var ScrollAction = /** @class */ (function () {
-    function ScrollAction(offset) {
-        this.offset = offset;
-    }
-    return ScrollAction;
-}());
-exports.ScrollAction = ScrollAction;
-/**
- * @hidden
- */
-var PageAction = /** @class */ (function () {
-    function PageAction(skip) {
-        this.skip = skip;
-    }
-    return PageAction;
-}());
-exports.PageAction = PageAction;
-/**
- * @hidden
- */
-var ScrollerService = /** @class */ (function () {
-    function ScrollerService(onScrollAction, onPageAction) {
-        this.onScrollAction = onScrollAction;
-        this.onPageAction = onPageAction;
-        this.direction = 'vertical';
-        this.firstLoaded = 0;
-        this.lastLoaded = 0;
-        this.lastScrollTop = 0;
-        this.take = 0;
-        this.total = 0;
-        this.rowHeightService = null;
-        this.bottomOffset = 0;
-        this.topOffset = 0;
-    }
-    ScrollerService.prototype.create = function (rowHeightService, skip, take, total, topOffset, bottomOffset, direction) {
-        if (topOffset === void 0) { topOffset = 0; }
-        if (bottomOffset === void 0) { bottomOffset = 0; }
-        if (direction === void 0) { direction = 'vertical'; }
-        this.rowHeightService = rowHeightService;
-        this.firstLoaded = skip;
-        this.lastLoaded = skip + take;
-        this.take = take;
-        this.total = total;
-        this.lastScrollTop = 0;
-        this.topOffset = topOffset;
-        this.bottomOffset = bottomOffset;
-        this.direction = direction;
-        var offsetBufferRows = this.rowsForHeight(topOffset);
-        var skipWithOffset = normalize(skip - offsetBufferRows);
-        this.onScrollAction(new ScrollAction(this.rowOffset(skipWithOffset)));
-        this.onPageAction(new PageAction(skipWithOffset));
-    };
-    ScrollerService.prototype.onScroll = function (_a) {
-        var scrollLeft = _a.scrollLeft, scrollTop = _a.scrollTop, offsetHeight = _a.offsetHeight, offsetWidth = _a.offsetWidth;
-        var scrollPosition = this.direction === 'vertical' ? scrollTop : scrollLeft;
-        var offsetSize = this.direction === 'vertical' ? offsetHeight : offsetWidth;
-        if (this.lastScrollTop === scrollPosition || !this.rowHeightService) {
-            return;
-        }
-        var up = this.lastScrollTop >= scrollPosition;
-        this.lastScrollTop = scrollPosition;
-        var firstItemIndex = this.rowHeightService.index(normalize(scrollPosition - this.topOffset));
-        var lastItemIndex = this.rowHeightService.index(normalize(scrollPosition + offsetSize - this.bottomOffset));
-        if (!up && lastItemIndex >= this.lastLoaded && this.lastLoaded < this.total) {
-            this.firstLoaded = firstItemIndex;
-            this.onScrollAction(new ScrollAction(this.rowOffset(firstItemIndex)));
-            this.lastLoaded = Math.min(this.firstLoaded + this.take, this.total);
-            this.onPageAction(new PageAction(this.firstLoaded));
-        }
-        if (up && firstItemIndex <= this.firstLoaded) {
-            var nonVisibleBuffer = Math.floor(this.take * 0.3);
-            this.firstLoaded = normalize(firstItemIndex - nonVisibleBuffer);
-            this.onScrollAction(new ScrollAction(this.rowOffset(this.firstLoaded)));
-            this.lastLoaded = Math.min(this.firstLoaded + this.take, this.total);
-            this.onPageAction(new PageAction(this.firstLoaded));
-        }
-    };
-    ScrollerService.prototype.rowOffset = function (index) {
-        return this.rowHeightService ? this.rowHeightService.offset(index) + this.topOffset : 0;
-    };
-    ScrollerService.prototype.rowsForHeight = function (height) {
-        return this.rowHeightService ? Math.ceil(height / this.rowHeightService.height(0)) : 0;
-    };
-    return ScrollerService;
-}());
-exports.ScrollerService = ScrollerService;

package/dist/npm/virtualization/services/index.d.ts

@@ -1,3 +0,0 @@
-import { RowHeightService } from './RowHeightService';
-import { PageAction, ScrollAction, ScrollElement, ScrollerService } from './ScrollerService';
-export { PageAction, ScrollElement, RowHeightService, ScrollAction, ScrollerService };

package/dist/npm/virtualization/services/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScrollerService = exports.ScrollAction = exports.RowHeightService = exports.PageAction = void 0;
-var RowHeightService_1 = require("./RowHeightService");
-Object.defineProperty(exports, "RowHeightService", { enumerable: true, get: function () { return RowHeightService_1.RowHeightService; } });
-var ScrollerService_1 = require("./ScrollerService");
-Object.defineProperty(exports, "PageAction", { enumerable: true, get: function () { return ScrollerService_1.PageAction; } });
-Object.defineProperty(exports, "ScrollAction", { enumerable: true, get: function () { return ScrollerService_1.ScrollAction; } });
-Object.defineProperty(exports, "ScrollerService", { enumerable: true, get: function () { return ScrollerService_1.ScrollerService; } });