@dereekb/date 9.24.46 → 9.25.0

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

@@ -0,0 +1,667 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandDateCellScheduleRangeToDateCellRanges = exports.expandDateCellScheduleRange = exports.expandDateCellSchedule = exports.expandDateCellScheduleFactory = exports.dateCellScheduleDateCellTimingFilter = exports.dateCellScheduleDateFilter = exports.copyDateCellScheduleDateFilterConfig = exports.fullDateCellScheduleRange = exports.DEFAULT_FULL_DATE_SCHEDULE_RANGE_DURATION = exports.isSameFullDateCellScheduleDateRange = exports.isFullDateCellScheduleDateRange = exports.isSameDateCellScheduleEventRange = exports.dateCellScheduleDateRange = exports.isSameDateCellScheduleDateRange = exports.isDateCellScheduleStartOfDayDateRange = exports.isDateCellScheduleDateRange = exports.DateCellSchedule = exports.isSameDateCellSchedule = exports.isDateCellSchedule = exports.dateCellScheduleDayCodesAreSetsEquivalent = exports.dateCellScheduleDayCodeFactory = exports.rawDateCellScheduleDayCodes = exports.expandDateCellScheduleDayCodesToDayCodesSet = exports.expandDateCellScheduleDayCodes = exports.dateCellScheduleDayCodesSetFromDaysOfWeek = exports.expandDateCellScheduleDayCodesToDayOfWeekSet = exports.simplifyDateCellScheduleDayCodes = exports.dateCellScheduleEncodedWeek = exports.isEmptyDateCellScheduleEncodedWeek = exports.isDateCellScheduleEncodedWeek = exports.DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = exports.dateCellScheduleDayCodesFromEnabledDays = exports.enabledDaysFromDateCellScheduleDayCodes = exports.weekendDateCellScheduleDayCodes = exports.weekdayDateCellScheduleDayCodes = exports.fullWeekDateCellScheduleDayCodes = exports.DateCellScheduleDayCode = 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_fns_1 = require("date-fns");
+const date_1 = require("./date");
+const date_cell_1 = require("./date.cell");
+const date_cell_factory_1 = require("./date.cell.factory");
+const date_cell_filter_1 = require("./date.cell.filter");
+const date_cell_index_1 = require("./date.cell.index");
+const date_cell_week_1 = require("./date.cell.week");
+const date_range_1 = require("./date.range");
+const date_timezone_1 = require("./date.timezone");
+const date_week_1 = require("./date.week");
+var DateCellScheduleDayCode;
+(function (DateCellScheduleDayCode) {
+    /**
+     * Special no-op/unused code
+     */
+    DateCellScheduleDayCode[DateCellScheduleDayCode["NONE"] = 0] = "NONE";
+    DateCellScheduleDayCode[DateCellScheduleDayCode["SUNDAY"] = 1] = "SUNDAY";
+    DateCellScheduleDayCode[DateCellScheduleDayCode["MONDAY"] = 2] = "MONDAY";
+    DateCellScheduleDayCode[DateCellScheduleDayCode["TUESDAY"] = 3] = "TUESDAY";
+    DateCellScheduleDayCode[DateCellScheduleDayCode["WEDNESDAY"] = 4] = "WEDNESDAY";
+    DateCellScheduleDayCode[DateCellScheduleDayCode["THURSDAY"] = 5] = "THURSDAY";
+    DateCellScheduleDayCode[DateCellScheduleDayCode["FRIDAY"] = 6] = "FRIDAY";
+    DateCellScheduleDayCode[DateCellScheduleDayCode["SATURDAY"] = 7] = "SATURDAY";
+    /**
+     * All weekdays (Mon-Fri)
+     */
+    DateCellScheduleDayCode[DateCellScheduleDayCode["WEEKDAY"] = 8] = "WEEKDAY";
+    /**
+     * All weekend days (Sat/Sun)
+     */
+    DateCellScheduleDayCode[DateCellScheduleDayCode["WEEKEND"] = 9] = "WEEKEND";
+})(DateCellScheduleDayCode = exports.DateCellScheduleDayCode || (exports.DateCellScheduleDayCode = {}));
+function fullWeekDateCellScheduleDayCodes() {
+    return [DateCellScheduleDayCode.WEEKDAY, DateCellScheduleDayCode.WEEKEND];
+}
+exports.fullWeekDateCellScheduleDayCodes = fullWeekDateCellScheduleDayCodes;
+function weekdayDateCellScheduleDayCodes() {
+    return [DateCellScheduleDayCode.MONDAY, DateCellScheduleDayCode.TUESDAY, DateCellScheduleDayCode.WEDNESDAY, DateCellScheduleDayCode.THURSDAY, DateCellScheduleDayCode.FRIDAY];
+}
+exports.weekdayDateCellScheduleDayCodes = weekdayDateCellScheduleDayCodes;
+function weekendDateCellScheduleDayCodes() {
+    return [DateCellScheduleDayCode.SATURDAY, DateCellScheduleDayCode.SUNDAY];
+}
+exports.weekendDateCellScheduleDayCodes = weekendDateCellScheduleDayCodes;
+/**
+ * Creates an EnabledDays from the input.
+ *
+ * @param input
+ * @returns
+ */
+function enabledDaysFromDateCellScheduleDayCodes(input) {
+    const days = expandDateCellScheduleDayCodesToDayOfWeekSet(Array.from(new Set(input)));
+    return (0, util_1.enabledDaysFromDaysOfWeek)(days);
+}
+exports.enabledDaysFromDateCellScheduleDayCodes = enabledDaysFromDateCellScheduleDayCodes;
+/**
+ * Creates an array of simplified DateCellScheduleDayCode[] values from the input.
+ *
+ * @param input
+ * @returns
+ */
+function dateCellScheduleDayCodesFromEnabledDays(input) {
+    const days = (0, util_1.daysOfWeekFromEnabledDays)(input);
+    const scheduleDayCodes = days.map((x) => x + 1);
+    return simplifyDateCellScheduleDayCodes(scheduleDayCodes);
+}
+exports.dateCellScheduleDayCodesFromEnabledDays = dateCellScheduleDayCodesFromEnabledDays;
+exports.DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX = /^[0-9]{0,9}$/;
+/**
+ * Returns true if the input is a DateCellScheduleEncodedWeek.
+ *
+ * @param input
+ * @returns
+ */
+function isDateCellScheduleEncodedWeek(input) {
+    return exports.DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX.test(input);
+}
+exports.isDateCellScheduleEncodedWeek = isDateCellScheduleEncodedWeek;
+/**
+ * Returns true if the input string represents an empty DateCellScheduleEncodedWeek.
+ *
+ * @param input
+ * @returns
+ */
+function isEmptyDateCellScheduleEncodedWeek(input) {
+    return input === '' || input === '0';
+}
+exports.isEmptyDateCellScheduleEncodedWeek = isEmptyDateCellScheduleEncodedWeek;
+/**
+ * Creates a DateCellScheduleEncodedWeek from an array of DateCellScheduleDayCode values.
+ *
+ * The returned encoded week is simplified.
+ *
+ * @param codes
+ */
+function dateCellScheduleEncodedWeek(codes) {
+    const result = simplifyDateCellScheduleDayCodes(codes);
+    return result.join('');
+}
+exports.dateCellScheduleEncodedWeek = dateCellScheduleEncodedWeek;
+/**
+ * Reduces/merges any day codes into more simplified day codes.
+ *
+ * For instance, if all days of the week are selected, they will be reduced to "8".
+ *
+ * @param codes
+ * @returns
+ */
+function simplifyDateCellScheduleDayCodes(codes) {
+    const codesSet = new Set(codes);
+    const result = [];
+    if (codesSet.size >= 2) {
+        let weekDays;
+        let hasAllWeekDays = codesSet.has(DateCellScheduleDayCode.WEEKDAY);
+        if (!hasAllWeekDays) {
+            weekDays = (0, util_1.range)(DateCellScheduleDayCode.MONDAY, DateCellScheduleDayCode.SATURDAY).filter((code) => codesSet.has(code));
+            hasAllWeekDays = weekDays.length === 5;
+        }
+        const hasSaturday = codesSet.has(DateCellScheduleDayCode.SATURDAY);
+        const hasSunday = codesSet.has(DateCellScheduleDayCode.SUNDAY);
+        const hasAllWeekendDays = codesSet.has(DateCellScheduleDayCode.WEEKEND) || (hasSaturday && hasSunday);
+        if (!hasAllWeekendDays && hasSunday) {
+            result.push(DateCellScheduleDayCode.SUNDAY);
+        }
+        if (!hasAllWeekDays) {
+            (0, util_1.mergeArrayIntoArray)(result, weekDays);
+        }
+        if (!hasAllWeekendDays && hasSaturday) {
+            result.push(DateCellScheduleDayCode.SATURDAY);
+        }
+        if (hasAllWeekDays) {
+            result.push(DateCellScheduleDayCode.WEEKDAY);
+        }
+        if (hasAllWeekendDays) {
+            result.push(DateCellScheduleDayCode.WEEKEND);
+        }
+    }
+    else {
+        const only = (0, util_1.firstValueFromIterable)(codesSet);
+        if (only) {
+            result.push(only);
+        }
+    }
+    return result;
+}
+exports.simplifyDateCellScheduleDayCodes = simplifyDateCellScheduleDayCodes;
+/**
+ * Expands the input DateCellScheduleDayCodesInput to a Set of DayOfWeek values.
+ *
+ * @param input
+ * @returns
+ */
+function expandDateCellScheduleDayCodesToDayOfWeekSet(input) {
+    const days = new Set();
+    const dayCodesSet = expandDateCellScheduleDayCodesToDayCodesSet(input);
+    (0, util_1.forEachInIterable)(dayCodesSet, (code) => {
+        days.add((code - 1));
+    });
+    return days;
+}
+exports.expandDateCellScheduleDayCodesToDayOfWeekSet = expandDateCellScheduleDayCodesToDayOfWeekSet;
+function dateCellScheduleDayCodesSetFromDaysOfWeek(input) {
+    const codes = new Set();
+    (0, util_1.forEachInIterable)(input, (code) => {
+        codes.add((code + 1));
+    });
+    return codes;
+}
+exports.dateCellScheduleDayCodesSetFromDaysOfWeek = dateCellScheduleDayCodesSetFromDaysOfWeek;
+/**
+ * Expands the input into an array of DateCellScheduleDayCode values.
+ *
+ * @param input
+ * @returns
+ */
+function expandDateCellScheduleDayCodes(input) {
+    return Array.from(expandDateCellScheduleDayCodesToDayCodesSet(input));
+}
+exports.expandDateCellScheduleDayCodes = expandDateCellScheduleDayCodes;
+/**
+ * Expands the input DateCellScheduleDayCodesInput to a Set of DayOfWeek values.
+ *
+ * @param input
+ * @returns
+ */
+function expandDateCellScheduleDayCodesToDayCodesSet(input) {
+    const codes = rawDateCellScheduleDayCodes(input);
+    const days = new Set();
+    codes.forEach((code) => {
+        switch (code) {
+            case 0:
+                // do nothing
+                break;
+            case 8:
+                (0, util_1.addToSet)(days, weekdayDateCellScheduleDayCodes()); // monday-friday
+                break;
+            case 9:
+                (0, util_1.addToSet)(days, weekendDateCellScheduleDayCodes());
+                break;
+            default: // remove offset
+                days.add(code);
+                break;
+        }
+    });
+    return days;
+}
+exports.expandDateCellScheduleDayCodesToDayCodesSet = expandDateCellScheduleDayCodesToDayCodesSet;
+/**
+ * Converts the input DateCellScheduleDayCodesInput to an array of DateCellScheduleDayCode values, but does not expand
+ *
+ * @param input
+ * @returns
+ */
+function rawDateCellScheduleDayCodes(input) {
+    let dayCodes;
+    switch (typeof input) {
+        case 'string':
+            dayCodes = Array.from(new Set(input)).map((x) => Number(x));
+            break;
+        case 'number':
+            dayCodes = [input];
+            break;
+        default:
+            dayCodes = Array.from(input);
+            break;
+    }
+    return dayCodes.filter((x) => Boolean(x)); // filter out "none" code
+}
+exports.rawDateCellScheduleDayCodes = rawDateCellScheduleDayCodes;
+/**
+ * Creates a DateCellScheduleDayCodeFactory using the optional input config.
+ *
+ * @param config
+ * @returns
+ */
+function dateCellScheduleDayCodeFactory(config) {
+    const normal = (0, date_week_1.yearWeekCodeDateTimezoneInstance)(config === null || config === void 0 ? void 0 : config.timezone);
+    return (date) => {
+        const target = normal.systemDateToTargetDate(date);
+        const day = (0, date_fns_1.getDay)(target);
+        return day + 1;
+    };
+}
+exports.dateCellScheduleDayCodeFactory = dateCellScheduleDayCodeFactory;
+/**
+ * Returns true if the input codes, when expanded, are equivalent.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+function dateCellScheduleDayCodesAreSetsEquivalent(a, b) {
+    const ae = expandDateCellScheduleDayCodes(a);
+    const be = expandDateCellScheduleDayCodes(b);
+    return (0, util_1.iterablesAreSetEquivalent)(ae, be);
+}
+exports.dateCellScheduleDayCodesAreSetsEquivalent = dateCellScheduleDayCodesAreSetsEquivalent;
+/**
+ * Returns true if the input is a DateCellSchedule.
+ *
+ * @param input
+ * @returns
+ */
+function isDateCellSchedule(input) {
+    if (typeof input === 'object') {
+        const asRange = input;
+        return (typeof asRange.w === 'string' && !asRange.ex) || (Array.isArray(asRange.ex) && !asRange.d) || Array.isArray(asRange.d);
+    }
+    return false;
+}
+exports.isDateCellSchedule = isDateCellSchedule;
+function isSameDateCellSchedule(a, b) {
+    if (a && b) {
+        return a.w === b.w && (0, util_1.iterablesAreSetEquivalent)(a.ex, b.ex) && (0, util_1.iterablesAreSetEquivalent)(a.d, b.d);
+    }
+    else {
+        return a == b;
+    }
+}
+exports.isSameDateCellSchedule = isSameDateCellSchedule;
+class DateCellSchedule {
+    constructor(template) {
+        if (template) {
+            this.w = template.w;
+            this.d = template.d;
+            this.ex = template.ex;
+        }
+    }
+}
+tslib_1.__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.Matches)(exports.DATE_CELL_SCHEDULE_ENCODED_WEEK_REGEX),
+    tslib_1.__metadata("design:type", String)
+], DateCellSchedule.prototype, "w", void 0);
+tslib_1.__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Min)(0, { each: true }),
+    (0, class_validator_1.IsArray)(),
+    tslib_1.__metadata("design:type", Array)
+], DateCellSchedule.prototype, "d", void 0);
+tslib_1.__decorate([
+    (0, class_transformer_1.Expose)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.Min)(0, { each: true }),
+    (0, class_validator_1.IsArray)(),
+    tslib_1.__metadata("design:type", Array)
+], DateCellSchedule.prototype, "ex", void 0);
+exports.DateCellSchedule = DateCellSchedule;
+/**
+ * Returns true if the input is possibly a FullDateCellScheduleRange.
+ *
+ * Does not check that the input is a valid FullDateCellScheduleRange.
+ *
+ * @param input
+ * @returns
+ */
+function isDateCellScheduleDateRange(input) {
+    if (typeof input === 'object') {
+        const asRange = input;
+        return isDateCellSchedule(asRange) && (0, date_1.isDate)(asRange.end) && (0, date_1.isDate)(asRange.start);
+    }
+    return false;
+}
+exports.isDateCellScheduleDateRange = isDateCellScheduleDateRange;
+/**
+ * Returns true if the input is a DateCellScheduleDateRange without a duration or startsAt.
+ *
+ * @param input
+ * @returns
+ */
+function isDateCellScheduleStartOfDayDateRange(input) {
+    if (isDateCellScheduleDateRange(input) && input.duration == null && input.startsAt == null) {
+        const { start, end, timezone } = input;
+        const normalInstance = (0, date_timezone_1.dateTimezoneUtcNormal)(timezone);
+        return normalInstance.isStartOfDayInTargetTimezone(start) && normalInstance.isStartOfDayInTargetTimezone(end);
+    }
+    return false;
+}
+exports.isDateCellScheduleStartOfDayDateRange = isDateCellScheduleStartOfDayDateRange;
+/**
+ * Returns true if both inputs have the same schedule and date range.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+function isSameDateCellScheduleDateRange(a, b) {
+    if (a && b) {
+        return (0, date_range_1.isSameDateRange)(a, b) && isSameDateCellSchedule(a, b);
+    }
+    else {
+        return a == b;
+    }
+}
+exports.isSameDateCellScheduleDateRange = isSameDateCellScheduleDateRange;
+/**
+ * Creates a DateCellScheduleDateRange from the input.
+ *
+ * @param input
+ * @returns
+ */
+function dateCellScheduleDateRange(input) {
+    const { w, ex, d, start: inputStart, startsAt: inputStartsAt, end: inputEnd, timezone: inputTimezone } = input;
+    const timezone = inputTimezone !== null && inputTimezone !== void 0 ? inputTimezone : (0, date_1.requireCurrentTimezone)(); // treat input as the current timezone
+    const normalInstance = (0, date_timezone_1.dateTimezoneUtcNormal)(timezone);
+    let start;
+    let end;
+    // either start or startsAt is provided
+    if (inputStart != null) {
+        const startInSystemTimezone = normalInstance.systemDateToTargetDate(inputStart); // start needs to be in the system timezone normal before processing.
+        start = normalInstance.startOfDayInTargetTimezone(startInSystemTimezone); // ensure the start of the day is set/matches the timezone.
+    }
+    else {
+        if (inputStartsAt != null) {
+            start = normalInstance.startOfDayInTargetTimezone(inputStartsAt);
+        }
+        else if (inputEnd != null) {
+            start = normalInstance.startOfDayInTargetTimezone(inputEnd); // start on the same day as the end date
+        }
+        else {
+            throw new Error('Could not determine the proper start value for the dateCellScheduleDateRange().');
+        }
+    }
+    // set the end value
+    end = inputEnd !== null && inputEnd !== void 0 ? inputEnd : (0, date_fns_1.addMinutes)(start, 1); // default the end to one minute after the start
+    return {
+        w,
+        ex,
+        d,
+        start,
+        end,
+        timezone
+    };
+}
+exports.dateCellScheduleDateRange = dateCellScheduleDateRange;
+/**
+ * Returns true if both inputs have the same FullDateCellScheduleRange.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+function isSameDateCellScheduleEventRange(a, b) {
+    if (a && b) {
+        return isSameDateCellScheduleDateRange(a, b) && isSameDateCellScheduleEventRange(a, b);
+    }
+    else {
+        return a == b;
+    }
+}
+exports.isSameDateCellScheduleEventRange = isSameDateCellScheduleEventRange;
+/**
+ * Returns true if the input is possibly a FullDateCellScheduleRange.
+ *
+ * Does not check that the input is a valid FullDateCellScheduleRange.
+ *
+ * @param input
+ * @returns
+ */
+function isFullDateCellScheduleDateRange(input) {
+    if (typeof input === 'object') {
+        const asRange = input;
+        return isDateCellSchedule(asRange) && (0, date_cell_1.isFullDateCellTiming)(asRange);
+    }
+    return false;
+}
+exports.isFullDateCellScheduleDateRange = isFullDateCellScheduleDateRange;
+/**
+ * Returns true if both inputs have the same FullDateCellScheduleRange.
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+function isSameFullDateCellScheduleDateRange(a, b) {
+    if (a && b) {
+        return isSameDateCellScheduleDateRange(a, b) && (0, date_cell_1.isSameFullDateCellTiming)(a, b);
+    }
+    else {
+        return a == b;
+    }
+}
+exports.isSameFullDateCellScheduleDateRange = isSameFullDateCellScheduleDateRange;
+/**
+ * If a duration is not set, this is the default used.
+ */
+exports.DEFAULT_FULL_DATE_SCHEDULE_RANGE_DURATION = 1;
+/**
+ * Creates a FullDateCellScheduleRange from the input.
+ */
+function fullDateCellScheduleRange(input) {
+    const { dateCellScheduleRange, duration: inputDefaultDuration, startsAtTime: inputDefaultStartsAtTime, updateWithDefaults } = input;
+    let initialFullDateRange;
+    const inputStartsAt = dateCellScheduleRange.startsAt;
+    const inputDuration = dateCellScheduleRange.duration;
+    const needsDurationAdjustment = inputStartsAt == null || (updateWithDefaults && inputDefaultDuration != null);
+    const needsStartsAtAdjustment = inputDuration == null || (updateWithDefaults && inputDefaultStartsAtTime != null);
+    if (isFullDateCellScheduleDateRange(dateCellScheduleRange)) {
+        initialFullDateRange = dateCellScheduleRange; // no need to create a FullDateCellScheduleRange
+    }
+    else {
+        // fill in the blanks for the date range
+        const initialDateRange = dateCellScheduleDateRange(dateCellScheduleRange);
+        initialDateRange.startsAt = inputStartsAt !== null && inputStartsAt !== void 0 ? inputStartsAt : initialDateRange.start;
+        initialDateRange.duration = inputDuration !== null && inputDuration !== void 0 ? inputDuration : exports.DEFAULT_FULL_DATE_SCHEDULE_RANGE_DURATION; // copy duration and startsAt
+        initialFullDateRange = initialDateRange;
+        if (isDateCellScheduleStartOfDayDateRange(dateCellScheduleRange)) {
+            initialFullDateRange.end = (0, date_fns_1.addMinutes)(initialFullDateRange.end, initialDateRange.duration);
+        }
+    }
+    let fullDateCellTiming = initialFullDateRange;
+    // Apply adjustments as needed
+    if (needsDurationAdjustment || needsStartsAtAdjustment) {
+        fullDateCellTiming = (0, date_cell_factory_1.updateDateCellTimingWithDateCellTimingEvent)({
+            timing: initialFullDateRange,
+            event: {
+                startsAt: inputDefaultStartsAtTime !== null && inputDefaultStartsAtTime !== void 0 ? inputDefaultStartsAtTime : initialFullDateRange.startsAt,
+                duration: inputDefaultDuration !== null && inputDefaultDuration !== void 0 ? inputDefaultDuration : initialFullDateRange.duration
+            },
+            // flag to replace the necessary items
+            replaceStartsAt: needsStartsAtAdjustment,
+            replaceDuration: needsDurationAdjustment
+        });
+    }
+    const result = {
+        timezone: fullDateCellTiming.timezone,
+        start: fullDateCellTiming.start,
+        startsAt: fullDateCellTiming.startsAt,
+        end: fullDateCellTiming.end,
+        duration: fullDateCellTiming.duration,
+        w: initialFullDateRange.w,
+        ex: initialFullDateRange.ex,
+        d: initialFullDateRange.d
+    };
+    return result;
+}
+exports.fullDateCellScheduleRange = fullDateCellScheduleRange;
+function copyDateCellScheduleDateFilterConfig(inputFilter) {
+    return {
+        start: inputFilter.start,
+        startsAt: inputFilter.startsAt,
+        end: inputFilter.end,
+        timezone: inputFilter.timezone,
+        w: inputFilter.w,
+        d: inputFilter.d,
+        ex: inputFilter.ex,
+        // filter extras
+        minMaxDateRange: inputFilter.minMaxDateRange,
+        setStartAsMinDate: inputFilter.setStartAsMinDate
+    };
+}
+exports.copyDateCellScheduleDateFilterConfig = copyDateCellScheduleDateFilterConfig;
+/**
+ * Creates a DateCellScheduleDateFilter.
+ *
+ * @param config
+ * @returns
+ */
+function dateCellScheduleDateFilter(config) {
+    const { w, start: inputStart, startsAt: inputStartsAt, end: inputEnd, timezone: inputTimezone, setStartAsMinDate = true, minMaxDateRange } = config;
+    const timezone = inputTimezone !== null && inputTimezone !== void 0 ? inputTimezone : (0, date_1.requireCurrentTimezone)(); // if the timezone is not provided, assume the startsAt is a system timezone normal.
+    const normalInstance = (0, date_timezone_1.dateTimezoneUtcNormal)(timezone);
+    // derive the startsAt time for the range. If not provided, defaults to inputStart, or midnight in the target timezone.
+    const startsAt = inputStartsAt != null ? inputStartsAt : inputStart !== null && inputStart !== void 0 ? inputStart : normalInstance.startOfDayInTargetTimezone();
+    const startsAtInSystem = normalInstance.systemDateToTargetDate(startsAt);
+    const allowedDays = expandDateCellScheduleDayCodesToDayOfWeekSet(w);
+    // Start date is either now or the filter's start date. It is never the minMax's start date, since that is irrelevant to the filter's range.
+    const firstDateDay = (0, date_fns_1.getDay)(startsAtInSystem);
+    const dayForIndex = (0, date_cell_week_1.dateCellDayOfWeekFactory)(firstDateDay);
+    const dateIndexForDate = (0, date_cell_factory_1.dateCellTimingRelativeIndexFactory)({ startsAt, timezone });
+    let end;
+    if (inputEnd != null) {
+        // use the startsAt time instead of the end time because endsAt can fall into the next day index range
+        const { expectedFinalStartsAt } = (0, date_cell_1.calculateExpectedDateCellTimingDurationPair)({ startsAt, timezone, end: inputEnd });
+        end = expectedFinalStartsAt;
+    }
+    const indexFloor = setStartAsMinDate ? 0 : Number.MIN_SAFE_INTEGER;
+    const minAllowedIndex = (minMaxDateRange === null || minMaxDateRange === void 0 ? void 0 : minMaxDateRange.start) != null ? Math.max(indexFloor, dateIndexForDate(minMaxDateRange.start)) : indexFloor; // start date should be the min inde
+    const maxAllowedIndex = end != null ? dateIndexForDate(end) : (minMaxDateRange === null || minMaxDateRange === void 0 ? void 0 : minMaxDateRange.end) != null ? dateIndexForDate(minMaxDateRange.end) : Number.MAX_SAFE_INTEGER; // max "to" value
+    const includedIndexes = new Set(config.d);
+    const excludedIndexes = new Set(config.ex);
+    return (input) => {
+        let i;
+        let day;
+        if (typeof input === 'number') {
+            i = input;
+        }
+        else {
+            i = dateIndexForDate(input);
+        }
+        day = dayForIndex(i);
+        const result = (i >= minAllowedIndex && i <= maxAllowedIndex && allowedDays.has(day) && !excludedIndexes.has(i)) || includedIndexes.has(i);
+        return result;
+    };
+}
+exports.dateCellScheduleDateFilter = dateCellScheduleDateFilter;
+/**
+ * Creates a DateCellScheduleDateCellTimingFilter.
+ *
+ * @param param0
+ * @returns
+ */
+function dateCellScheduleDateCellTimingFilter({ timing, schedule }) {
+    const isAllowed = dateCellScheduleDateFilter({
+        w: schedule.w,
+        d: schedule.d,
+        ex: schedule.ex,
+        startsAt: timing.startsAt,
+        end: timing.end,
+        timezone: timing.timezone
+    });
+    return (block) => {
+        const i = block.i;
+        return isAllowed(i);
+    };
+}
+exports.dateCellScheduleDateCellTimingFilter = dateCellScheduleDateCellTimingFilter;
+/**
+ * Creates a DateCellTimingExpansionFactory using the input DateCellScheduleDateCellTimingFilterConfig.
+ *
+ * @param config
+ * @returns
+ */
+function expandDateCellScheduleFactory(config) {
+    const { invertSchedule = false, now, onlyBlocksThatHaveEnded, onlyBlocksThatHaveStarted, onlyBlocksNotYetEnded, onlyBlocksNotYetStarted, maxDateCellsToReturn, durationSpanFilter: inputDurationSpanFilter } = config;
+    let durationSpanFilter;
+    let durationSpanFilters = [];
+    if (inputDurationSpanFilter) {
+        durationSpanFilters.push(inputDurationSpanFilter);
+    }
+    if (onlyBlocksNotYetStarted) {
+        durationSpanFilters.push((0, date_cell_filter_1.dateCellDurationSpanHasNotStartedFilterFunction)(now));
+    }
+    else if (onlyBlocksThatHaveEnded) {
+        durationSpanFilters.push((0, date_cell_filter_1.dateCellDurationSpanHasEndedFilterFunction)(now));
+    }
+    else {
+        if (onlyBlocksThatHaveStarted) {
+            durationSpanFilters.push((0, date_cell_filter_1.dateCellDurationSpanHasStartedFilterFunction)(now));
+        }
+        if (onlyBlocksNotYetEnded) {
+            durationSpanFilters.push((0, date_cell_filter_1.dateCellDurationSpanHasNotEndedFilterFunction)(now));
+        }
+    }
+    durationSpanFilter = (0, util_1.mergeFilterFunctions)(...durationSpanFilters);
+    const expansionFactory = (0, date_cell_factory_1.dateCellTimingExpansionFactory)({
+        timing: config.timing,
+        filter: (0, util_1.invertFilter)(dateCellScheduleDateCellTimingFilter(config), invertSchedule),
+        durationSpanFilter,
+        maxDateCellsToReturn
+    });
+    return expansionFactory;
+}
+exports.expandDateCellScheduleFactory = expandDateCellScheduleFactory;
+/**
+ * Expands the input DateCellTiming and DateCellSchedule into an array of DateCellDurationSpan value that correspond with blocks in the event.
+ *
+ * Can optionally provide an IndexRange to specify a specific range to filter on. The range will be capped to the range of the timing.
+ *
+ * @param timing
+ * @param schedule
+ * @param inputRange
+ * @returns
+ */
+function expandDateCellSchedule(input) {
+    const { timing, limitIndexRange } = input;
+    const expansionFactory = expandDateCellScheduleFactory(input);
+    const completeRange = (0, date_cell_factory_1.dateCellIndexRange)(timing);
+    const range = limitIndexRange ? { minIndex: Math.max(limitIndexRange.minIndex, completeRange.minIndex), maxIndex: Math.min(limitIndexRange.maxIndex, completeRange.maxIndex) } : completeRange;
+    const dateCellForRange = {
+        i: range.minIndex,
+        to: range.maxIndex
+    }; // Index is considered to be used as inclusive already, so no need to use dateCellIndexRangeToDateCellRange
+    return expansionFactory([dateCellForRange]);
+}
+exports.expandDateCellSchedule = expandDateCellSchedule;
+/**
+ *
+ * @param input
+ * @returns
+ */
+function expandDateCellScheduleRange(input) {
+    const { dateCellScheduleRange, duration, startsAtTime } = input;
+    const fullDateRange = fullDateCellScheduleRange({
+        dateCellScheduleRange,
+        duration,
+        startsAtTime,
+        updateWithDefaults: true
+    });
+    return expandDateCellSchedule(Object.assign(Object.assign({}, input), { schedule: fullDateRange, timing: fullDateRange }));
+}
+exports.expandDateCellScheduleRange = expandDateCellScheduleRange;
+function expandDateCellScheduleRangeToDateCellRanges(input) {
+    const dateCellDurationSpans = expandDateCellScheduleRange(input);
+    return (0, date_cell_index_1.groupToDateCellRanges)(dateCellDurationSpans);
+}
+exports.expandDateCellScheduleRangeToDateCellRanges = expandDateCellScheduleRangeToDateCellRanges;
+//# sourceMappingURL=date.cell.schedule.js.map