@dereekb/dbx-form 9.24.4 → 9.24.5

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

@@ -4,13 +4,13 @@ import * as i0 from '@angular/core';
 import { Injectable, SkipSelf, Directive, Injector, Optional, Component, Inject, Input, ElementRef, ViewChild, ChangeDetectionStrategy, EventEmitter, Output, InjectionToken, NgModule } from '@angular/core';
 import { FieldType } from '@ngx-formly/material';
 import { switchMap, first, tap, map, distinctUntilChanged, shareReplay, combineLatestWith, BehaviorSubject, of, startWith, filter, throttleTime, combineLatest } from 'rxjs';
-import { filterMaybe, SubscriptionObject, asObservable } from '@dereekb/rxjs';
+import { filterMaybe, distinctUntilHasDifferentValues, SubscriptionObject, asObservable } from '@dereekb/rxjs';
 import { DateScheduleDayCode, expandDateScheduleDayCodesToDayOfWeekSet, dateTimingRelativeIndexFactory, dateBlockDayOfWeekFactory, findMaxDate, findMinDate, isSameDateRange, isSameDateDay, isSameDate, expandDateScheduleRange, isSameDateScheduleRange, dateTimingRelativeIndexArrayFactory, isInfiniteDateRange, copyDateScheduleDateFilterConfig, dateScheduleDateFilter, dateTimezoneUtcNormal, expandDateScheduleDayCodes, isDateInDateRangeFunction, isDateWithinDateBlockRangeFunction, copyHoursAndMinutesFromDate, dateScheduleEncodedWeek, dateBlockTimingDateFactory, enabledDaysFromDateScheduleDayCodes, dateScheduleDayCodesFromEnabledDays, formatToMonthDayString } from '@dereekb/date';
-import { setsAreEquivalent, unique, mergeArrays, iterableToArray, toggleInSet, addToSet, isIndexNumberInIndexRangeFunction, range, minAndMaxNumber, getDaysOfWeekNames, mergeObjects, KeyValueTypleValueFilter } from '@dereekb/util';
+import { setsAreEquivalent, unique, mergeArrays, iterableToArray, range, toggleInSet, removeFromSet, addToSet, isIndexNumberInIndexRangeFunction, minAndMaxNumber, getDaysOfWeekNames, mergeObjects, KeyValueTypleValueFilter } from '@dereekb/util';
 import { ComponentStore } from '@ngrx/component-store';
 import { startOfDay, endOfDay, isBefore } from 'date-fns';
 import * as i1$1 from '@dereekb/dbx-web';
-import { AbstractPopoverDirective, AbstractDialogDirective, DbxActionModule, DbxButtonModule, DbxDialogInteractionModule, DbxPopoverInteractionModule, DbxTextModule } from '@dereekb/dbx-web';
+import { AbstractPopoverDirective, AbstractDialogDirective, sanitizeDbxDialogContentConfig, DbxActionModule, DbxButtonModule, DbxDialogInteractionModule, DbxPopoverInteractionModule, DbxTextModule } from '@dereekb/dbx-web';
 import * as i3 from '@angular/forms';
 import { FormGroup, FormControl, FormsModule, ReactiveFormsModule } from '@angular/forms';
 import * as i5 from '@angular/material/form-field';
