@dereekb/date 10.0.5 → 10.0.7

package/src/lib/date/date.cell.index.js

@@ -1,731 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expandUniqueDateCellsFunction = exports.groupUniqueDateCells = exports.dateCellEndIndex = exports.dateCellRangeHasRange = exports.expandDateCellRange = exports.dateRelativeStateForDateCellRangeComparedToIndex = exports.getNextDateCellTimingIndex = exports.dateCellRangesFullyCoverDateCellRangeFunction = exports.dateCellRangeBlocksCount = exports.dateCellRangeBlocksCountInfo = exports.isDateCellWithinDateCellRange = exports.isDateCellWithinDateCellRangeFunction = exports.filterDateCellsInDateCellRange = exports.allIndexesInDateCellRanges = exports.allIndexesInDateCellRange = exports.groupToDateCellRanges = exports.sortDateCellRanges = exports.sortDateCellRangeAndSizeFunction = exports.dateCellRangeOverlapsRange = exports.dateCellRangeOverlapsRangeFunction = exports.dateCellRangeIncludedByRangeFunction = exports.dateCellRangeWithRange = exports.dateCellRangeWithRangeFromIndex = exports.dateCellRange = exports.getLeastAndGreatestDateCellIndexInDateCellRanges = exports.getGreatestDateCellIndexInDateCellRanges = exports.getLeastDateCellIndexInDateCellRanges = exports.isValidDateCellRangeSeries = exports.isValidDateCellRange = exports.isDateCellRange = exports.DateCellRange = void 0;
-const tslib_1 = require("tslib");
-const util_1 = require("@dereekb/util");
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
-const date_cell_1 = require("./date.cell");
-class DateCellRange extends date_cell_1.DateCell {
-    constructor(template) {
-        super(template);
-        if (template) {
-            this.to = template.to;
-        }
-    }
-}
-exports.DateCellRange = DateCellRange;
-tslib_1.__decorate([
-    (0, class_transformer_1.Expose)(),
-    (0, class_validator_1.IsNumber)(),
-    (0, class_validator_1.IsOptional)(),
-    (0, class_validator_1.Min)(0),
-    tslib_1.__metadata("design:type", Number)
-], DateCellRange.prototype, "to", void 0);
-/**
- * Returns true if the input is a DateCellRange.
- *
- * Does not check validity. Use isValidDateCellRange()
- *
- * @param input
- * @returns
- */
-function isDateCellRange(input) {
-    return typeof input === 'object' ? (Number.isInteger(input.i) && input.to === undefined) || Number.isInteger(input.to) : false;
-}
-exports.isDateCellRange = isDateCellRange;
-/**
- * Returns true if the input is a valid DateCellRange.
- *
- * @param input
- * @returns
- */
-function isValidDateCellRange(input) {
-    const { i, to } = input;
-    if (!(0, date_cell_1.isValidDateCellIndex)(i)) {
-        return false;
-    }
-    else if (to != null && (!(0, date_cell_1.isValidDateCellIndex)(to) || to < i)) {
-        return false;
-    }
-    return true;
-}
-exports.isValidDateCellRange = isValidDateCellRange;
-/**
- * Returns true if the input is a sorted DateCellRange array and there are no repeat indexes.
- *
- * @param input
- * @returns
- */
-function isValidDateCellRangeSeries(input) {
-    if (!Array.isArray(input)) {
-        return false;
-    }
-    const invalidRange = input.findIndex((range) => !isValidDateCellRange(range));
-    if (invalidRange !== -1) {
-        return false;
-    }
-    let greatestIndex = -1;
-    for (let i = 0; i < input.length; i += 1) {
-        const range = input[i];
-        if (range.i <= greatestIndex) {
-            return false;
-        }
-        else {
-            const nextGreatestIndex = range.to || range.i; // to is greater than or equal to i in a valid date block range.
-            greatestIndex = nextGreatestIndex;
-        }
-    }
-    return true;
-}
-exports.isValidDateCellRangeSeries = isValidDateCellRangeSeries;
-/**
- * Returns the lowest index between all the input date block ranges. Returns 0 by default if there is no minimum or input blocks.
- *
- * The input range is not expected to be sorted.
- */
-function getLeastDateCellIndexInDateCellRanges(input) {
-    var _a, _b;
-    return (_b = (_a = getLeastAndGreatestDateCellIndexInDateCellRanges(input)) === null || _a === void 0 ? void 0 : _a.leastIndex) !== null && _b !== void 0 ? _b : 0;
-}
-exports.getLeastDateCellIndexInDateCellRanges = getLeastDateCellIndexInDateCellRanges;
-/**
- * Returns the largest index between all the input date block ranges. Returns 0 by default.
- *
- * The input range is not expected to be sorted.
- */
-function getGreatestDateCellIndexInDateCellRanges(input) {
-    var _a, _b;
-    return (_b = (_a = getLeastAndGreatestDateCellIndexInDateCellRanges(input)) === null || _a === void 0 ? void 0 : _a.greatestIndex) !== null && _b !== void 0 ? _b : 0;
-}
-exports.getGreatestDateCellIndexInDateCellRanges = getGreatestDateCellIndexInDateCellRanges;
-/**
- * Returns the largest index between all the input date block ranges. Returns null if the input is empty.
- *
- * The input range is not expected to be sorted.
- */
-function getLeastAndGreatestDateCellIndexInDateCellRanges(input) {
-    if (!input.length) {
-        return null;
-    }
-    let leastIndex = Number.MAX_SAFE_INTEGER;
-    let greatestIndex = 0;
-    let leastIndexItem = input[0];
-    let greatestIndexItem = input[0];
-    for (let i = 0; i < input.length; i += 1) {
-        const range = input[i];
-        const leastRangeIndex = range.i;
-        const greatestRangeIndex = range.to || range.i;
-        if (leastRangeIndex < leastIndex) {
-            leastIndex = leastRangeIndex;
-            leastIndexItem = range;
-        }
-        if (greatestRangeIndex > greatestIndex) {
-            greatestIndex = greatestRangeIndex;
-            greatestIndexItem = range;
-        }
-    }
-    return {
-        leastIndex,
-        leastIndexItem,
-        greatestIndex,
-        greatestIndexItem
-    };
-}
-exports.getLeastAndGreatestDateCellIndexInDateCellRanges = getLeastAndGreatestDateCellIndexInDateCellRanges;
-/**
- * Creates a DateCellRange
- *
- * @param i
- * @param to
- * @returns
- */
-function dateCellRange(i, to) {
-    return { i, to: to !== null && to !== void 0 ? to : i };
-}
-exports.dateCellRange = dateCellRange;
-/**
- * Creates a DateCellRangeWithRange from the input DateCellIndex.
- *
- * @param dateCellIndex
- * @returns
- */
-function dateCellRangeWithRangeFromIndex(dateCellIndex) {
-    return dateCellRange(dateCellIndex, dateCellIndex);
-}
-exports.dateCellRangeWithRangeFromIndex = dateCellRangeWithRangeFromIndex;
-/**
- * Creates a DateCellRangeWithRange from the input DateCellIndex, DateCell, or DateCellRange.
- *
- * @param input
- * @returns
- */
-function dateCellRangeWithRange(input) {
-    if (typeof input === 'number') {
-        return dateCellRangeWithRangeFromIndex(input);
-    }
-    else {
-        return dateCellRange(input.i, input.to);
-    }
-}
-exports.dateCellRangeWithRange = dateCellRangeWithRange;
-/**
- * Creates a DateCellRangeIncludedByRangeFunction
- *
- * @param inputRange
- * @returns
- */
-function dateCellRangeIncludedByRangeFunction(inputRange) {
-    const { i, to } = dateCellRangeWithRange(inputRange);
-    return (input) => {
-        var _a;
-        const range = dateCellRangeWithRange(input);
-        return range.i <= i && ((_a = range === null || range === void 0 ? void 0 : range.to) !== null && _a !== void 0 ? _a : range.i) >= to;
-    };
-}
-exports.dateCellRangeIncludedByRangeFunction = dateCellRangeIncludedByRangeFunction;
-/**
- * Creates a DateCellRangeOverlapsRangeFunction
- *
- * @param inputRange
- * @returns
- */
-function dateCellRangeOverlapsRangeFunction(inputRange) {
-    const { i, to } = dateCellRangeWithRange(inputRange);
-    return (input) => {
-        var _a;
-        const range = dateCellRangeWithRange(input);
-        return range.i <= to && ((_a = range === null || range === void 0 ? void 0 : range.to) !== null && _a !== void 0 ? _a : range.i) >= i;
-    };
-}
-exports.dateCellRangeOverlapsRangeFunction = dateCellRangeOverlapsRangeFunction;
-/**
- * Returns true if either of the ranges overlap eachother.
- *
- * @param rangeA
- * @param rangeB
- * @returns
- */
-function dateCellRangeOverlapsRange(rangeA, rangeB) {
-    return dateCellRangeOverlapsRangeFunction(rangeA)(rangeB);
-}
-exports.dateCellRangeOverlapsRange = dateCellRangeOverlapsRange;
-/**
- * Sorts the input ranges by index and distance (to values).
- *
- * In many cases sortAscendingIndexNumberRefFunction may be preferential.
- *
- * @returns
- */
-function sortDateCellRangeAndSizeFunction() {
-    return (a, b) => { var _a, _b; return a.i - b.i || ((_a = a.to) !== null && _a !== void 0 ? _a : a.i) - ((_b = b.to) !== null && _b !== void 0 ? _b : b.i); };
-}
-exports.sortDateCellRangeAndSizeFunction = sortDateCellRangeAndSizeFunction;
-/**
- * Sorts the input date ranges. This will retain the before/after order while also sorting items by index.
- *
- * @param input
- * @returns
- */
-function sortDateCellRanges(input) {
-    return input.sort((0, util_1.sortAscendingIndexNumberRefFunction)());
-}
-exports.sortDateCellRanges = sortDateCellRanges;
-/**
- * Groups the input values into DateCellRange values.
- *
- * @param input
- */
-function groupToDateCellRanges(input) {
-    var _a;
-    if (input.length === 0) {
-        return [];
-    }
-    // sort by index in ascending order
-    const blocks = sortDateCellRanges(input);
-    function newBlockFromBlocksArrayIndex(blocksArrayIndex) {
-        const { i, to } = blocks[blocksArrayIndex];
-        return {
-            i,
-            to: to !== null && to !== void 0 ? to : i
-        };
-    }
-    // start at the first block
-    let current = newBlockFromBlocksArrayIndex(0);
-    const results = [];
-    for (let i = 1; i < blocks.length; i += 1) {
-        const block = blocks[i];
-        const isContinuous = block.i <= current.to + 1;
-        if (isContinuous) {
-            // extend the current block.
-            current.to = (_a = blocks[i].to) !== null && _a !== void 0 ? _a : blocks[i].i;
-        }
-        else {
-            // complete/create new block.
-            results.push(current);
-            current = newBlockFromBlocksArrayIndex(i);
-        }
-    }
-    results.push(current);
-    return results;
-}
-exports.groupToDateCellRanges = groupToDateCellRanges;
-/**
- * Returns an array containing all indexes in the date block range.
- */
-function allIndexesInDateCellRange(input) {
-    return input.to != null ? (0, util_1.range)(input.i, input.to + 1) : [input.i];
-}
-exports.allIndexesInDateCellRange = allIndexesInDateCellRange;
-/**
- * Returns the set of all indexes within the input.
- *
- * @param input
- * @returns
- */
-function allIndexesInDateCellRanges(input) {
-    const set = new Set();
-    input.forEach((x) => {
-        if (typeof x === 'number') {
-            set.add(x);
-        }
-        else {
-            const allIndexes = allIndexesInDateCellRange(x);
-            (0, util_1.addToSet)(set, allIndexes);
-        }
-    });
-    return set;
-}
-exports.allIndexesInDateCellRanges = allIndexesInDateCellRanges;
-/**
- * Returns blocks that are only in the given DateCellRange.
- *
- * @param blocks
- * @param range
- * @returns
- */
-function filterDateCellsInDateCellRange(blocks, range) {
-    const dateCellIsWithinDateCellRange = isDateCellWithinDateCellRangeFunction(range);
-    return blocks.filter(dateCellIsWithinDateCellRange);
-}
-exports.filterDateCellsInDateCellRange = filterDateCellsInDateCellRange;
-function isDateCellWithinDateCellRangeFunction(inputRange) {
-    const range = dateCellRangeWithRange(inputRange);
-    return (input) => {
-        var _a;
-        if (typeof input === 'number') {
-            input = { i: input };
-        }
-        if (input.i >= range.i) {
-            const to = (_a = input.to) !== null && _a !== void 0 ? _a : input.i;
-            return to <= range.to;
-        }
-        return false;
-    };
-}
-exports.isDateCellWithinDateCellRangeFunction = isDateCellWithinDateCellRangeFunction;
-/**
- * Returns true if the first DateCell or DateCellRange contains the second input.
- *
- * @param range
- * @param isContainedWithin
- * @returns
- */
-function isDateCellWithinDateCellRange(range, contains) {
-    return isDateCellWithinDateCellRangeFunction(range)(dateCellRangeWithRange(contains));
-}
-exports.isDateCellWithinDateCellRange = isDateCellWithinDateCellRange;
-/**
- * Counts the number of blocks in the input range.
- *
- * @param inputDateCellRange
- * @returns
- */
-function dateCellRangeBlocksCountInfo(inputDateCellRange) {
-    const group = groupToDateCellRanges((0, util_1.asArray)(inputDateCellRange));
-    let count = 0;
-    let total = 0;
-    group.forEach((x) => {
-        const blocks = Math.abs(x.to - x.i) + 1; // +1 for inclusivity
-        count += blocks;
-        const size = (0, util_1.sumOfIntegersBetween)(x.i, x.to);
-        total += size;
-    });
-    return {
-        count,
-        total,
-        average: count > 0 ? total / count : 0
-    };
-}
-exports.dateCellRangeBlocksCountInfo = dateCellRangeBlocksCountInfo;
-/**
- * Counts the number of blocks in the input range.
- *
- * @param inputDateCellRange
- * @returns
- */
-function dateCellRangeBlocksCount(inputDateCellRange) {
-    return dateCellRangeBlocksCountInfo(inputDateCellRange).count;
-}
-exports.dateCellRangeBlocksCount = dateCellRangeBlocksCount;
-/**
- * Creates a dateCellRangesFullyCoverDateCellRangeFunction
- *
- * @param ranges
- * @returns
- */
-function dateCellRangesFullyCoverDateCellRangeFunction(ranges) {
-    const groupedRanges = Array.isArray(ranges) ? groupToDateCellRanges(ranges) : [dateCellRangeWithRange(ranges)];
-    return (inputRange) => {
-        const fn = dateCellRangeIncludedByRangeFunction(inputRange);
-        return groupedRanges.findIndex(fn) !== -1;
-    };
-}
-exports.dateCellRangesFullyCoverDateCellRangeFunction = dateCellRangesFullyCoverDateCellRangeFunction;
-/**
- * Computes a GetNextDateCellTimingIndexResult from the input.
- *
- * @param input
- */
-function getNextDateCellTimingIndex(input) {
-    var _a, _b, _c;
-    const { ranges, currentIndex } = input;
-    const relativeStateGroups = (0, util_1.makeValuesGroupMap)((0, util_1.asArray)(ranges), (range) => {
-        return dateRelativeStateForDateCellRangeComparedToIndex(range, currentIndex);
-    });
-    const pastResults = (_a = relativeStateGroups.get('past')) !== null && _a !== void 0 ? _a : [];
-    const presentResults = (_b = relativeStateGroups.get('present')) !== null && _b !== void 0 ? _b : [];
-    const futureResults = (_c = relativeStateGroups.get('future')) !== null && _c !== void 0 ? _c : [];
-    const currentResult = presentResults[0];
-    let nextResult;
-    let nextIndex = currentIndex + 1;
-    const nextResultFromPresent = presentResults.find((x) => dateRelativeStateForDateCellRangeComparedToIndex(x, nextIndex) === 'present');
-    if (nextResultFromPresent) {
-        nextResult = nextResultFromPresent;
-    }
-    else {
-        // search through the future indexes, looking for the one with the lowest index.
-        const greatestAndLeastIndexResult = getLeastAndGreatestDateCellIndexInDateCellRanges(futureResults);
-        if (greatestAndLeastIndexResult) {
-            nextIndex = greatestAndLeastIndexResult.leastIndex;
-            nextResult = greatestAndLeastIndexResult.leastIndexItem;
-        }
-        else {
-            nextIndex = undefined;
-        }
-    }
-    return {
-        currentResult,
-        nextIndex,
-        nextResult,
-        pastResults,
-        presentResults,
-        futureResults
-    };
-}
-exports.getNextDateCellTimingIndex = getNextDateCellTimingIndex;
-/**
- * Returns the DateRelativeState for the given index and range.
- *
- * @param nowIndex
- * @param range
- */
-function dateRelativeStateForDateCellRangeComparedToIndex(range, nowIndex) {
-    const { i, to } = dateCellRange(range.i, range.to);
-    let state;
-    if (i > nowIndex) {
-        state = 'future'; // if i greater, then the range is in the future.
-    }
-    else if (to < nowIndex) {
-        state = 'past'; // if i is less than or equal, and to is less than i, then it is in the past
-    }
-    else {
-        state = 'present';
-    }
-    return state;
-}
-exports.dateRelativeStateForDateCellRangeComparedToIndex = dateRelativeStateForDateCellRangeComparedToIndex;
-/**
- * Expands a DateCellRange into an array of DateCell values.
- *
- * @param block
- * @returns
- */
-function expandDateCellRange(block) {
-    return (0, util_1.range)(block.i, dateCellEndIndex(block) + 1).map((i) => {
-        return Object.assign(Object.assign({}, block), { i, to: i }); // copy block, set to as i
-    });
-}
-exports.expandDateCellRange = expandDateCellRange;
-/**
- * Returns true if the input DateCellRange is longer than 1 block (I.E. has a "to" value greater than it's "i" value).
- *
- * @param input
- */
-function dateCellRangeHasRange(input) {
-    return input.to != null && input.to > input.i;
-}
-exports.dateCellRangeHasRange = dateCellRangeHasRange;
-/**
- * Reads the to index if it exists, or returns the block's index itself.
- *
- * @param input
- * @returns
- */
-function dateCellEndIndex(input) {
-    var _a;
-    return (_a = input.to) !== null && _a !== void 0 ? _a : input.i;
-}
-exports.dateCellEndIndex = dateCellEndIndex;
-/**
- * Groups all input DateCellRange or UniqueDateCell values into a UniqueDateCellRangeGroup value amd sorts the input.
- */
-function groupUniqueDateCells(input) {
-    var _a;
-    const blocks = sortDateCellRanges([...input]);
-    const i = 0;
-    let to;
-    if (blocks.length === 0) {
-        to = i;
-    }
-    else {
-        const lastBlock = (0, util_1.lastValue)(blocks);
-        to = (_a = lastBlock.to) !== null && _a !== void 0 ? _a : lastBlock.i;
-    }
-    return {
-        i,
-        to,
-        blocks
-    };
-}
-exports.groupUniqueDateCells = groupUniqueDateCells;
-function expandUniqueDateCellsFunction(config) {
-    const { startAtIndex = 0, endAtIndex, fillOption: fill, fillFactory: inputFillFactory, retainOnOverlap: inputRetainOnOverlap } = config;
-    const retainOnOverlap = inputRetainOnOverlap !== null && inputRetainOnOverlap !== void 0 ? inputRetainOnOverlap : 'next';
-    const maxAllowedIndex = endAtIndex !== null && endAtIndex !== void 0 ? endAtIndex : Number.MAX_SAFE_INTEGER;
-    const fillFactory = inputFillFactory;
-    if (!fillFactory && fill === 'fill') {
-        throw new Error('fillFactory is required when fillOption is "fill".');
-    }
-    return (input, newBlocks) => {
-        const inputGroup = Array.isArray(input) ? groupUniqueDateCells(input) : input;
-        const sorted = inputGroup.blocks.map((block) => ({ priority: 'current', block }));
-        if (newBlocks != null) {
-            const inputOverwriteGroup = Array.isArray(newBlocks) ? groupUniqueDateCells(newBlocks) : newBlocks;
-            (0, util_1.pushArrayItemsIntoArray)(sorted, inputOverwriteGroup.blocks.map((block) => ({ priority: 'next', block }))).sort((a, b) => a.block.i - b.block.i);
-        }
-        const blocks = [];
-        const discarded = [];
-        let current = sorted[0];
-        let currentNextIndex;
-        let next = sorted[1];
-        let nextStartIndex;
-        let i = 0;
-        let latestTo = startAtIndex - 1;
-        function addBlockWithRange(inputBlock, i, inputTo = i) {
-            // Add in any necessary gap block first
-            const gapSizeBetweenBlocks = i - (latestTo + 1);
-            if (gapSizeBetweenBlocks > 0) {
-                // start at the startAtIndex at a minimum
-                const gapStartIndex = Math.max(latestTo + 1, startAtIndex);
-                addGapBlock(gapStartIndex, i - 1);
-            }
-            const to = Math.min(inputTo, maxAllowedIndex) || 0;
-            const block = Object.assign(Object.assign({}, inputBlock), { i,
-                to });
-            blocks.push(block);
-            latestTo = to;
-            return block;
-        }
-        function completeBlocks() {
-            // extend or fill if there is an endAtIndex value present
-            if (endAtIndex != null && latestTo < endAtIndex) {
-                addGapBlock(latestTo + 1, endAtIndex);
-            }
-        }
-        function addGapBlock(i, inputTo = i) {
-            const to = Math.min(inputTo, maxAllowedIndex);
-            if (fill === 'fill') {
-                const dateCellRange = {
-                    i,
-                    to
-                };
-                const block = fillFactory(dateCellRange);
-                addBlockWithRange(block, i, to !== null && to !== void 0 ? to : i);
-            }
-            else if (blocks.length > 0) {
-                // do not extend if no blocks have been pushed.
-                const blockToExtend = (0, util_1.lastValue)(blocks);
-                blockToExtend.to = inputTo;
-            }
-            latestTo = to;
-        }
-        function continueToNext(use, priority) {
-            i += 1;
-            current = use != null ? { block: use, priority } : sorted[i];
-            next = sorted[i + 1];
-            if (next) {
-                nextStartIndex = next.block.i;
-                // complete loop once past the max allowed index
-                if (nextStartIndex > maxAllowedIndex) {
-                    continueLoop = false;
-                }
-                else {
-                    const nextEndIndex = dateCellEndIndex(next.block);
-                    if (nextEndIndex <= latestTo) {
-                        discardCurrent(); // skip until next is not less than or equal to the latest to
-                        continueToNext();
-                    }
-                }
-            }
-            else {
-                continueLoop = false;
-            }
-        }
-        function discard(pair) {
-            discarded.push(pair.block);
-        }
-        function discardCurrent() {
-            discard(current);
-        }
-        function discardNext() {
-            discard(next);
-            i += 1;
-            continueToNext();
-        }
-        let continueLoop = Boolean(next); // only loop if next is defined, otherwise we just add the final item.
-        /**
-         * Used to determine how to handle two neighboring objects.
-         */
-        function shouldRetainCurrentOverNext() {
-            if (current.priority === next.priority) {
-                return retainOnOverlap === 'current';
-            }
-            else {
-                return current.priority === retainOnOverlap;
-            }
-        }
-        while (continueLoop) {
-            currentNextIndex = current.block.i;
-            nextStartIndex = next.block.i;
-            const currentEndIndex = dateCellEndIndex(current.block);
-            const nextEndIndex = dateCellEndIndex(next.block);
-            if (nextStartIndex < startAtIndex || currentEndIndex < startAtIndex) {
-                // do nothing if the next index is still before the current start index.
-                discardCurrent();
-                continueToNext();
-            }
-            else if (currentNextIndex === nextStartIndex) {
-                // if next has the same range as current, then look at the tie-breaker
-                if (nextEndIndex === currentEndIndex) {
-                    // if they're both on the same index, then take the one based on the overwrite value
-                    if (shouldRetainCurrentOverNext()) {
-                        // add current
-                        addBlockWithRange(current.block, currentNextIndex, nextEndIndex);
-                        // discard and skip the "next" value
-                        discardNext();
-                    }
-                    else {
-                        // discard the current
-                        discardCurrent();
-                        // move on to next
-                        continueToNext();
-                    }
-                }
-                else if (nextEndIndex > currentEndIndex) {
-                    // handle overlap
-                    if (shouldRetainCurrentOverNext()) {
-                        // add current
-                        addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
-                        // change next to start at the next range
-                        continueToNext(Object.assign(Object.assign({}, next.block), { i: currentEndIndex + 1, to: nextEndIndex }), next.priority);
-                    }
-                    else {
-                        //
-                        discardCurrent();
-                        continueToNext();
-                    }
-                }
-                else {
-                    // the next item ends before the current item.
-                    if (shouldRetainCurrentOverNext()) {
-                        // discard the next value.
-                        discard(next);
-                        // continue with the current value
-                        continueToNext(current.block, current.priority);
-                    }
-                    else {
-                        // add the next item first since it overwrites the current
-                        addBlockWithRange(next.block, nextStartIndex, nextEndIndex);
-                        // continue with the current item as next.
-                        continueToNext(Object.assign(Object.assign({}, current.block), { i: nextEndIndex + 1, to: currentEndIndex }), current.priority);
-                    }
-                }
-            }
-            else {
-                // Check for any overlap
-                if (currentEndIndex >= nextStartIndex) {
-                    // handle overlap
-                    if (shouldRetainCurrentOverNext()) {
-                        // add current
-                        addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
-                        if (nextEndIndex > currentEndIndex) {
-                            // change next to start at the next range
-                            continueToNext(Object.assign(Object.assign({}, next.block), { i: currentEndIndex + 1, to: nextEndIndex }), next.priority);
-                        }
-                        else {
-                            // continue normally
-                            continueToNext();
-                        }
-                    }
-                    else {
-                        // add current up to the start index of next
-                        addBlockWithRange(current.block, currentNextIndex, nextStartIndex - 1);
-                        // check if the next one is fully contained
-                        if (nextEndIndex < currentEndIndex) {
-                            // add the next
-                            addBlockWithRange(next.block, nextStartIndex, nextEndIndex);
-                            // continue with the current
-                            continueToNext(Object.assign(Object.assign({}, current.block), { i: nextEndIndex + 1, to: currentEndIndex }), next.priority);
-                        }
-                        else {
-                            // continue to next
-                            continueToNext();
-                        }
-                    }
-                }
-                else {
-                    // no overlap
-                    // add the current block
-                    addBlockWithRange(current.block, currentNextIndex, currentEndIndex);
-                    // continue to next
-                    continueToNext();
-                }
-            }
-        }
-        if (current != null) {
-            // if current != null, then atleast one block was input/remaining.
-            const lastStartIndex = current.block.i;
-            const lastEndIndex = dateCellEndIndex(current.block);
-            if (lastEndIndex < startAtIndex || lastEndIndex <= latestTo || lastStartIndex > maxAllowedIndex) {
-                // if the block ends before the start index, then do nothing.
-                discardCurrent();
-            }
-            else {
-                addBlockWithRange(current.block, Math.max(startAtIndex, lastStartIndex), Math.min(lastEndIndex, maxAllowedIndex));
-            }
-            completeBlocks();
-        }
-        else if (fill === 'fill') {
-            completeBlocks();
-        }
-        const result = {
-            i: 0,
-            blocks,
-            discarded
-        };
-        return result;
-    };
-}
-exports.expandUniqueDateCellsFunction = expandUniqueDateCellsFunction;
-//# sourceMappingURL=date.cell.index.js.map