@dereekb/dbx-form 9.25.4 → 9.25.6

package/fesm2015/dereekb-dbx-form-calendar.mjs

@@ -5,7 +5,7 @@ import { Injectable, SkipSelf, Directive, Injector, Optional, Component, Inject,
 import { FieldType } from '@ngx-formly/material';
 import { switchMap, first, tap, map, distinctUntilChanged, shareReplay, of, combineLatestWith, BehaviorSubject, filter, combineLatest, EMPTY, startWith, throttleTime } from 'rxjs';
 import { filterMaybe, distinctUntilHasDifferentValues, SubscriptionObject, asObservableFromGetter, asObservable } from '@dereekb/rxjs';
-import { DateCellScheduleDayCode, expandDateCellScheduleDayCodesToDayOfWeekSet, dateCellTimingStartsAtForStartOfDay, dateCellTimingRelativeIndexFactory, dateCellDayOfWeekFactory, findMaxDate, findMinDate, isSameDateRange, isSameDateDay, isSameDate, dateCellTimingDateFactory, expandDateCellScheduleRange, formatToISO8601DayString, changeDateCellScheduleDateRangeToTimezone, isSameDateCellScheduleDateRange, dateCellTimingRelativeIndexArrayFactory, isInfiniteDateRange, copyDateCellScheduleDateFilterConfig, dateTimezoneUtcNormal, dateCellScheduleDateFilter, fullDateCellScheduleRange, dateCellTimingTimezoneNormalInstance, expandDateCellScheduleDayCodes, fullWeekDateCellScheduleDayCodes, dateCellScheduleDayCodesAreSetsEquivalent, simplifyDateCellScheduleDayCodes, isDateInDateRangeFunction, isDateWithinDateCellRangeFunction, dateCellScheduleEncodedWeek, dateCellTimingStartDateFactory, enabledDaysFromDateCellScheduleDayCodes, dateCellScheduleDayCodesFromEnabledDays, formatToMonthDayString, dateRange, DateRangeType } from '@dereekb/date';
+import { DateCellScheduleDayCode, expandDateCellScheduleDayCodesToDayOfWeekSet, dateCellTimingStartsAtForStartOfDay, dateCellTimingRelativeIndexFactory, dateCellDayOfWeekFactory, dateTimezoneUtcNormal, findMaxDate, findMinDate, isSameDateRange, isSameDateDay, isSameDate, dateCellTimingDateFactory, expandDateCellScheduleRange, formatToISO8601DayString, changeDateCellScheduleDateRangeToTimezone, isSameDateCellScheduleDateRange, dateCellTimingRelativeIndexArrayFactory, isInfiniteDateRange, copyDateCellScheduleDateFilterConfig, SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE, dateCellScheduleDateFilter, fullDateCellScheduleRange, dateCellTimingTimezoneNormalInstance, expandDateCellScheduleDayCodes, fullWeekDateCellScheduleDayCodes, dateCellScheduleDayCodesAreSetsEquivalent, simplifyDateCellScheduleDayCodes, isDateInDateRangeFunction, isDateWithinDateCellRangeFunction, dateCellScheduleEncodedWeek, dateCellTimingStartDateFactory, enabledDaysFromDateCellScheduleDayCodes, dateCellScheduleDayCodesFromEnabledDays, formatToMonthDayString, dateRange, DateRangeType } from '@dereekb/date';
 import { isInAllowedDaysOfWeekSet, mapValuesToSet, unique, mergeArrays, iterableToArray, range, toggleInSet, removeFromSet, addToSet, isIndexNumberInIndexRangeFunction, minAndMaxNumber, getDaysOfWeekNames, reduceBooleansWithAnd, mergeObjects, KeyValueTypleValueFilter } from '@dereekb/util';
 import { ComponentStore } from '@ngrx/component-store';
 import { startOfDay, endOfDay, isBefore, endOfWeek } from 'date-fns';
@@ -112,6 +112,36 @@ function initialCalendarScheduleSelectionState() {
         cellContentFactory: defaultCalendarScheduleSelectionCellContentFactory
     };
 }
