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

package/dist/es/utils.js

@@ -1,306 +0,0 @@
-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));
-};
-import { cloneDate, isEqual } from '@progress/kendo-date-math';
-import { getDate } from '@progress/kendo-date-math';
-import { EMPTY_SELECTIONRANGE } from './calendar/models/SelectionRange';
-/**
- * @hidden
- */
-export var isEqualRange = function (initial, updated) {
-    var _a = initial || EMPTY_SELECTIONRANGE, initialStart = _a.start, initialEnd = _a.end;
-    var _b = updated || EMPTY_SELECTIONRANGE, updatedStart = _b.start, updatedEnd = _b.end;
-    if (initialStart === null || initialEnd === null || updatedStart === null || updatedEnd === null) {
-        return false;
-    }
-    return isEqual(initialStart, updatedStart) && isEqual(initialEnd, updatedEnd);
-};
-// Polyfill for PropTypes.null
-/**
- * @hidden
- */
-export function nullable(subRequirement) {
-    var check = function (required, props, key) {
-        var rest = [];
-        for (var _i = 3; _i < arguments.length; _i++) {
-            rest[_i - 3] = arguments[_i];
-        }
-        if (props[key] === null) {
-            return null;
-        }
-        var sub = required ? subRequirement.isRequired : subRequirement;
-        return sub.apply(void 0, __spreadArray([props, key], rest, false));
-    };
-    var fn = check.bind(null, false);
-    fn.isRequired = check.bind(null, true);
-    return fn;
-}
-/**
- * @hidden
- */
-export var viewInRange = function (candidate, min, max) {
-    if (min === undefined || max === undefined) {
-        return candidate;
-    }
-    return min <= candidate && candidate <= max
-        ? candidate
-        : candidate < min
-            ? min
-            : max;
-};
-/**
- * @hidden
- */
-export var MIDNIGHT_DATE = new Date(1980, 0, 1);
-/**
- * @hidden
- */
-export var MIN_DATE = new Date(1900, 0, 1);
-/**
- * @hidden
- */
-export var MAX_DATE = new Date(2099, 11, 31);
-/**
- * @hidden
- */
-export var MIN_TIME = new Date(1980, 0, 1);
-/**
- * @hidden
- */
-export var MAX_TIME = new Date(1980, 0, 1, 23, 59, 59);
-var isSet = function (value) { return value !== null && value !== undefined; };
-/**
- * @hidden
- */
-export var isValidRange = function (min, max) { return (!isSet(min) || !isSet(max) || min <= max); };
-/**
- * @hidden
- */
-export var setTime = function (origin, candidate) {
-    var date = cloneDate(origin);
-    date.setHours(candidate.getHours(), candidate.getMinutes(), candidate.getSeconds(), candidate.getMilliseconds());
-    return date;
-};
-/**
- * @hidden
- */
-export var getToday = function () { return getDate(new Date()); };
-/**
- * @hidden
- */
-export var isInRange = function (candidate, min, max) { return (!candidate || !((min && min > candidate) || (max && max < candidate))); };
-/**
- * @hidden
- */
-export var isInDateRange = function (candidate, min, max) { return (candidate === null
-    || !((min && getDate(min) > getDate(candidate))
-        || (max && getDate(max) < getDate(candidate)))); };
-/**
- * @hidden
- */
-export var isInSelectionRange = function (value, selectionRange) {
-    var _a = selectionRange || EMPTY_SELECTIONRANGE, start = _a.start, end = _a.end;
-    if (!start || !end) {
-        return false;
-    }
-    return start < value && value < end;
-};
-/**
- * @hidden
- */
-export var range = function (start, end, step) {
-    if (step === void 0) { step = 1; }
-    var result = [];
-    for (var i = start; i < end; i = i + step) {
-        result.push(i);
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export var intersects = function (date, min, max) {
-    return min.getTime() <= date.getTime() && date.getTime() <= max.getTime();
-};
-/**
- * @hidden
- */
-export var shiftWeekNames = function (names, offset) { return (names.slice(offset).concat(names.slice(0, offset))); };
-/**
- * @hidden
- */
-export var dateInRange = function (candidate, min, max) {
-    if (!candidate) {
-        return candidate;
-    }
-    if (min && candidate < min) {
-        return cloneDate(min);
-    }
-    if (max && candidate > max) {
-        return cloneDate(max);
-    }
-    return candidate;
-};
-/**
- * @hidden
- */
-export var domContainerFactory = function (type) { return function (children, classes, styles) {
-    if (classes === void 0) { classes = ''; }
-    if (styles === void 0) { styles = {}; }
-    var container = document.createElement(type);
-    container.className = classes;
-    Object.keys(styles).map(function (key) { return container.style[key] = styles[key]; });
-    if (typeof children === 'string') {
-        container.innerHTML = children || '';
-    }
-    else {
-        (children || []).forEach(function (child) { return child && container.appendChild(child); });
-    }
-    return container;
-}; };
-/**
- * @hidden
- */
-export function debounce(func, wait, options) {
-    if (options === void 0) { options = {}; }
-    var lastArgs;
-    var lastThis;
-    var maxWait = options.maxWait;
-    var result;
-    var timerId;
-    var lastCallTime;
-    var root = window;
-    var lastInvokeTime = 0;
-    var leading = false;
-    var maxing = false;
-    var trailing = true;
-    // Bypass `requestAnimationFrame` by explicitly setting `wait=0`.
-    var useRAF = (!wait && wait !== 0 && typeof root.requestAnimationFrame === 'function');
-    if (typeof func !== 'function') {
-        throw new TypeError('Expected a function');
-    }
-    wait = +wait || 0;
-    function invokeFunc(time) {
-        var args = lastArgs;
-        var thisArg = lastThis;
-        lastArgs = lastThis = undefined;
-        lastInvokeTime = time;
-        result = func.apply(thisArg, args);
-        return result;
-    }
-    function startTimer(pendingFunc, tmr) {
-        if (useRAF) {
-            root.cancelAnimationFrame(timerId);
-            return root.requestAnimationFrame(pendingFunc);
-        }
-        return setTimeout(pendingFunc, tmr);
-    }
-    function cancelTimer(id) {
-        if (useRAF) {
-            return root.cancelAnimationFrame(id);
-        }
-        clearTimeout(id);
-    }
-    function leadingEdge(time) {
-        // Reset any `maxWait` timer.
-        lastInvokeTime = time;
-        // Start the timer for the trailing edge.
-        timerId = startTimer(timerExpired, wait);
-        // Invoke the leading edge.
-        return leading ? invokeFunc(time) : result;
-    }
-    function remainingWait(time) {
-        var timeSinceLastCall = time - lastCallTime;
-        var timeSinceLastInvoke = time - lastInvokeTime;
-        var timeWaiting = wait - timeSinceLastCall;
-        return maxing
-            ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
-            : timeWaiting;
-    }
-    function shouldInvoke(time) {
-        var timeSinceLastCall = time - lastCallTime;
-        var timeSinceLastInvoke = time - lastInvokeTime;
-        // Either this is the first call, activity has stopped and we're at the
-        // trailing edge, the system time has gone backwards and we're treating
-        // it as the trailing edge, or we've hit the `maxWait` limit.
-        return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
-            (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
-    }
-    function timerExpired() {
-        var time = Date.now();
-        if (shouldInvoke(time)) {
-            return trailingEdge(time);
-        }
-        // Restart the timer.
-        timerId = startTimer(timerExpired, remainingWait(time));
-    }
-    function trailingEdge(time) {
-        timerId = undefined;
-        // Only invoke if we have `lastArgs` which means `func` has been
-        // debounced at least once.
-        if (trailing && lastArgs) {
-            return invokeFunc(time);
-        }
-        lastArgs = lastThis = undefined;
-        return result;
-    }
-    function cancel() {
-        if (timerId !== undefined) {
-            cancelTimer(timerId);
-        }
-        lastInvokeTime = 0;
-        lastArgs = lastCallTime = lastThis = timerId = undefined;
-    }
-    function flush() {
-        return timerId === undefined ? result : trailingEdge(Date.now());
-    }
-    function pending() {
-        return timerId !== undefined;
-    }
-    function debounced() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var time = Date.now();
-        var isInvoking = shouldInvoke(time);
-        lastArgs = args;
-        /* @ts-ignore */
-        lastThis = this;
-        lastCallTime = time;
-        if (isInvoking) {
-            if (timerId === undefined) {
-                return leadingEdge(lastCallTime);
-            }
-            if (maxing) {
-                // Handle invocations in a tight loop.
-                timerId = startTimer(timerExpired, wait);
-                return invokeFunc(lastCallTime);
-            }
-        }
-        if (timerId === undefined) {
-            timerId = startTimer(timerExpired, wait);
-        }
-        return result;
-    }
-    debounced.cancel = cancel;
-    debounced.flush = flush;
-    debounced.pending = pending;
-    return debounced;
-}
-/**
- * @hidden
- */
-export function throttle(func, wait) {
-    return debounce(func, wait, {
-        leading: true,
-        trailing: true,
-        'maxWait': wait
-    });
-}

package/dist/es/virtualization/Virtualization.js

@@ -1,317 +0,0 @@
-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;
-import * as React from 'react';
-import * as PropTypes from 'prop-types';
-import { classNames } from '@progress/kendo-react-common';
-import { RowHeightService, ScrollerService } from './services';
-/**
- * @hidden
- */
-export var ScrollDirection;
-(function (ScrollDirection) {
-    ScrollDirection[ScrollDirection["Backward"] = 0] = "Backward";
-    ScrollDirection[ScrollDirection["Forward"] = 1] = "Forward";
-})(ScrollDirection || (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 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 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 = classNames('k-content k-scrollable', {
-            'k-scrollable-horizontal': this.direction === 'horizontal'
-        }, this.props.className);
-        var scrollableClassNames = 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));
-export { Virtualization };

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

@@ -1,68 +0,0 @@
-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));
-};
-/**
- * @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;
-}());
-export { RowHeightService };