@dereekb/dbx-form 13.11.14 → 13.11.15

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

@@ -31,12 +31,14 @@ import { FormlyModule } from '@ngx-formly/core';
 import { DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES } from '@ng-forge/dynamic-forms';
 import { setupMetaTracking, resolveValueFieldContext, buildValueFieldInputs } from '@ng-forge/dynamic-forms/integration';
 
+/* eslint-disable @typescript-eslint/no-deprecated -- legacy formly calendar factory; references deprecated config interfaces and is itself deprecated in favor of dbxForgeDateScheduleRangeField() */
 /**
  * Creates a Formly field configuration for a date schedule range picker with calendar-based selection.
  *
+ * @param config - Optional schedule range field configuration overrides.
+ * @returns A validated Formly field configuration for date schedule range selection.
+ *
  * @deprecated Use dbxForgeDateScheduleRangeField() from the forge API instead.
- * @param config - Optional schedule range field configuration overrides
- * @returns A validated Formly field configuration for date schedule range selection
  */
 function dateScheduleRangeField(config = {}) {
     const { key = 'schedule', appearance, hideCustomize, allowTextInput, filter, outputTimezone, initialSelectionState, computeSelectionResultRelativeToFilter, exclusions, defaultScheduleDays, minMaxDateRange, cellContentFactory, dialogContentConfig, customDetailsConfig } = config;
@@ -103,7 +105,7 @@ const defaultCalendarScheduleSelectionCellContentFactory = (day) => {
  * Creates the default initial state for the calendar schedule selection store,
  * using the current system timezone and all days of the week enabled.
  *
- * @returns A fresh CalendarScheduleSelectionState with default values
+ * @returns A fresh CalendarScheduleSelectionState with default values.
  */
 function initialCalendarScheduleSelectionState() {
     const defaultScheduleDays = new Set([DateCellScheduleDayCode.WEEKDAY, DateCellScheduleDayCode.WEEKEND]);
@@ -154,8 +156,8 @@ function calendarScheduleMinAndMaxDateRangeRelativeToFilter(x) {
 /**
  * Computes the effective min and max date range by combining the filter and the explicit minMaxDateRange constraints.
  *
- * @param x - State containing filter and minMaxDateRange to compute from
- * @returns A partial date range with the effective start and end boundaries
+ * @param x - State containing filter and minMaxDateRange to compute from.
+ * @returns A partial date range with the effective start and end boundaries.
  */
 function calendarScheduleMinAndMaxDateRange(x) {
     return {
@@ -166,8 +168,8 @@ function calendarScheduleMinAndMaxDateRange(x) {
 /**
  * Returns the effective minimum date by taking the latest start date between the filter and minMaxDateRange.
  *
- * @param x - State containing filter and minMaxDateRange
- * @returns The latest start date, or undefined if none
+ * @param x - State containing filter and minMaxDateRange.
+ * @returns The latest start date, or undefined if none.
  */
 function calendarScheduleMinDate(x) {
     return findMaxDate([x.filter?.start, x.minMaxDateRange?.start]);
@@ -175,8 +177,8 @@ function calendarScheduleMinDate(x) {
 /**
  * Returns the effective maximum date by taking the earliest end date between the filter and minMaxDateRange.
  *
- * @param x - State containing filter and minMaxDateRange
- * @returns The earliest end date, or undefined if none
+ * @param x - State containing filter and minMaxDateRange.
+ * @returns The earliest end date, or undefined if none.
  */
 function calendarScheduleMaxDate(x) {
     return findMinDate([x.filter?.end, x.minMaxDateRange?.end]);
@@ -184,8 +186,8 @@ function calendarScheduleMaxDate(x) {
 /**
  * Returns whether the filter's start date is being used as the effective start for the selection result computation.
  *
- * @param x - State containing filter and computeSelectionResultRelativeToFilter
- * @returns True if the filter start is being used for the selection result
+ * @param x - State containing filter and computeSelectionResultRelativeToFilter.
+ * @returns True if the filter start is being used for the selection result.
  */
 function calendarScheduleStartBeingUsedFromFilter(x) {
     return x.computeSelectionResultRelativeToFilter && x.filter?.start != null; // may be using either
@@ -330,9 +332,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
 /**
  * Updates the state with an initial selection (all or none) and applies it when no dates are currently toggled.
  *
- * @param state - The current selection state
+ * @param state - The current selection state.
  * @param initialSelectionState - The initial selection mode ('all' or 'none')
- * @returns The updated selection state
+ * @returns The updated selection state.
  */
 function updateStateWithInitialSelectionState(state, initialSelectionState) {
     const { toggledIndexes } = state;
@@ -344,9 +346,9 @@ function updateStateWithInitialSelectionState(state, initialSelectionState) {
 /**
  * Updates the computeSelectionResultRelativeToFilter flag and recalculates the state if the value changed.
  *
- * @param currentState - The current selection state
- * @param computeSelectionResultRelativeToFilter - Whether to compute results relative to the filter
- * @returns The updated selection state
+ * @param currentState - The current selection state.
+ * @param computeSelectionResultRelativeToFilter - Whether to compute results relative to the filter.
+ * @returns The updated selection state.
  */
 function updateStateWithComputeSelectionResultRelativeToFilter(currentState, computeSelectionResultRelativeToFilter) {
     let state = { ...currentState, computeSelectionResultRelativeToFilter };
@@ -358,9 +360,9 @@ function updateStateWithComputeSelectionResultRelativeToFilter(currentState, com
 /**
  * Updates the state with date exclusions, converting input dates/ranges to cell indexes and reapplying the filter.
  *
- * @param state - The current selection state
- * @param inputExclusions - Dates, date ranges, or cell indexes to exclude
- * @returns The updated selection state with exclusions applied
+ * @param state - The current selection state.
+ * @param inputExclusions - Dates, date ranges, or cell indexes to exclude.
+ * @returns The updated selection state with exclusions applied.
  */
 function updateStateWithExclusions(state, inputExclusions) {
     let computedExclusions;
@@ -375,9 +377,9 @@ function updateStateWithExclusions(state, inputExclusions) {
 /**
  * Sets the min/max date range constraint on the state, normalizing start to startOfDay and end to endOfDay.
  *
- * @param state - The current selection state
- * @param minMaxDateRange - The min/max boundary dates to enforce
- * @returns The updated selection state with the boundary applied
+ * @param state - The current selection state.
+ * @param minMaxDateRange - The min/max boundary dates to enforce.
+ * @returns The updated selection state with the boundary applied.
  */
 function updateStateWithMinMaxDateRange(state, minMaxDateRange) {
     if (minMaxDateRange != null && !isInfiniteDateRange(minMaxDateRange)) {
@@ -406,9 +408,9 @@ function updateStateWithMinMaxDateRange(state, minMaxDateRange) {
  * Applies a date cell schedule filter to the selection state, computing the enabled day function
  * from the filter, exclusions, and min/max date range constraints.
  *
- * @param currentState - The current selection state
- * @param inputFilter - The filter configuration to apply
- * @returns The updated selection state with the filter applied
+ * @param currentState - The current selection state.
+ * @param inputFilter - The filter configuration to apply.
+ * @returns The updated selection state with the filter applied.
  */
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function updateStateWithFilter(currentState, inputFilter) {
@@ -529,13 +531,14 @@ function updateStateWithFilter(currentState, inputFilter) {
 /**
  * Updates the output timezone and transforms the current selection value to reflect the new timezone.
  *
- * @param state - The current selection state
- * @param timezone - The target timezone string
- * @returns The updated selection state with timezone-adjusted values
+ * @param state - The current selection state.
+ * @param timezone - The target timezone string.
+ * @returns The updated selection state with timezone-adjusted values.
  */
 function updateStateWithTimezoneValue(state, timezone) {
     const { currentSelectionValue } = state;
     const timezoneNormal = timezone ? dateTimezoneUtcNormal({ timezone }) : undefined;
+    let result;
     if (timezoneNormal && currentSelectionValue) {
         // update the selection value to reflect the timezone changes.
         const { dateScheduleRange: currentDateCellScheduleRange } = currentSelectionValue;
@@ -546,17 +549,20 @@ function updateStateWithTimezoneValue(state, timezone) {
             start,
             end
         };
-        return updateStateWithDateCellScheduleRangeValue({ ...state, outputTimezone: timezone, outputTimezoneNormal: timezoneNormal }, newRange);
+        result = updateStateWithDateCellScheduleRangeValue({ ...state, outputTimezone: timezone, outputTimezoneNormal: timezoneNormal }, newRange);
     }
-    return { ...state, outputTimezone: timezone, outputTimezoneNormal: timezoneNormal }; // no change in value
+    else {
+        result = { ...state, outputTimezone: timezone, outputTimezoneNormal: timezoneNormal }; // no change in value
+    }
+    return result;
 }
 /**
  * Updates the state from an external date cell schedule range value, converting timezone-aware inputs
  * to system time and synchronizing the internal selection indexes.
  *
- * @param state - The current selection state
- * @param inputChange - The date cell schedule range to apply
- * @returns The updated selection state
+ * @param state - The current selection state.
+ * @param inputChange - The date cell schedule range to apply.
+ * @returns The updated selection state.
  */
 function updateStateWithDateCellScheduleRangeValue(state, inputChange) {
     const { currentSelectionValue, systemTimezone } = state;
@@ -585,10 +591,14 @@ function updateStateWithDateCellScheduleRangeValue(state, inputChange) {
         };
     }
     const isSameValue = isSameDateCellScheduleDateRange(currentDateCellScheduleRange, change);
+    let result;
     if (isSameValue) {
-        return state;
+        result = state;
     }
-    if (change != null) {
+    else if (change == null) {
+        result = noSelectionCalendarScheduleSelectionState(state); // clear selection, retain disabled days
+    }
+    else {
         // After the legacy-restored output anchor, change.ex is already state-anchored
         // (change.start equals state.start for filter-relative outputs), so no offset
         // is applied. inputStart is clamped to state.minMaxDateRange.start when set so
@@ -597,31 +607,30 @@ function updateStateWithDateCellScheduleRangeValue(state, inputChange) {
         const minMaxStart = state.minMaxDateRange?.start;
         const clampedInputStart = minMaxStart && minMaxStart.getTime() > change.start.getTime() ? minMaxStart : change.start;
         const nextState = { ...state, inputStart: clampedInputStart, inputEnd: change.end, toggledIndexes: new Set(change.ex ?? []) };
-        return updateStateWithChangedScheduleDays(finalizeNewCalendarScheduleSelectionState(nextState), expandDateCellScheduleDayCodes(change.w || '89'));
+        result = updateStateWithChangedScheduleDays(finalizeNewCalendarScheduleSelectionState(nextState), expandDateCellScheduleDayCodes(change.w || '89'));
     }
-    return noSelectionCalendarScheduleSelectionState(state); // clear selection, retain disabled days
+    return result;
 }
 /**
  * Updates the default schedule day codes (used when no explicit schedule days are set) and recalculates allowed days.
  *
- * @param state - The current selection state
- * @param change - The new default schedule day codes
- * @returns The updated selection state
+ * @param state - The current selection state.
+ * @param change - The new default schedule day codes.
+ * @returns The updated selection state.
  */
 function updateStateWithChangedDefaultScheduleDays(state, change) {
     const { defaultScheduleDays: currentDefaultScheduleDays } = state;
     const defaultScheduleDays = new Set(change ?? fullWeekDateCellScheduleDayCodes());
-    if (dateCellScheduleDayCodesAreSetsEquivalent(defaultScheduleDays, currentDefaultScheduleDays)) {
-        return state; // no change
-    }
-    return finalizeUpdateStateWithChangedScheduleDays(state, { ...state, defaultScheduleDays });
+    return dateCellScheduleDayCodesAreSetsEquivalent(defaultScheduleDays, currentDefaultScheduleDays)
+        ? state // no change
+        : finalizeUpdateStateWithChangedScheduleDays(state, { ...state, defaultScheduleDays });
 }
 /**
  * Updates the explicit schedule day codes override and recalculates allowed days of the week.
  *
- * @param state - The current selection state
- * @param change - The new schedule day codes, or null/undefined to clear the override
- * @returns The updated selection state
+ * @param state - The current selection state.
+ * @param change - The new schedule day codes, or null/undefined to clear the override.
+ * @returns The updated selection state.
  */
 function updateStateWithChangedScheduleDays(state, change) {
     const { scheduleDays: currentScheduleDays } = state;
@@ -638,51 +647,58 @@ function updateStateWithChangedScheduleDays(state, change) {
     else if (currentScheduleDays !== change) {
         newScheduleDays = change ? scheduleDays : null; // set the new one, or clear it
     }
-    if (newScheduleDays === undefined) {
-        return state;
-    }
-    return finalizeUpdateStateWithChangedScheduleDays(state, { ...state, scheduleDays: newScheduleDays ?? undefined });
+    return newScheduleDays === undefined ? state : finalizeUpdateStateWithChangedScheduleDays(state, { ...state, scheduleDays: newScheduleDays ?? undefined });
 }
 /**
  * Switches between single and multiple selection mode, trimming the selection to a single value when switching to single mode.
  *
- * @param state - The current selection state
- * @param selectionMode - The new selection mode
- * @returns The updated selection state
+ * @param state - The current selection state.
+ * @param selectionMode - The new selection mode.
+ * @returns The updated selection state.
  */
 function updateStateWithSelectionMode(state, selectionMode) {
     const { selectionMode: currentSelectionMode } = state;
-    if (currentSelectionMode !== selectionMode) {
+    let result;
+    if (currentSelectionMode === selectionMode) {
+        result = state;
+    }
+    else {
         const nextState = { ...state, selectionMode };
         if (selectionMode === 'multiple') {
-            return nextState;
+            result = nextState;
+        }
+        else {
+            const currentSelectionRange = computeCalendarScheduleSelectionDateCellRange(nextState);
+            result = currentSelectionRange ? updateStateWithChangedDates(nextState, { set: [currentSelectionRange.i], invertSetBehavior: true }) : nextState;
         }
-        const currentSelectionRange = computeCalendarScheduleSelectionDateCellRange(nextState);
-        return currentSelectionRange ? updateStateWithChangedDates(nextState, { set: [currentSelectionRange.i], invertSetBehavior: true }) : nextState;
     }
-    return state;
+    return result;
 }
 /**
  * Finalizes a schedule days change by recalculating allowed days of the week and updating toggled indexes accordingly.
  *
- * @param previousState - The state before the schedule days change
- * @param nextState - The state with updated schedule day codes
- * @returns The finalized selection state with recalculated allowed days and toggled indexes
+ * @param previousState - The state before the schedule days change.
+ * @param nextState - The state with updated schedule day codes.
+ * @returns The finalized selection state with recalculated allowed days and toggled indexes.
  */
 function finalizeUpdateStateWithChangedScheduleDays(previousState, nextState) {
     const previousScheduleDays = previousState.effectiveScheduleDays;
     const nextScheduleDays = nextState.scheduleDays ?? nextState.defaultScheduleDays;
+    let result;
     if (dateCellScheduleDayCodesAreSetsEquivalent(nextScheduleDays, previousScheduleDays)) {
-        return nextState; // the default or input schedule changed but the schedule is still the same, so no need for an update.
-    }
-    const effectiveScheduleDays = new Set(simplifyDateCellScheduleDayCodes(nextScheduleDays));
-    const allowedDaysOfWeek = expandDateCellScheduleDayCodesToDayOfWeekSet(nextScheduleDays);
-    return finalizeNewCalendarScheduleSelectionState({
-        ...nextState,
-        // update the effective schedule days and allowed days of week
-        effectiveScheduleDays,
-        allowedDaysOfWeek
-    });
+        result = nextState; // the default or input schedule changed but the schedule is still the same, so no need for an update.
+    }
+    else {
+        const effectiveScheduleDays = new Set(simplifyDateCellScheduleDayCodes(nextScheduleDays));
+        const allowedDaysOfWeek = expandDateCellScheduleDayCodesToDayOfWeekSet(nextScheduleDays);
+        result = finalizeNewCalendarScheduleSelectionState({
+            ...nextState,
+            // update the effective schedule days and allowed days of week
+            effectiveScheduleDays,
+            allowedDaysOfWeek
+        });
+    }
+    return result;
 }
 /**
  * Applies date changes (toggle, add, remove, set, selectAll, or reset) to the calendar selection state,
@@ -696,9 +712,9 @@ function finalizeUpdateStateWithChangedScheduleDays(previousState, nextState) {
  * Applies date changes (toggle, add, remove, set, selectAll, or reset) to the calendar selection state,
  * updating toggled indexes and input start/end accordingly.
  *
- * @param state - The current selection state
- * @param change - The date changes to apply
- * @returns The updated selection state
+ * @param state - The current selection state.
+ * @param change - The date changes to apply.
+ * @returns The updated selection state.
  */
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function updateStateWithChangedDates(state, change) {
@@ -830,17 +846,16 @@ function updateStateWithChangedDates(state, change) {
     nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
     // Recalculate the range and simplified to exclusions
     const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(nextState);
-    if (rangeAndExclusion) {
-        return finalizeNewCalendarScheduleSelectionState({ ...nextState, toggledIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end });
-    }
-    // no selected days
-    return noSelectionCalendarScheduleSelectionState(nextState);
+    return rangeAndExclusion
+        ? finalizeNewCalendarScheduleSelectionState({ ...nextState, toggledIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end })
+        : // no selected days
+            noSelectionCalendarScheduleSelectionState(nextState);
 }
 /**
  * Clears all date selections from the state, retaining other configuration like schedule days and filter.
  *
- * @param state - The current selection state
- * @returns The state with all selections cleared
+ * @param state - The current selection state.
+ * @returns The state with all selections cleared.
  */
 function noSelectionCalendarScheduleSelectionState(state) {
     return finalizeNewCalendarScheduleSelectionState({ ...state, toggledIndexes: new Set(), inputStart: null, inputEnd: null });
@@ -848,9 +863,9 @@ function noSelectionCalendarScheduleSelectionState(state) {
 /**
  * Updates the selection state with a new start/end date range, retaining toggled indexes within the new range bounds.
  *
- * @param state - The current selection state
- * @param change - The new input start and end dates
- * @returns The updated selection state
+ * @param state - The current selection state.
+ * @param change - The new input start and end dates.
+ * @returns The updated selection state.
  */
 function updateStateWithChangedRange(state, change) {
     const { inputStart: currentInputStart, inputEnd: currentInputEnd, indexFactory } = state;
@@ -858,24 +873,28 @@ function updateStateWithChangedRange(state, change) {
     const inputStart = startOfDay(change.inputStart);
     const inputEnd = startOfDay(change.inputEnd); // midnight of the last day
     const isValidRange = minDate != null || maxDate != null ? isDateInDateRangeFunction({ start: minDate ?? undefined, end: maxDate ?? undefined }) : () => true;
+    let result;
     if (!isValidRange(inputStart) || !isValidRange(inputEnd) || (isSameDateDay(inputStart, currentInputStart) && isSameDateDay(inputEnd, currentInputEnd))) {
-        return state; // if no change, return the current state.
-    }
-    // retain all indexes that are within the new range
-    const minIndex = indexFactory(inputStart);
-    const maxIndex = indexFactory(inputEnd) + 1;
-    const currentIndexes = [...state.toggledIndexes];
-    const isInCurrentRange = isIndexNumberInIndexRangeFunction({ minIndex, maxIndex });
-    const excludedIndexesInNewRange = currentIndexes.filter(isInCurrentRange);
-    const toggledIndexes = new Set(excludedIndexesInNewRange);
-    const nextState = { ...state, toggledIndexes, inputStart, inputEnd };
-    return finalizeNewCalendarScheduleSelectionState(nextState);
+        result = state; // if no change, return the current state.
+    }
+    else {
+        // retain all indexes that are within the new range
+        const minIndex = indexFactory(inputStart);
+        const maxIndex = indexFactory(inputEnd) + 1;
+        const currentIndexes = [...state.toggledIndexes];
+        const isInCurrentRange = isIndexNumberInIndexRangeFunction({ minIndex, maxIndex });
+        const excludedIndexesInNewRange = currentIndexes.filter(isInCurrentRange);
+        const toggledIndexes = new Set(excludedIndexesInNewRange);
+        const nextState = { ...state, toggledIndexes, inputStart, inputEnd };
+        result = finalizeNewCalendarScheduleSelectionState(nextState);
+    }
+    return result;
 }
 /**
  * Finalizes a partially-built state by recomputing the isEnabledDay function and the current selection value.
  *
- * @param nextState - The partially-built selection state to finalize
- * @returns The finalized selection state
+ * @param nextState - The partially-built selection state to finalize.
+ * @returns The finalized selection state.
  */
 function finalizeNewCalendarScheduleSelectionState(nextState) {
     nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
@@ -885,8 +904,8 @@ function finalizeNewCalendarScheduleSelectionState(nextState) {
 /**
  * Builds a decision function that determines whether a given day index is enabled (selected) in the current state.
  *
- * @param state - The selection state to derive the enabled-day function from
- * @returns A function that returns true if the given day is enabled/selected
+ * @param state - The selection state to derive the enabled-day function from.
+ * @returns Returns true if the given day is enabled/selected.
  */
 function isEnabledDayInCalendarScheduleSelectionState(state) {
     const { allowedDaysOfWeek, indexFactory, inputStart, inputEnd, indexDayOfWeek, systemTimezone } = state;
@@ -910,96 +929,103 @@ function isEnabledDayInCalendarScheduleSelectionState(state) {
  * Computes the output DateCellScheduleDateRange value from the current selection state,
  * applying timezone offsets and filter-relative computations as needed.
  *
- * @param state - The current selection state to compute from
- * @returns The computed selection value, or null if nothing is selected
+ * @param state - The current selection state to compute from.
+ * @returns The computed selection value, or null if nothing is selected.
  */
 function computeScheduleSelectionValue(state) {
     const { indexFactory: systemIndexFactory, allowedDaysOfWeek, effectiveScheduleDays, indexDayOfWeek, computeSelectionResultRelativeToFilter, filter, systemTimezone } = state;
     let timezone = systemTimezone;
     const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(state);
+    let result;
     if (rangeAndExclusion == null) {
-        return null;
-    }
-    const { start: rangeStart, end: rangeEnd, excluded: allExcluded, dateCellRange } = rangeAndExclusion;
-    let filterOffsetExcludedRange = [];
-    let indexOffset = dateCellRange.i;
-    let start = rangeStart;
-    let end = rangeEnd;
-    // If computeSelectionResultRelativeToFilter is true, then we need to offset the values to be relative to that start.
-    if (computeSelectionResultRelativeToFilter && filter?.start) {
-        start = filter.start; // 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
+        result = null;
+    }
+    else {
+        const { start: rangeStart, end: rangeEnd, excluded: allExcluded, dateCellRange } = rangeAndExclusion;
+        let filterOffsetExcludedRange = [];
+        let indexOffset = dateCellRange.i;
+        let start = rangeStart;
+        let end = rangeEnd;
+        // If computeSelectionResultRelativeToFilter is true, then we need to offset the values to be relative to that start.
+        if (computeSelectionResultRelativeToFilter && filter?.start) {
+            start = filter.start; // 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 rangeStartIndex = systemIndexFactory(rangeStart);
+            const startIndex = systemIndexFactory(startInSystemTimezone);
+            const filterStartIndexOffset = rangeStartIndex - startIndex;
+            filterOffsetExcludedRange = range(0, filterStartIndexOffset);
+            indexOffset = indexOffset - filterStartIndexOffset;
         }
-        const rangeStartIndex = systemIndexFactory(rangeStart);
-        const startIndex = systemIndexFactory(startInSystemTimezone);
-        const filterStartIndexOffset = rangeStartIndex - startIndex;
-        filterOffsetExcludedRange = range(0, filterStartIndexOffset);
-        indexOffset = indexOffset - filterStartIndexOffset;
-    }
-    const excluded = computeSelectionResultRelativeToFilter
-        ? allExcluded.filter((x) => {
-            // ???
-            return allowedDaysOfWeek.has(indexDayOfWeek(x));
-        })
-        : allExcluded;
-    const offsetExcluded = excluded.map((x) => x - indexOffset); // set to the proper offset
-    const ex = [...filterOffsetExcludedRange, ...offsetExcluded];
-    const w = dateCellScheduleEncodedWeek(effectiveScheduleDays);
-    const d = []; // "included" blocks are never used/calculated.
-    // Always ensure the end is after or equal to the start.
-    if (isBefore(end, start)) {
-        end = start; // end is start
-    }
-    const dateScheduleRange = {
-        timezone,
-        start,
-        end,
-        w,
-        d,
-        ex
-    };
-    return {
-        dateScheduleRange,
-        minMaxRange: { start, end }
-    };
+        const excluded = computeSelectionResultRelativeToFilter
+            ? allExcluded.filter((x) => {
+                // ???
+                return allowedDaysOfWeek.has(indexDayOfWeek(x));
+            })
+            : allExcluded;
+        const offsetExcluded = excluded.map((x) => x - indexOffset); // set to the proper offset
+        const ex = [...filterOffsetExcludedRange, ...offsetExcluded];
+        const w = dateCellScheduleEncodedWeek(effectiveScheduleDays);
+        const d = []; // "included" blocks are never used/calculated.
+        // Always ensure the end is after or equal to the start.
+        if (isBefore(end, start)) {
+            end = start; // end is start
+        }
+        const dateScheduleRange = {
+            timezone,
+            start,
+            end,
+            w,
+            d,
+            ex
+        };
+        result = {
+            dateScheduleRange,
+            minMaxRange: { start, end }
+        };
+    }
+    return result;
 }
 /**
  * Computes the selected date range with its corresponding cell range and all excluded day indexes.
  * Returns null if no days are selected.
  *
- * @param state - The current selection state
- * @returns The range and exclusion data, or null if nothing is selected
+ * @param state - The current selection state.
+ * @returns The range and exclusion data, or null if nothing is selected.
  */
 function computeScheduleSelectionRangeAndExclusion(state) {
     const { start: currentStart, isEnabledDay, isEnabledFilterDay, systemTimezone } = state;
     const dateFactory = dateCellTimingStartDateFactory({ startsAt: currentStart, timezone: systemTimezone });
     const dateCellRange = computeCalendarScheduleSelectionDateCellRange(state);
+    let result;
     if (dateCellRange == null) {
-        return null; // returns null if no items are selected.
+        result = null; // returns null if no items are selected.
+    }
+    else {
+        const start = dateFactory(dateCellRange.i);
+        const end = dateFactory(dateCellRange.to);
+        const excluded = range(dateCellRange.i, dateCellRange.to + 1).filter((x) => {
+            return !isEnabledDay(x) || !isEnabledFilterDay(x);
+        });
+        result = {
+            dateCellRange,
+            start,
+            end,
+            excluded
+        };
     }
-    const start = dateFactory(dateCellRange.i);
-    const end = dateFactory(dateCellRange.to);
-    const excluded = range(dateCellRange.i, dateCellRange.to + 1).filter((x) => {
-        return !isEnabledDay(x) || !isEnabledFilterDay(x);
-    });
-    const result = {
-        dateCellRange,
-        start,
-        end,
-        excluded
-    };
     return result;
 }
 /**
  * Computes the selected date range (start and end dates) from the current selection state.
  *
- * @param state - The current selection state
- * @returns The selected date range, or undefined if nothing is selected
+ * @param state - The current selection state.
+ * @returns The selected date range, or undefined if nothing is selected.
  */
 function computeCalendarScheduleSelectionRange(state) {
     const dateFactory = dateCellTimingDateFactory({ startsAt: state.start, timezone: state.systemTimezone });
@@ -1010,8 +1036,8 @@ function computeCalendarScheduleSelectionRange(state) {
 /**
  * Computes the date cell index range (i, to) that spans all selected and toggled days in the current state.
  *
- * @param state - The current selection state
- * @returns The cell range spanning all selected days, or undefined if nothing is selected
+ * @param state - The current selection state.
+ * @returns The cell range spanning all selected days, or undefined if nothing is selected.
  */
 function computeCalendarScheduleSelectionDateCellRange(state) {
     const { allowedDaysOfWeek, indexFactory, inputStart, inputEnd, indexDayOfWeek, isEnabledDay, isEnabledFilterDay } = state;
@@ -1108,7 +1134,7 @@ function provideCalendarScheduleSelectionStoreIfParentIsUnavailable() {
  *
  * This is the forge equivalent of {@link dbxScheduleSelectionCalendarDateDaysFormFields}.
  *
- * @returns A FormConfig with toggle fields for each day of the week
+ * @returns A FormConfig with toggle fields for each day of the week.
  */
 function dbxScheduleSelectionCalendarDateDaysForgeFormFields() {
     return { fields: dbxScheduleSelectionCalendarDateDaysForgeFormDayFields() };
@@ -1116,7 +1142,7 @@ function dbxScheduleSelectionCalendarDateDaysForgeFormFields() {
 /**
  * Creates an array of forge toggle field definitions, one for each day of the week, keyed by lowercase day name.
  *
- * @returns An array of forge toggle field definitions for each day of the week
+ * @returns The forge toggle field definitions for each day of the week.
  */
 function dbxScheduleSelectionCalendarDateDaysForgeFormDayFields() {
     return getDaysOfWeekNames(false).map((dayOfWeekName) => {
@@ -1257,18 +1283,18 @@ class DbxScheduleSelectionCalendarDateRangeComponent {
     timezoneSignal = toSignal(this.timezone$);
     timezoneReleventDateSignal = toSignal(this.timezoneReleventDate$, { initialValue: new Date() });
     isCustomizedSignal = toSignal(this.isCustomized$, { initialValue: false });
-    showCustomLabelSignal = computed(() => this.showCustomize() && this.isCustomizedSignal(), ...(ngDevMode ? [{ debugName: "showCustomLabelSignal" }] : /* istanbul ignore next */ []));
+    showCustomLabelSignal = computed(() => {
+        const isCustomized = this.isCustomizedSignal();
+        return this.showCustomize() && isCustomized;
+    }, ...(ngDevMode ? [{ debugName: "showCustomLabelSignal" }] : /* istanbul ignore next */ []));
     currentErrorMessageSignal = toSignal(this.currentErrorMessage$);
-    datePickerFilterSignal = toSignal(this.datePickerFilter$, { initialValue: (() => true) });
+    datePickerFilterSignal = toSignal(this.datePickerFilter$, { initialValue: () => true });
     _requiredUpdateValidatorsEffect = effect(() => {
         const validators = this.required()
             ? [
                 (control) => {
                     const range = control.value;
-                    if (!range?.start || !range.end) {
-                        return { required: true };
-                    }
-                    return null;
+                    return !range?.start || !range.end ? { required: true } : null;
                 }
             ]
             : [];
@@ -1392,12 +1418,16 @@ class DbxScheduleSelectionCalendarDatePopoverButtonComponent {
     buttonPopoverOrigin = viewChild.required('buttonPopoverOrigin', { read: ElementRef });
     disabled$ = this.dbxCalendarScheduleSelectionStore.isViewReadonly$;
     buttonText$ = this.dbxCalendarScheduleSelectionStore.currentDateRange$.pipe(map((x) => {
+        let result;
         if (x?.start && x.end) {
             const startString = formatToMonthDayString(x.start);
             const endString = formatToMonthDayString(x.end);
-            return startString === endString ? startString : `${formatToMonthDayString(x.start)} - ${formatToMonthDayString(x.end)}`;
+            result = startString === endString ? startString : `${formatToMonthDayString(x.start)} - ${formatToMonthDayString(x.end)}`;
+        }
+        else {
+            result = 'Pick a Date Range';
         }
-        return 'Pick a Date Range';
+        return result;
     }), shareReplay(1));
     disabledSignal = toSignal(this.disabled$, { initialValue: false });
     buttonTextSignal = toSignal(this.buttonText$, { initialValue: 'Pick a Date Range' });
@@ -1526,8 +1556,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
  * Creates a factory that produces a beforeMonthViewRender handler for the schedule selection calendar.
  * The handler applies CSS classes and metadata to each day cell based on the current selection state.
  *
- * @param inputModifyFn - Optional function to further customize each day cell after default processing
- * @returns A factory function that accepts a state observable and produces a render handler
+ * @param inputModifyFn - Optional function to further customize each day cell after default processing.
+ * @returns A factory function that accepts a state observable and produces a render handler.
  */
 function dbxScheduleSelectionCalendarBeforeMonthViewRenderFactory(inputModifyFn) {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
@@ -1583,10 +1613,8 @@ class DbxScheduleSelectionCalendarComponent {
     }), shareReplay(1));
     showButtonsOnReadonly$ = this.config$.pipe(map((x) => x?.showButtonsOnReadonly ?? false), distinctUntilChanged(), shareReplay(1));
     showButtons$ = this.showButtonsOnReadonly$.pipe(switchMap((x) => {
-        if (x) {
-            return of(true);
-        }
-        return this.readonly$.pipe(map((x) => !x));
+        const result = x ? of(true) : this.readonly$.pipe(map((readonly) => !readonly));
+        return result;
     }), distinctUntilChanged(), shareReplay(1));
     showClearSelectionButton$ = this.config$.pipe(map((config) => config?.showClearSelectionButton ?? true), combineLatestWith(this.showButtons$), map((x) => reduceBooleansWithAnd(x)), distinctUntilChanged(), shareReplay(1));
     datePopoverButtonInjectionConfig$ = this.config$.pipe(map((x) => x?.buttonInjectionConfig), switchMapDbxInjectionComponentConfig(DbxScheduleSelectionCalendarDatePopoverButtonComponent), combineLatestWith(this.showButtons$), map(([config, showButton]) => (showButton ? config : undefined)), shareReplay(1));
@@ -1879,6 +1907,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                 }]
         }] });
 
+/* eslint-disable @typescript-eslint/no-deprecated -- legacy NgModule that wraps the deprecated DbxFormCalendarDateScheduleRangeFieldComponent; replacement is provideDbxForgeCalendarFieldDeclarations() */
 const importsAndExports$1 = [DbxFormCalendarDateScheduleRangeFieldComponent];
 /**
  * @deprecated Use provideDbxForgeCalendarFieldDeclarations() instead.
@@ -1912,8 +1941,8 @@ const FORGE_CALENDAR_DATE_SCHEDULE_RANGE_FIELD_TYPE = 'dbx-forge-calendar-date-s
  *
  * This is the forge equivalent of {@link dateScheduleRangeField}.
  *
- * @param config - Optional schedule range field configuration overrides
- * @returns A validated forge field definition for date schedule range selection
+ * @param config - Optional schedule range field configuration overrides.
+ * @returns A validated forge field definition for date schedule range selection.
  */
 function dbxForgeDateScheduleRangeField(config = {}) {
     const { key = 'schedule', label, description, required, readonly: isReadonly, appearance, allowTextInput, hideCustomize, allowCustomizeWithoutDateRange, outputTimezone, defaultScheduleDays, minMaxDateRange, filter, exclusions, dialogContentConfig, computeSelectionResultRelativeToFilter, initialSelectionState, cellContentFactory, customDetailsConfig } = config;
@@ -1978,14 +2007,14 @@ class DbxForgeCalendarDateScheduleRangeFieldComponent {
     _filterSub = cleanSubscription();
     _exclusionsSub = cleanSubscription();
     // Field value signal (double-call pattern: field()() to get FieldState)
-    fieldValue = computed(() => {
+    fieldValueSignal = computed(() => {
         const state = this.field()?.();
         return state?.value?.();
-    }, ...(ngDevMode ? [{ debugName: "fieldValue" }] : /* istanbul ignore next */ []));
-    isDisabled = computed(() => {
+    }, ...(ngDevMode ? [{ debugName: "fieldValueSignal" }] : /* istanbul ignore next */ []));
+    isDisabledSignal = computed(() => {
         const state = this.field()?.();
         return state?.disabled?.() ?? false;
-    }, ...(ngDevMode ? [{ debugName: "isDisabled" }] : /* istanbul ignore next */ []));
+    }, ...(ngDevMode ? [{ debugName: "isDisabledSignal" }] : /* istanbul ignore next */ []));
     isRequiredSignal = computed(() => {
         const state = this.field()?.();
         return state?.required?.() ?? false;
@@ -1993,17 +2022,18 @@ class DbxForgeCalendarDateScheduleRangeFieldComponent {
     // Computed props
     labelTextSignal = computed(() => this.props()?.label, ...(ngDevMode ? [{ debugName: "labelTextSignal" }] : /* istanbul ignore next */ []));
     descriptionSignal = computed(() => this.props()?.description, ...(ngDevMode ? [{ debugName: "descriptionSignal" }] : /* istanbul ignore next */ []));
-    isReadonlyOrDisabledSignal = computed(() => this.props()?.readonly || this.isDisabled(), ...(ngDevMode ? [{ debugName: "isReadonlyOrDisabledSignal" }] : /* istanbul ignore next */ []));
+    isReadonlyOrDisabledSignal = computed(() => {
+        const isDisabled = this.isDisabledSignal();
+        return this.props()?.readonly || isDisabled;
+    }, ...(ngDevMode ? [{ debugName: "isReadonlyOrDisabledSignal" }] : /* istanbul ignore next */ []));
     openPickerOnTextClickSignal = computed(() => this.props()?.allowTextInput !== true, ...(ngDevMode ? [{ debugName: "openPickerOnTextClickSignal" }] : /* istanbul ignore next */ []));
     showCustomizeSignal = computed(() => !this.props()?.hideCustomize, ...(ngDevMode ? [{ debugName: "showCustomizeSignal" }] : /* istanbul ignore next */ []));
     dialogContentConfigSignal = computed(() => this.props()?.dialogContentConfig, ...(ngDevMode ? [{ debugName: "dialogContentConfigSignal" }] : /* istanbul ignore next */ []));
     customDetailsConfigSignal = computed(() => this.props()?.customDetailsConfig, ...(ngDevMode ? [{ debugName: "customDetailsConfigSignal" }] : /* istanbul ignore next */ []));
     allowCustomizeWithoutDateRangeSignal = computed(() => this.props()?.allowCustomizeWithoutDateRange ?? false, ...(ngDevMode ? [{ debugName: "allowCustomizeWithoutDateRangeSignal" }] : /* istanbul ignore next */ []));
     disableCustomizeSignal = computed(() => {
-        if (this.allowCustomizeWithoutDateRangeSignal()) {
-            return false;
-        }
-        return !this.fieldValue();
+        const fieldValue = this.fieldValueSignal();
+        return this.allowCustomizeWithoutDateRangeSignal() ? false : !fieldValue;
     }, ...(ngDevMode ? [{ debugName: "disableCustomizeSignal" }] : /* istanbul ignore next */ []));
     _setFieldValue(value) {
         try {
@@ -2019,7 +2049,7 @@ class DbxForgeCalendarDateScheduleRangeFieldComponent {
     constructor() {
         setupMetaTracking(this.elementRef, this.meta, { selector: 'dbx-schedule-selection-calendar-date-range' });
         // Convert field value to observable for store sync
-        const fieldValue$ = toObservable(this.fieldValue);
+        const fieldValue$ = toObservable(this.fieldValueSignal);
         // Sync field value → store (skip initial emission)
         this._syncSub.subscription = fieldValue$
             .pipe(skip(1), distinctUntilChanged((a, b) => isSameDateCellScheduleDateRange(a, b)))
@@ -2097,9 +2127,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
  * Uses the standard buildValueFieldInputs to bridge the ng-forge field definition
  * to the component's input signals.
  *
- * @param fieldDef - Field definition configuration
- * @param fieldDef.key - Form model key for the field
- * @returns Signal containing a Record of input names to values for ngComponentOutlet
+ * @param fieldDef - Field definition configuration.
+ * @param fieldDef.key - Form model key for the field.
+ * @returns Signal containing a Record of input names to values for ngComponentOutlet.
  */
 function calendarDateScheduleRangeFieldMapper(fieldDef) {
     const ctx = resolveValueFieldContext();
@@ -2121,12 +2151,15 @@ var calendar_schedule_forge_field_component = /*#__PURE__*/Object.freeze({
     calendarDateScheduleRangeFieldMapper: calendarDateScheduleRangeFieldMapper
 });
 
+/* eslint-disable @typescript-eslint/no-deprecated -- legacy formly day-selection field factory; replacement is dbxScheduleSelectionCalendarDateDaysForgeFormFields() */
+// COMPAT: Deprecated aliases
 /**
  * Creates form fields for selecting which days of the week are enabled in a schedule selection calendar,
  * wrapped in a responsive flex layout.
  *
+ * @returns Array of Formly field configs with toggle fields for each day of the week.
+ *
  * @deprecated Use dbxScheduleSelectionCalendarDateDaysForgeFormFields() instead.
- * @returns An array of Formly field configs with toggle fields for each day of the week
  */
 function dbxScheduleSelectionCalendarDateDaysFormFields() {
     const fields = dbxScheduleSelectionCalendarDateDaysFormDayFields();
@@ -2135,8 +2168,9 @@ function dbxScheduleSelectionCalendarDateDaysFormFields() {
 /**
  * Creates an array of toggle field configs, one for each day of the week, keyed by lowercase day name.
  *
+ * @returns The toggle Formly field configs for each day of the week.
+ *
  * @deprecated Use forge toggle fields directly.
- * @returns An array of toggle Formly field configs for each day of the week
  */
 function dbxScheduleSelectionCalendarDateDaysFormDayFields() {
     return getDaysOfWeekNames(false).map((dayOfWeekName) => {
@@ -2147,6 +2181,7 @@ function dbxScheduleSelectionCalendarDateDaysFormDayFields() {
     });
 }
 
+/* eslint-disable @typescript-eslint/no-deprecated -- legacy formly day-selection component; replacement is DbxScheduleSelectionCalendarDateDaysForgeFormComponent */
 /**
  * @deprecated Use DbxScheduleSelectionCalendarDateDaysForgeFormComponent instead.
  */
@@ -2167,6 +2202,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.11", ngImpo
                 }]
         }] });
 
+/* eslint-disable @typescript-eslint/no-deprecated -- aggregator NgModule for the deprecated DbxFormCalendarModule; replacement is provideDbxForgeCalendarFieldDeclarations() */
 const importsAndExports = [
     DbxScheduleSelectionCalendarComponent,
     DbxScheduleSelectionCalendarDateDaysComponent,