@dereekb/dbx-form 9.24.4 → 9.24.5

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

@@ -1,14 +1,14 @@
 import * as i4$1 from '@dereekb/dbx-form';
 import { formlyField, propsAndConfigForFieldConfig, flexLayoutWrapper, toggleField, AbstractSyncFormlyFormDirective, provideFormlyContext, DbxFormModule, DbxFormlyModule } from '@dereekb/dbx-form';
 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 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 from '@dereekb/dbx-web/calendar';
@@ -100,7 +100,7 @@ function initialCalendarScheduleSelectionState() {
     return {
         start,
         indexFactory,
-        selectedIndexes: new Set(),
+        toggledIndexes: new Set(),
         scheduleDays,
         allowedDaysOfWeek,
         indexDayOfWeek,
@@ -154,7 +154,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));
@@ -168,6 +168,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 = {
@@ -180,6 +183,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) {
@@ -190,13 +195,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?.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);
@@ -205,10 +207,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);
@@ -223,8 +228,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 { ...state, initialSelectionState };
@@ -354,7 +359,7 @@ function updateStateWithDateScheduleRangeValue(state, change) {
     }
     else {
         if (change != null) {
-            const nextState = { ...state, inputStart: change.start, inputEnd: change.end, selectedIndexes: new Set(change.ex) };
+            const nextState = { ...state, inputStart: change.start, inputEnd: change.end, toggledIndexes: new Set(change.ex) };
             return updateStateWithChangedScheduleDays(finalizeNewCalendarScheduleSelectionState(nextState), expandDateScheduleDayCodes(change.w || '89'));
         }
         else {
@@ -375,12 +380,20 @@ function updateStateWithChangedScheduleDays(state, change) {
     }
 }
 function updateStateWithChangedDates(state, change) {
-    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 = change.set ?? [];
         const selectAll = change.reset === true ? state.initialSelectionState : change.selectAll;
         switch (selectAll) {
@@ -397,29 +410,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 = { ...state, inputStart, inputEnd, selectedIndexes };
+    const nextState = { ...state, inputStart, inputEnd, toggledIndexes };
     nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
     // Recalculate the range and simplified to exclusions
     const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(nextState);
     if (rangeAndExclusion) {
-        return finalizeNewCalendarScheduleSelectionState({ ...nextState, selectedIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end });
+        return finalizeNewCalendarScheduleSelectionState({ ...nextState, toggledIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end });
     }
     else {
         // no selected days
@@ -427,7 +463,7 @@ function updateStateWithChangedDates(state, change) {
     }
 }
 function noSelectionCalendarScheduleSelectionState(state) {
-    return finalizeNewCalendarScheduleSelectionState({ ...state, selectedIndexes: new Set(), inputStart: null, inputEnd: null });
+    return finalizeNewCalendarScheduleSelectionState({ ...state, toggledIndexes: new Set(), inputStart: null, inputEnd: null });
 }
 function updateStateWithChangedRange(state, change) {
     const { inputStart: currentInputStart, inputEnd: currentInputEnd, indexFactory, minMaxDateRange } = state;
@@ -441,11 +477,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 = { ...state, selectedIndexes, inputStart, inputEnd };
+    const toggledIndexes = new Set(excludedIndexesInNewRange);
+    const nextState = { ...state, toggledIndexes, inputStart, inputEnd };
     return finalizeNewCalendarScheduleSelectionState(nextState);
 }
 function finalizeNewCalendarScheduleSelectionState(nextState) {
@@ -466,7 +502,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;
@@ -548,8 +584,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) {
@@ -1134,7 +1170,7 @@ class DbxScheduleSelectionCalendarDateDialogComponent extends AbstractDialogDire
             width: '80vw',
             minHeight: 400,
             minWidth: 360,
-            ...contentConfig.dialogConfig,
+            ...sanitizeDbxDialogContentConfig(contentConfig.dialogConfig),
             injector,
             data: {
                 config,