+/**
+ * This is used in cases where the dates in the min/max date range need to be shifted to the filter's timezone.
+ *
+ * This is because the index factory is always in system timezone, but when selecting all/none with a filter we need to use the filter's timezone.
+ *
+ * @param x
+ * @returns
+ */
+function calendarScheduleMinAndMaxDateRangeRelativeToFilter(x) {
+    var _a;
+    let input = x;
+    if (((_a = x.filter) === null || _a === void 0 ? void 0 : _a.timezone) && x.minMaxDateRange != null) {
+        const filterNormal = dateTimezoneUtcNormal(x.filter.timezone);
+        const transformFn = filterNormal.transformFunction('systemDateToTargetDate');
+        input = {
+            filter: x.filter,
+            minMaxDateRange: {
+                start: x.minMaxDateRange.start ? transformFn(x.minMaxDateRange.start) : undefined,
+                end: x.minMaxDateRange.end ? transformFn(x.minMaxDateRange.end) : undefined
+            }
+        };
+    }
+    return calendarScheduleMinAndMaxDateRange(input);
+}
+function calendarScheduleMinAndMaxDateRange(x) {
+    return {
+        start: calendarScheduleMinDate(x) || undefined,
+        end: calendarScheduleMaxDate(x) || undefined
+    };
+}
 function calendarScheduleMinDate(x) {
     var _a, _b;
     return findMaxDate([(_a = x.filter) === null || _a === void 0 ? void 0 : _a.start, (_b = x.minMaxDateRange) === null || _b === void 0 ? void 0 : _b.start]);
@@ -120,12 +150,6 @@ function calendarScheduleMaxDate(x) {
     var _a, _b;
     return findMinDate([(_a = x.filter) === null || _a === void 0 ? void 0 : _a.end, (_b = x.minMaxDateRange) === null || _b === void 0 ? void 0 : _b.end]);
 }
-function calendarScheduleMinAndMaxDateRange(x) {
-    return {
-        start: calendarScheduleMinDate(x) || undefined,
-        end: calendarScheduleMaxDate(x) || undefined
-    };
-}
 function calendarScheduleStartBeingUsedFromFilter(x) {
     var _a;
     return x.computeSelectionResultRelativeToFilter && ((_a = x.filter) === null || _a === void 0 ? void 0 : _a.start) != null; // may be using either
@@ -322,7 +346,6 @@ function updateStateWithMinMaxDateRange(state, minMaxDateRange) {
     return updateStateWithFilter(state, state.filter);
 }
 function updateStateWithFilter(state, inputFilter) {
-    var _a, _b;
     const { computedExclusions: exclusions, minMaxDateRange, systemTimezone } = state;
     let isEnabledFilterDay = () => true;
     let filter = null;
@@ -332,21 +355,34 @@ function updateStateWithFilter(state, inputFilter) {
         let filterStart = null; // the start date that will be used/set on the filter.
         if (inputFilter) {
             filter = copyDateCellScheduleDateFilterConfig(inputFilter); // copy filter
+            let nextFilterTimezone; // only set if inputFilter.start or inputFilter.startsAt
             // configure filter start
             if (inputFilter.start) {
                 filterStart = inputFilter.start;
+                // if no timezone is specified, then use the system timezone and align filterStart to the start of the day.
+                if (!inputFilter.timezone) {
+                    filterStart = SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE.startOfDayInTargetTimezone(inputFilter.startsAt);
+                    nextFilterTimezone = systemTimezone;
+                }
+                else {
+                    nextFilterTimezone = inputFilter.timezone;
+                }
             }
             else if (inputFilter.startsAt) {
                 if (inputFilter.timezone) {
+                    // if no timezone is provided, use startsAt as-is
                     const timezoneNormal = dateTimezoneUtcNormal(inputFilter.timezone);
                     filterStart = timezoneNormal.startOfDayInTargetTimezone(inputFilter.startsAt);
+                    nextFilterTimezone = inputFilter.timezone;
                 }
                 else {
-                    filterStart = inputFilter.startsAt;
-                    filter.timezone = systemTimezone;
+                    // set to the start of today in the system timezone.
+                    filterStart = SYSTEM_DATE_TIMEZONE_UTC_NORMAL_INSTANCE.startOfDayInTargetTimezone(inputFilter.startsAt);
+                    nextFilterTimezone = systemTimezone;
                 }
             }
             filter.start = filterStart !== null && filterStart !== void 0 ? filterStart : undefined;
+            filter.timezone = nextFilterTimezone;
             // configure exclusions
             if (exclusions === null || exclusions === void 0 ? void 0 : exclusions.length) {
                 enabledFilter = Object.assign(Object.assign({}, filter), { ex: unique(mergeArrays([filter.ex, exclusions])) });
@@ -369,17 +405,46 @@ function updateStateWithFilter(state, inputFilter) {
          * If the input filter has a start date, use that as the relative start to ensure indexes are compared the same,
          * otherwise use the state's start. This is important for the index calculations.
          */
-        enabledFilter.start = (_a = filter === null || filter === void 0 ? void 0 : filter.start) !== null && _a !== void 0 ? _a : state.start;
+        let finalEnabledStart;
+        let finalEnabledTimezone;
+        //  filter?.start ?? state.start;
+        if (!enabledFilter.start) {
+            // use the current state's start, but make sure it is in the proper timezone.
+            if (enabledFilter.timezone) {
+                const timezoneNormal = dateTimezoneUtcNormal(enabledFilter.timezone);
+                finalEnabledStart = timezoneNormal.startOfDayInTargetTimezone(state.start); // get the start of the day for the current start
+                finalEnabledTimezone = enabledFilter.timezone;
+            }
+            else {
+                finalEnabledStart = state.start;
+                finalEnabledTimezone = systemTimezone;
+            }
+        }
+        else if (!enabledFilter.timezone) {
+            finalEnabledTimezone = systemTimezone;
+            const timezoneNormal = dateTimezoneUtcNormal(finalEnabledTimezone);
+            finalEnabledStart = timezoneNormal.startOfDayInTargetTimezone(enabledFilter.start); // get the start of the day for the target timezone
+        }
+        else {
+            finalEnabledStart = enabledFilter.start;
+            finalEnabledTimezone = enabledFilter.timezone;
+        }
+        enabledFilter.start = finalEnabledStart;
+        enabledFilter.timezone = finalEnabledTimezone;
         // create the filter
         isEnabledFilterDay = dateCellScheduleDateFilter(enabledFilter);
     }
     state = Object.assign(Object.assign({}, state), { filter, isEnabledFilterDay });
     // For the same reason as above, use the filter's start date as the relative start if applicable.
     if (filter && filter.start) {
-        const start = filter.start;
-        state.start = start;
-        state.indexFactory = dateCellTimingRelativeIndexFactory({ startsAt: start, timezone: (_b = filter.timezone) !== null && _b !== void 0 ? _b : systemTimezone });
-        state.indexDayOfWeek = dateCellDayOfWeekFactory(start);
+        let startForSystemTimezone = filter.start;
+        if (filter.timezone) {
+            const timezoneNormal = dateTimezoneUtcNormal(filter.timezone);
+            startForSystemTimezone = timezoneNormal.systemDateToTargetDate(filter.start); // get the start of the day for the system timezone
+        }
+        state.start = startForSystemTimezone;
+        state.indexFactory = dateCellTimingRelativeIndexFactory({ startsAt: startForSystemTimezone, timezone: systemTimezone });
+        state.indexDayOfWeek = dateCellDayOfWeekFactory(startForSystemTimezone);
     }
     // attempt to re-apply the initial selection state once filter is applied
     if (state.initialSelectionState) {
@@ -497,7 +562,7 @@ function finalizeUpdateStateWithChangedScheduleDays(previousState, nextState) {
 function updateStateWithChangedDates(state, change) {
     var _a;
     const { allowedDaysOfWeek, indexFactory, indexDayOfWeek, inputStart: currentInputStart, inputEnd: currentInputEnd, minMaxDateRange, filter } = state;
-    const { start: minDate, end: maxDate } = calendarScheduleMinAndMaxDateRange(state);
+    const { start: minDate, end: maxDate } = calendarScheduleMinAndMaxDateRangeRelativeToFilter(state);
     let inputStart = currentInputStart;
     let inputEnd = currentInputEnd;
     /**
@@ -582,8 +647,8 @@ function noSelectionCalendarScheduleSelectionState(state) {
     return finalizeNewCalendarScheduleSelectionState(Object.assign(Object.assign({}, state), { toggledIndexes: new Set(), inputStart: null, inputEnd: null }));
 }
 function updateStateWithChangedRange(state, change) {
-    const { inputStart: currentInputStart, inputEnd: currentInputEnd, indexFactory, minMaxDateRange } = state;
-    const { start: minDate, end: maxDate } = minMaxDateRange !== null && minMaxDateRange !== void 0 ? minMaxDateRange : {};
+    const { inputStart: currentInputStart, inputEnd: currentInputEnd, indexFactory } = state;
+    const { start: minDate, end: maxDate } = calendarScheduleMinAndMaxDateRange(state);
     const inputStart = startOfDay(change.inputStart);
     const inputEnd = startOfDay(change.inputEnd); // midnight of the last day
     const isValidRange = minDate != null || maxDate != null ? isDateInDateRangeFunction({ start: minDate !== null && minDate !== void 0 ? minDate : undefined, end: maxDate !== null && maxDate !== void 0 ? maxDate : undefined }) : () => true;
@@ -625,7 +690,7 @@ function isEnabledDayInCalendarScheduleSelectionState(state) {
     };
 }
 function computeScheduleSelectionValue(state) {
-    const { indexFactory, allowedDaysOfWeek, effectiveScheduleDays, indexDayOfWeek, computeSelectionResultRelativeToFilter, filter, systemTimezone } = state;
+    const { indexFactory: systemIndexFactory, allowedDaysOfWeek, effectiveScheduleDays, indexDayOfWeek, computeSelectionResultRelativeToFilter, filter, systemTimezone } = state;
     let timezone = systemTimezone;
     const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(state);
     if (rangeAndExclusion == null) {
@@ -639,12 +704,16 @@ function computeScheduleSelectionValue(state) {
     // If computeSelectionResultRelativeToFilter is true, then we need to offset the values to be relative to that start.
     if (computeSelectionResultRelativeToFilter && (filter === null || filter === void 0 ? void 0 : filter.start)) {
         start = filter.start; // always start at the filter's start date
+        let startInSystemTimezone = start;
         if (filter.timezone) {
             timezone = filter.timezone;
             const filterNormal = dateTimezoneUtcNormal(timezone);
             end = filterNormal.startOfDayInTargetTimezone(end);
+            startInSystemTimezone = filterNormal.systemDateToTargetDate(start); // convert the start to the system timezone normal for deriving the index
         }
-        const filterStartIndexOffset = indexFactory(rangeStart) - indexFactory(start);
+        const rangeStartIndex = systemIndexFactory(rangeStart);
+        const startIndex = systemIndexFactory(startInSystemTimezone);
+        const filterStartIndexOffset = rangeStartIndex - startIndex;
         filterOffsetExcludedRange = range(0, filterStartIndexOffset);
         indexOffset = indexOffset - filterStartIndexOffset;
     }