@@ -96,7 +96,7 @@ function initialCalendarScheduleSelectionState() {
     return {
         start,
         indexFactory,
-        selectedIndexes: new Set(),
+        toggledIndexes: new Set(),
         scheduleDays,
         allowedDaysOfWeek,
         indexDayOfWeek,
@@ -153,7 +153,7 @@ class DbxCalendarScheduleSelectionStore extends ComponentStore {
         /**
          * @deprecated This is not the same as the current selection value. This is the set of manually togged off dates. It will be removed in a future update.
          */
-        this.selectedDates$ = this.state$.pipe(map((x) => x.selectedIndexes), distinctUntilChanged(), shareReplay(1));
+        this.selectedDates$ = this.state$.pipe(map((x) => x.toggledIndexes), distinctUntilChanged(), shareReplay(1));
         this.isEnabledFilterDayFunction$ = this.state$.pipe(map((x) => x.isEnabledFilterDay), shareReplay(1));
         this.isEnabledDayFunction$ = this.state$.pipe(map((x) => x.isEnabledDay), shareReplay(1));
         this.currentDateRange$ = this.state$.pipe(map(computeCalendarScheduleSelectionRange), distinctUntilChanged((a, b) => isSameDateRange(a, b)), shareReplay(1));
@@ -167,6 +167,9 @@ class DbxCalendarScheduleSelectionStore extends ComponentStore {
         this.effectiveTimezone$ = this.state$.pipe(map((x) => (!calendarScheduleStartBeingUsedFromFilter(x) && x.timezone ? x.timezone : undefined)), distinctUntilChanged(), shareReplay(1));
         this.effectiveTimezoneNormal$ = this.state$.pipe(map((x) => (!calendarScheduleStartBeingUsedFromFilter(x) && x.timezoneNormal ? x.timezoneNormal : undefined)), distinctUntilChanged(), shareReplay(1));
         this.currentSelectionValue$ = this.state$.pipe(map((x) => x.currentSelectionValue), shareReplay(1));
+        this.currentSelectionValueDateBlockDurationSpan$ = this.currentSelectionValue$.pipe(map((x) => (x ? expandDateScheduleRange(x) : [])), shareReplay(1));
+        this.selectionValueSelectedIndexes$ = this.currentSelectionValueDateBlockDurationSpan$.pipe(map((x) => new Set(x.map((y) => y.i))), distinctUntilHasDifferentValues(), shareReplay(1));
+        this.selectionValue$ = this.currentSelectionValue$.pipe(filterMaybe(), shareReplay(1));
         this.currentSelectionValueWithTimezone$ = this.currentSelectionValue$.pipe(combineLatestWith(this.effectiveTimezoneNormal$), map(([x, timezoneNormal]) => {
             if (x && timezoneNormal) {
                 x = {
@@ -175,6 +178,8 @@ class DbxCalendarScheduleSelectionStore extends ComponentStore {
             }
             return x;
         }), distinctUntilChanged(), shareReplay(1));
+        this.selectionValueWithTimezone$ = this.currentSelectionValueWithTimezone$.pipe(filterMaybe(), shareReplay(1));
+        this.selectionValueWithTimezoneDateBlockDurationSpan$ = this.selectionValueWithTimezone$.pipe(map((x) => expandDateScheduleRange(x)), shareReplay(1));
         this.nextToggleSelection$ = this.hasConfiguredMinMaxRange$.pipe(switchMap((hasConfiguredMinMaxRange) => {
             let obs;
             if (hasConfiguredMinMaxRange) {
@@ -185,13 +190,10 @@ class DbxCalendarScheduleSelectionStore extends ComponentStore {
             }
             return obs;
         }), shareReplay(1));
-        this.selectionValue$ = this.currentSelectionValueWithTimezone$.pipe(filterMaybe(), shareReplay(1));
-        this.selectionValueDateBlockDurationSpan$ = this.selectionValue$.pipe(map((x) => expandDateScheduleRange(x)), shareReplay(1));
-        this.selectionValueSelectedIndexes$ = this.selectionValueDateBlockDurationSpan$.pipe(map((x) => new Set(x.map((y) => y.i))), shareReplay(1));
         this.currentDateScheduleRangeValue$ = this.currentSelectionValueWithTimezone$.pipe(map((x) => x === null || x === void 0 ? void 0 : x.dateScheduleRange), distinctUntilChanged(isSameDateScheduleRange), shareReplay(1));
         this.dateScheduleRangeValue$ = this.currentDateScheduleRangeValue$.pipe(filterMaybe(), shareReplay(1));
         this.cellContentFactory$ = this.state$.pipe(map((x) => x.cellContentFactory), distinctUntilChanged(), shareReplay(1));
-        this.isCustomized$ = this.state$.pipe(map((x) => x.selectedIndexes.size > 0), distinctUntilChanged(), shareReplay(1));
+        this.isCustomized$ = this.state$.pipe(map((x) => x.toggledIndexes.size > 0), distinctUntilChanged(), shareReplay(1));
         // MARK: State Changes
         this.setMinMaxDateRange = this.updater(updateStateWithMinMaxDateRange);
         this.setFilter = this.updater(updateStateWithFilter);
@@ -200,10 +202,13 @@ class DbxCalendarScheduleSelectionStore extends ComponentStore {
         this.clearFilter = this.updater((state) => updateStateWithFilter(state, undefined));
         this.setTimezone = this.updater(updateStateWithTimezoneValue);
         this.setInputRange = this.updater(updateStateWithChangedRange);
+        // NOTE: Selected dates are NOT selected indexes. They are the internal selected dates that are excluded from the selection.
         this.toggleSelectedDates = this.updater((state, toggle) => updateStateWithChangedDates(state, { toggle }));
         this.addSelectedDates = this.updater((state, add) => updateStateWithChangedDates(state, { add }));
         this.removeSelectedDates = this.updater((state, remove) => updateStateWithChangedDates(state, { remove }));
         this.setSelectedDates = this.updater((state, set) => updateStateWithChangedDates(state, { set }));
+        // NOTE: Selected indexes are the typical/expected indexes that are selected or not.
+        this.setSelectedIndexes = this.updater((state, set) => updateStateWithChangedDates(state, { set, invertSetBehavior: true }));
         this.selectAllDates = this.updater((state, selectAll = 'all') => updateStateWithChangedDates(state, { selectAll }));
         this.setInitialSelectionState = this.updater(updateStateWithInitialSelectionState);
         this.setScheduleDays = this.updater(updateStateWithChangedScheduleDays);
@@ -218,8 +223,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
             type: Injectable
         }], ctorParameters: function () { return []; } });
 function updateStateWithInitialSelectionState(state, initialSelectionState) {
-    const { selectedIndexes } = state;
-    if (selectedIndexes.size === 0 && initialSelectionState === 'all') {
+    const { toggledIndexes } = state;
+    if (toggledIndexes.size === 0 && initialSelectionState === 'all') {
         state = updateStateWithChangedDates(state, { selectAll: initialSelectionState });
     }
     return Object.assign(Object.assign({}, state), { initialSelectionState });
@@ -340,7 +345,7 @@ function updateStateWithDateScheduleRangeValue(state, change) {
     }
     else {
         if (change != null) {
-            const nextState = Object.assign(Object.assign({}, state), { inputStart: change.start, inputEnd: change.end, selectedIndexes: new Set(change.ex) });
+            const nextState = Object.assign(Object.assign({}, state), { inputStart: change.start, inputEnd: change.end, toggledIndexes: new Set(change.ex) });
             return updateStateWithChangedScheduleDays(finalizeNewCalendarScheduleSelectionState(nextState), expandDateScheduleDayCodes(change.w || '89'));
         }
         else {
@@ -362,12 +367,20 @@ function updateStateWithChangedScheduleDays(state, change) {
 }
 function updateStateWithChangedDates(state, change) {
     var _a;
-    const { indexFactory, allowedDaysOfWeek, indexDayOfWeek, inputStart: currentInputStart, inputEnd: currentInputEnd, minMaxDateRange } = state;
+    const { indexFactory, allowedDaysOfWeek, indexDayOfWeek, inputStart: currentInputStart, inputEnd: currentInputEnd, minMaxDateRange, filter } = state;
     const { start: minDate, end: maxDate } = calendarScheduleMinAndMaxDateRange(state);
     let inputStart = currentInputStart;
     let inputEnd = currentInputEnd;
-    let selectedIndexes;
-    if (change.reset || change.selectAll != null || change.set) {
+    /**
+     * This is a set of indexes that are internally "selected" so that they are excluded from the inputStart/inputEnd date range.
+     *
+     * Do not confuse this with the actual indexes that are selected.
+     */
+    let toggledIndexes;
+    function asIndexes(indexes) {
+        return iterableToArray(indexes).map(indexFactory);
+    }
+    if (change.reset || change.selectAll != null || change.set != null) {
         let set = (_a = change.set) !== null && _a !== void 0 ? _a : [];
         const selectAll = change.reset === true ? state.initialSelectionState : change.selectAll;
         switch (selectAll) {
@@ -384,29 +397,52 @@ function updateStateWithChangedDates(state, change) {
                 set = [];
                 break;
         }
-        selectedIndexes = new Set(iterableToArray(set).map(indexFactory));
+        toggledIndexes = new Set(asIndexes(set));
+        if (change.invertSetBehavior && minDate && maxDate && !selectAll) {
+            const minIndex = indexFactory(minDate);
+            const maxIndex = indexFactory(maxDate);
+            inputStart = minDate;
+            inputEnd = maxDate;
+            toggledIndexes = new Set(range(minIndex, maxIndex + 1).filter((x) => !toggledIndexes.has(x)));
+        }
     }
     else {
-        selectedIndexes = new Set(state.selectedIndexes);
+        toggledIndexes = new Set(state.toggledIndexes);
         if (change.toggle) {
-            const allowedToToggle = iterableToArray(change.toggle)
-                .map(indexFactory)
-                .filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
-            toggleInSet(selectedIndexes, allowedToToggle);
+            const allowedToToggle = asIndexes(change.toggle).filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
+            toggleInSet(toggledIndexes, allowedToToggle);
         }
+        let addToExclusion;
+        let removeFromExclusion;
         if (change.add) {
-            addToSet(selectedIndexes, iterableToArray(change.add).map(indexFactory));
+            if (change.invertSetBehavior) {
+                addToExclusion = change.add;
+            }
+            else {
+                removeFromExclusion = change.add;
+            }
         }
         if (change.remove) {
-            addToSet(selectedIndexes, iterableToArray(change.remove).map(indexFactory));
+            if (change.invertSetBehavior) {
+                removeFromExclusion = change.remove;
+            }
+            else {
+                addToExclusion = change.remove;
+            }
+        }
+        if (addToExclusion) {
+            removeFromSet(toggledIndexes, asIndexes(addToExclusion));
+        }
+        if (removeFromExclusion) {
+            addToSet(toggledIndexes, asIndexes(removeFromExclusion));
         }
     }
-    const nextState = Object.assign(Object.assign({}, state), { inputStart, inputEnd, selectedIndexes });
+    const nextState = Object.assign(Object.assign({}, state), { inputStart, inputEnd, toggledIndexes });
     nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
     // Recalculate the range and simplified to exclusions
     const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(nextState);
     if (rangeAndExclusion) {
-        return finalizeNewCalendarScheduleSelectionState(Object.assign(Object.assign({}, nextState), { selectedIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end }));
+        return finalizeNewCalendarScheduleSelectionState(Object.assign(Object.assign({}, nextState), { toggledIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end }));
     }
     else {
         // no selected days
@@ -414,7 +450,7 @@ function updateStateWithChangedDates(state, change) {
     }
 }
 function noSelectionCalendarScheduleSelectionState(state) {
-    return finalizeNewCalendarScheduleSelectionState(Object.assign(Object.assign({}, state), { selectedIndexes: new Set(), inputStart: null, inputEnd: null }));
+    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;
@@ -428,11 +464,11 @@ function updateStateWithChangedRange(state, change) {
     // retain all indexes that are within the new range
     const minIndex = indexFactory(inputStart);
     const maxIndex = indexFactory(inputEnd) + 1;
-    const currentIndexes = Array.from(state.selectedIndexes);
+    const currentIndexes = Array.from(state.toggledIndexes);
     const isInCurrentRange = isIndexNumberInIndexRangeFunction({ minIndex, maxIndex });
     const excludedIndexesInNewRange = currentIndexes.filter(isInCurrentRange);
-    const selectedIndexes = new Set(excludedIndexesInNewRange);
-    const nextState = Object.assign(Object.assign({}, state), { selectedIndexes, inputStart, inputEnd });
+    const toggledIndexes = new Set(excludedIndexesInNewRange);
+    const nextState = Object.assign(Object.assign({}, state), { toggledIndexes, inputStart, inputEnd });
     return finalizeNewCalendarScheduleSelectionState(nextState);
 }
 function finalizeNewCalendarScheduleSelectionState(nextState) {
@@ -453,7 +489,7 @@ function isEnabledDayInCalendarScheduleSelectionState(state) {
         const index = indexFactory(input);
         const dayOfWeek = indexDayOfWeek(index);
         const isInSelectedRange = isInStartAndEndRange(input);
-        const isSelected = state.selectedIndexes.has(index);
+        const isSelected = state.toggledIndexes.has(index);
         const isAllowedDayOfWeek = allowedDaysOfWeek.has(dayOfWeek);
         const result = isAllowedDayOfWeek && ((isInSelectedRange && !isSelected) || (isSelected && !isInSelectedRange));
         return result;
@@ -535,8 +571,8 @@ function computeCalendarScheduleSelectionRange(state) {
 }
 function computeCalendarScheduleSelectionDateBlockRange(state) {
     const { indexFactory, inputStart, inputEnd, allowedDaysOfWeek, indexDayOfWeek, isEnabledDay, isEnabledFilterDay } = state;
-    const enabledSelectedIndexes = Array.from(state.selectedIndexes).filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
-    const minAndMaxSelectedValues = minAndMaxNumber(enabledSelectedIndexes);
+    const enabledExclusionIndexes = Array.from(state.toggledIndexes).filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
+    const minAndMaxSelectedValues = minAndMaxNumber(enabledExclusionIndexes);
     let startRange;
     let endRange;
     if (minAndMaxSelectedValues) {
@@ -1123,7 +1159,7 @@ class DbxScheduleSelectionCalendarDateDialogComponent extends AbstractDialogDire
         const contentConfig = mergeObjects([defaultContentConfig, inputContentConfig], KeyValueTypleValueFilter.NULL);
         const closeConfig = mergeObjects([defaultCloseConfig, contentConfig === null || contentConfig === void 0 ? void 0 : contentConfig.closeConfig, inputCloseConfig], KeyValueTypleValueFilter.NULL);
         contentConfig.closeConfig = closeConfig;
-        return matDialog.open(DbxScheduleSelectionCalendarDateDialogComponent, Object.assign(Object.assign({ height: 'calc(var(--vh100) * 0.9)', width: '80vw', minHeight: 400, minWidth: 360 }, contentConfig.dialogConfig), { injector, data: {
+        return matDialog.open(DbxScheduleSelectionCalendarDateDialogComponent, Object.assign(Object.assign({ height: 'calc(var(--vh100) * 0.9)', width: '80vw', minHeight: 400, minWidth: 360 }, sanitizeDbxDialogContentConfig(contentConfig.dialogConfig)), { injector, data: {
                 config,
                 contentConfig
             } }));