@dereekb/date 9.24.46 → 9.25.0

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

@@ -0,0 +1,731 @@
+"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;
+        }
+    }
+}
+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);
+exports.DateCellRange = DateCellRange;
+/**
+ * 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 since
+ *
+ * @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.mergeArrayIntoArray)(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